[3/3 blink] Support redirect option of Request and "opaqueredirect" response type.

Source/modules/fetch/FetchManager.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/fetch/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 19 matching lines @@
 #include "modules/fetch/ResponseInit.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
 
 namespace blink {
 
-namespace {
-
-bool IsRedirectStatusCode(int statusCode)
-{
-    return (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307 || statusCode == 308);
-}
-
-} // namespace
-
 class FetchManager::Loader final : public NoBaseWillBeGarbageCollectedFinalized<FetchManager::Loader>, public ThreadableLoaderClient, public ContextLifecycleObserver {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(FetchManager::Loader);
 public:
     static PassOwnPtrWillBeRawPtr<Loader> create(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request)
     {
         return adoptPtrWillBeNoop(new Loader(executionContext, fetchManager, resolver, request));
     }
 
     ~Loader() override;
     DECLARE_VIRTUAL_TRACE();
@@ skipping 45 matching lines @@
 DEFINE_TRACE(FetchManager::Loader)
 {
     visitor->trace(m_fetchManager);
     visitor->trace(m_resolver);
     visitor->trace(m_request);
     ContextLifecycleObserver::trace(visitor);
 }
 
 void FetchManager::Loader::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
-    ASSERT(handle);
-
     m_responseHttpStatusCode = response.httpStatusCode();
 
     // Recompute the tainting if the request was redirected to a different
     // origin.
     if (!SecurityOrigin::create(response.url())->isSameSchemeHostPort(m_request->origin().get())) {
         switch (m_request->mode()) {
         case WebURLRequest::FetchRequestModeSameOrigin:
             ASSERT_NOT_REACHED();
             break;
         case WebURLRequest::FetchRequestModeNoCORS:
             m_request->setResponseTainting(FetchRequestData::OpaqueTainting);
             break;
         case WebURLRequest::FetchRequestModeCORS:
         case WebURLRequest::FetchRequestModeCORSWithForcedPreflight:
             m_request->setResponseTainting(FetchRequestData::CORSTainting);
             break;
         }
     }
-    FetchResponseData* responseData = FetchResponseData::createWithBuffer(new BodyStreamBuffer(createFetchDataConsumerHandleFromWebHandle(handle)));
+
+    bool isRedirectResponse = false;
+    FetchResponseData* responseData = nullptr;
+    if (!handle) {
+        ASSERT(IsRedirectStatusCode(m_responseHttpStatusCode));
+        ASSERT(m_request->redirect() == WebURLRequest::FetchRedirectModeManual);
+        isRedirectResponse = true;
+        responseData = FetchResponseData::create();
+    } else {
+        responseData = FetchResponseData::createWithBuffer(new BodyStreamBuffer(createFetchDataConsumerHandleFromWebHandle(handle)));
+    }
     responseData->setStatus(response.httpStatusCode());
     responseData->setStatusMessage(response.httpStatusText());
     for (auto& it : response.httpHeaderFields())
         responseData->headerList()->append(it.key, it.value);
     responseData->setURL(response.url());
     responseData->setMIMEType(response.mimeType());
 
     FetchResponseData* taintedResponse = nullptr;
 
-    if (IsRedirectStatusCode(m_responseHttpStatusCode)) {
-        Vector<String> locations;
-        responseData->headerList()->getAll("location", locations);
-        if (locations.size() > 1) {
-            performNetworkError("Multiple Location header.");
-            return;
-        }
-        if (locations.size() == 1) {
-            KURL locationURL(m_request->url(), locations[0]);
-            if (!locationURL.isValid()) {
-                performNetworkError("Invalid Location header.");
-                return;
-            }
-            ASSERT(m_request->redirect() == WebURLRequest::FetchRedirectModeManual);
-            taintedResponse = responseData->createOpaqueRedirectFilteredResponse();
-        }
-        // When the location header doesn't exist, we don't treat the response
-        // as a redirect response, and execute tainting.
-    }
-    if (!taintedResponse) {
+    if (isRedirectResponse) {
+        taintedResponse = responseData->createOpaqueRedirectFilteredResponse();
+    } else {
         switch (m_request->tainting()) {
         case FetchRequestData::BasicTainting:
             taintedResponse = responseData->createBasicFilteredResponse();
             break;
         case FetchRequestData::CORSTainting:
             taintedResponse = responseData->createCORSFilteredResponse();
             break;
         case FetchRequestData::OpaqueTainting:
             taintedResponse = responseData->createOpaqueFilteredResponse();
             break;
         }
     }
     Response* r = Response::create(m_resolver->executionContext(), taintedResponse);
     r->headers()->setGuard(Headers::ImmutableGuard);
     m_resolver->resolve(r);
     m_resolver.clear();
+
+    if (isRedirectResponse) {
+        // There is no need to read the body of redirect response because there
+        // is no way to read the body of opaque-redirect filtered response's
+        // internal response.
+        // TODO(horo): If we support any API which expose the internal body, we
+        // will have to read the body. And also HTTPCache changes will be needed
+        // because it doesn't store the body of redirect responses.
+        notifyFinished();
+    }
 }
 
 void FetchManager::Loader::didFinishLoading(unsigned long, double)
 {
     ASSERT(!m_failed);
     m_finished = true;
 
     if (document() && document()->frame() && document()->frame()->page()
         && m_responseHttpStatusCode >= 200 && m_responseHttpStatusCode < 300) {
         document()->frame()->page()->chromeClient().ajaxSucceeded(document()->frame());
@@ skipping 298 matching lines @@
 
 DEFINE_TRACE(FetchManager)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContext);
     visitor->trace(m_loaders);
 #endif
 }
 
 } // namespace blink