Implement request's redirect mode and RequestRedirect for Fetch

Source/modules/fetch/Request.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/Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 21 matching lines @@
     DOMWrapperWorld& world = scriptState->world();
     if (world.isIsolatedWorld())
         request->setOrigin(world.isolatedWorldSecurityOrigin());
     else
         request->setOrigin(scriptState->executionContext()->securityOrigin());
     // FIXME: Set ForceOriginHeaderFlag.
     request->setSameOriginDataURLFlag(true);
     request->mutableReferrer()->setClient();
     request->setMode(original->mode());
     request->setCredentials(original->credentials());
+    request->setRedirect(original->redirect());
     // FIXME: Set cache mode.
-    // TODO(yhirano): Set redirect mode.
     return request;
 }
 
 Request* Request::createRequestWithRequestOrString(ScriptState* scriptState, Request* inputRequest, const String& inputString, const RequestInit& init, ExceptionState& exceptionState)
 {
     // "1. Let |temporaryBody| be null."
     RefPtr<BlobDataHandle> temporaryBody;
 
     // "2. If |input| is a Request object and |input|'s body is non-null, run
     // these substeps:"
@@ skipping 83 matching lines @@
         request->setCredentials(WebURLRequest::FetchCredentialsModeInclude);
     } else {
         if (!inputRequest)
             request->setCredentials(WebURLRequest::FetchCredentialsModeOmit);
     }
 
     // FIXME: "14. Let |cache| be |init|'s cache member if it is present, and
     // |fallbackCache| otherwise."
     // FIXME: "15. If |cache| is non-null, set |request|'s cache mode to
     // |cache|."
-    // TODO(yhirano): "16. If |init|'s redirect member is present and its is
-    // manual, throw a TypeError."
-    // TODO(yhirano): "17. Let |redirect| be |init|'s redirect member if it is
-    // present, and |fallbackRedirect| otherwise."
-    // TODO(yhirano): "18 If |redirect| is non-null, set |request|'s redirect
-    // mode to |redirect|."
-    // TODO(yhirano): "19 If |request|'s redirect mode is manual, set it to
-    // follow."
+
+    if (init.redirect == "manual") {
+        exceptionState.throwTypeError("'" + init.redirect + "' manual redirect method is unsupported.");
+        return nullptr;
+        }
+
+    if (init.redirect == "follow") {
+        request->setRedirect(WebURLRequest::FetchRedirectModeFollow);
+    } else if (init.redirect == "manual") {
+        request->setRedirect(WebURLRequest::FetchRedirectModeFollow);
+    } else if (init.redirect == "error") {
+        request->setRedirect(WebURLRequest::FetchRedirectModeError);
+    } else {
+        if (!inputRequest)
+            request->setRedirect(WebURLRequest::FetchRedirectModeFollow);
+    }
 
     // "20. If |init|'s method member is present, let |method| be it and run
     // these substeps:"
     if (!init.method.isNull()) {
         // "1. If |method| is not a method or method is a forbidden method,
         // throw a TypeError."
         if (!isValidHTTPToken(init.method)) {
             exceptionState.throwTypeError("'" + init.method + "' is not a valid HTTP method.");
             return nullptr;
         }
@@ skipping 282 matching lines @@
         return "omit";
     case WebURLRequest::FetchCredentialsModeSameOrigin:
         return "same-origin";
     case WebURLRequest::FetchCredentialsModeInclude:
         return "include";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
+String Request::redirect() const
+{
+    // "The redirect attribute's getter must return request's redirect mode."
+    switch (m_request->redirect()) {
+    case WebURLRequest::FetchRedirectModeFollow:
+        return "follow";
+    case WebURLRequest::FetchRedirectModeError:
+        return "error";
+    case WebURLRequest::FetchRedirectModeManual:
+        return "manual";
+    }
+    ASSERT_NOT_REACHED();
+    return "";
+}
+
 Request* Request::clone(ExceptionState& exceptionState) const
 {
     if (bodyUsed()) {
         exceptionState.throwTypeError("Request body is already used");
         return nullptr;
     }
 
     FetchRequestData* request = m_request->clone();
     if (blobDataHandle() && isBodyConsumed()) {
         // Currently the only methods that can consume body data without
@@ skipping 17 matching lines @@
 {
     ASSERT(!bodyUsed());
     lockBody(PassBody);
     return m_request->pass();
 }
 
 void Request::populateWebServiceWorkerRequest(WebServiceWorkerRequest& webRequest) const
 {
     webRequest.setMethod(method());
     webRequest.setRequestContext(m_request->context());
+    webRequest.setRedirectMode(m_request->redirect());
     // This strips off the fragment part.
     webRequest.setURL(url());
 
     const FetchHeaderList* headerList = m_headers->headerList();
     for (size_t i = 0, size = headerList->size(); i < size; ++i) {
         const FetchHeaderList::Header& header = headerList->entry(i);
         webRequest.appendHeader(header.first, header.second);
     }
 
     webRequest.setReferrer(m_request->referrer().referrer().referrer, static_cast<WebReferrerPolicy>(m_request->referrer().referrer().referrerPolicy));
@@ skipping 29 matching lines @@
 }
 
 DEFINE_TRACE(Request)
 {
     Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
 }
 
 } // namespace blink