remove useless refactor

Author: unusual-thoughts

tower-http/src/follow_redirect/mod.rs

@@ -341,11 +341,21 @@ where
 
     fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
         let service = self.inner.clone();
-        let mut request = RedirectingRequest::new(
-            mem::replace(&mut self.inner, service),
-            self.policy.clone(),
-            &mut req,
-        );
+        let service = mem::replace(&mut self.inner, service);
+        let mut policy = self.policy.clone();
+        let mut body = BodyRepr::None;
+        body.try_clone_from(req.body(), &policy);
+        policy.on_request(&mut req);
+
+        let mut request = RedirectingRequest {
+            method: req.method().clone(),
+            uri: req.uri().clone(),
+            version: req.version(),
+            headers: req.headers().clone(),
+            service,
+            body,
+            policy,
+        };
         ResponseFuture {
             future: Either::Left(request.service.call(req)),
             request,
@@ -380,65 +390,8 @@ where
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.project();
         let mut res = ready!(this.future.as_mut().poll(cx)?);
-        CB::on_response(&mut res, &this.request);
-
-        match this.request.handle_response(&mut res) {
-            Ok(Some(pending)) => {
-                this.future.set(Either::Right(pending));
-                cx.waker().wake_by_ref();
-                Poll::Pending
-            }
-            Ok(None) => Poll::Ready(Ok(res)),
-            Err(e) => Poll::Ready(Err(e)),
-        }
-    }
-}
-
-/// Wraps a [`http::Request`] with a [`policy::Policy`] to apply,
-/// and an underlying service in case further requests are required.
-#[derive(Debug)]
-struct RedirectingRequest<S, B, P> {
-    service: S,
-    policy: P,
-    method: Method,
-    uri: Uri,
-    version: Version,
-    headers: HeaderMap<HeaderValue>,
-    body: BodyRepr<B>,
-}
-
-impl<S, ReqBody, ResBody, P> RedirectingRequest<S, ReqBody, P>
-where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
-    ReqBody: Body + Default,
-    P: Policy<ReqBody, S::Error>,
-{
-    #[inline]
-    /// Build a [`RedirectingRequest`] from a service, attached policy and original [`http::Request`]
-    fn new(service: S, mut policy: P, req: &mut Request<ReqBody>) -> Self {
-        let mut body = BodyRepr::None;
-        body.try_clone_from(req.body(), &policy);
-        policy.on_request(req);
-        Self {
-            method: req.method().clone(),
-            uri: req.uri().clone(),
-            version: req.version(),
-            headers: req.headers().clone(),
-            service,
-            body,
-            policy,
-        }
-    }
+        CB::on_response(&mut res, this.request);
 
-    /// Handle an incoming [`http::Response`] from the underlying service.
-    /// Returns an error if the policy failed.
-    /// Returns a future if there is more work to do.
-    /// Otherwise, returns an empty result.
-    #[inline]
-    fn handle_response(
-        &mut self,
-        res: &mut Response<ResBody>,
-    ) -> Result<Option<Oneshot<S, Request<ReqBody>>>, S::Error> {
         let drop_payload_headers = |headers: &mut HeaderMap| {
             for header in &[
                 CONTENT_TYPE,
@@ -453,63 +406,84 @@ where
             StatusCode::MOVED_PERMANENTLY | StatusCode::FOUND => {
                 // User agents MAY change the request method from POST to GET
                 // (RFC 7231 section 6.4.2. and 6.4.3.).
-                if self.method == Method::POST {
-                    self.method = Method::GET;
-                    self.body = BodyRepr::Empty;
-                    drop_payload_headers(&mut self.headers);
+                if this.request.method == Method::POST {
+                    this.request.method = Method::GET;
+                    this.request.body = BodyRepr::Empty;
+                    drop_payload_headers(&mut this.request.headers);
                 }
             }
             StatusCode::SEE_OTHER => {
                 // A user agent can perform a GET or HEAD request (RFC 7231 section 6.4.4.).
-                if self.method != Method::HEAD {
-                    self.method = Method::GET;
+                if this.request.method != Method::HEAD {
+                    this.request.method = Method::GET;
                 }
-                self.body = BodyRepr::Empty;
-                drop_payload_headers(&mut self.headers);
+                this.request.body = BodyRepr::Empty;
+                drop_payload_headers(&mut this.request.headers);
             }
             StatusCode::TEMPORARY_REDIRECT | StatusCode::PERMANENT_REDIRECT => {}
-            _ => return Ok(None),
+            _ => return Poll::Ready(Ok(res)),
         };
 
-        let body = if let Some(body) = self.body.take() {
+        let body = if let Some(body) = this.request.body.take() {
             body
         } else {
-            return Ok(None);
+            return Poll::Ready(Ok(res));
         };
 
         let location = res
             .headers()
             .get(&LOCATION)
-            .and_then(|loc| resolve_uri(str::from_utf8(loc.as_bytes()).ok()?, &self.uri));
+            .and_then(|loc| resolve_uri(str::from_utf8(loc.as_bytes()).ok()?, &this.request.uri));
         let location = if let Some(loc) = location {
             loc
         } else {
-            return Ok(None);
+            return Poll::Ready(Ok(res));
         };
 
         let attempt = Attempt {
             status: res.status(),
             location: &location,
-            previous: &self.uri,
+            previous: &this.request.uri,
         };
-        match self.policy.redirect(&attempt)? {
+        match this.request.policy.redirect(&attempt)? {
             Action::Follow => {
-                self.uri = location;
-                self.body.try_clone_from(&body, &self.policy);
+                this.request.uri = location;
+                this.request
+                    .body
+                    .try_clone_from(&body, &this.request.policy);
 
                 let mut req = Request::new(body);
-                *req.uri_mut() = self.uri.clone();
-                *req.method_mut() = self.method.clone();
-                *req.version_mut() = self.version;
-                *req.headers_mut() = self.headers.clone();
-                self.policy.on_request(&mut req);
-                Ok(Some(Oneshot::new(self.service.clone(), req)))
+                *req.uri_mut() = this.request.uri.clone();
+                *req.method_mut() = this.request.method.clone();
+                *req.version_mut() = this.request.version;
+                *req.headers_mut() = this.request.headers.clone();
+                this.request.policy.on_request(&mut req);
+                this.future.set(Either::Right(Oneshot::new(
+                    this.request.service.clone(),
+                    req,
+                )));
+
+                cx.waker().wake_by_ref();
+                Poll::Pending
             }
-            Action::Stop => Ok(None),
+            Action::Stop => Poll::Ready(Ok(res)),
         }
     }
 }
 
+/// Wraps a [`http::Request`] with a [`policy::Policy`] to apply,
+/// and an underlying service in case further requests are required.
+#[derive(Debug)]
+struct RedirectingRequest<S, B, P> {
+    service: S,
+    policy: P,
+    method: Method,
+    uri: Uri,
+    version: Version,
+    headers: HeaderMap<HeaderValue>,
+    body: BodyRepr<B>,
+}
+
 /// Response [`Extensions`][http::Extensions] value that represents the effective request URI of
 /// a response returned by a [`FollowRedirect`] middleware.
 ///