Implement Request.context for Fetch API

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 16 matching lines @@
     request->setURL(original->url());
     request->setMethod(original->method());
     request->setHeaderList(original->headerList()->clone());
     request->setUnsafeRequestFlag(true);
     request->setBlobDataHandle(original->blobDataHandle());
     // FIXME: Set client.
     request->setOrigin(SecurityOrigin::create(context->url()));
     // FIXME: Set ForceOriginHeaderFlag.
     request->setSameOriginDataURLFlag(true);
     request->mutableReferrer()->setClient();
-    request->setContext(WebURLRequest::RequestContextFetch);
+    request->setContext(original->context());

[hiroshige, 2015/04/07 03:56:11]

Should this be WebURLRequest::RequestContextUnspecified? (please double-check)
Spec: https://fetch.spec.whatwg.org/#dom-request
Step 4:
Set request to a new request whose url is request's url, ..., context is the
empty string, ...

[shiva.jm, 2015/04/09 09:16:22]

I think we no need to set the context here, it will be set in the constructor
"FetchRequestData::FetchRequestData()", when FetchRequestData::create() is
called.

[hiroshige, 2015/04/09 17:43:21]

Then we have to remove the line of
here.

[shiva.jm, 2015/04/10 09:27:10]

The call to setContext() should be present here, no need to remove, since here a
copy of original request is made.
Actually in my previous comment "no need to set the context here", means no need
to set the context with WebURLRequest::RequestContextUnspecified, since context
will be set with WebURLRequest::RequestContextUnspecified in the constructor
"FetchRequestData::FetchRequestData()", when FetchRequestData::create() is
called.
sorry, i did not put correctly in my previous comment.

[hiroshige, 2015/04/10 11:24:23]

I still think we must NOT set context to |original->context()| here, because
createCopyOfFetchRequestDataForFetch() is not a general copy construction
function, but it corresponds to Step 4 of Request() constructor in the spec
https://fetch.spec.whatwg.org/#dom-request:
Here, the spec states "context is the empty string", so |request|'s context must
remain the empty string here.

From another point of view,
(new Request(event.request)).context
must be the empty string due to the Step 4 of the Request() constructor I cited
above (because this is synthetic Request object).
In this CL (Patch Set 3), (new Request(event.request)).context is
event.request.context, which can be e.g. 'script' in serviceworker.
Removing this setContext() here leads (new Request(event.request)).context to be
the empty string.
(For test code see https://codereview.chromium.org/1079493002/, Patch Set 2. The
added tests fails when we setContext() here.)

     request->setMode(original->mode());
     request->setCredentials(original->credentials());
     // FIXME: Set cache mode.
     return request;
 }
 
 Request* Request::createRequestWithRequestOrString(ExecutionContext* context, Request* inputRequest, const String& inputString, const RequestInit& init, ExceptionState& exceptionState)
 {
     // "1. If input is a Request object, run these substeps:"
     if (inputRequest) {
@@ skipping 257 matching lines @@
     case WebURLRequest::FetchRequestModeNoCORS:
         return "no-cors";
     case WebURLRequest::FetchRequestModeCORS:
     case WebURLRequest::FetchRequestModeCORSWithForcedPreflight:
         return "cors";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
+String Request::context() const

[hiroshige, 2015/04/07 03:56:11]

Move context() above referrer() to match the order with the spec.

[shiva.jm, 2015/04/09 09:16:22]

Done.

+{
+    // "The context attribute's getter must return request's context"
+    switch (m_request->context()) {
+    case WebURLRequest::RequestContextUnspecified:
+        return "";
+    case WebURLRequest::RequestContextAudio:
+        return "audio";
+    case WebURLRequest::RequestContextBeacon:
+        return "beacon";
+    case WebURLRequest::RequestContextCSPReport:
+        return "cspreport";
+    case WebURLRequest::RequestContextDownload:
+        return "download";
+    case WebURLRequest::RequestContextEmbed:
+        return "embed";
+    case WebURLRequest::RequestContextEventSource:
+        return "eventsource";
+    case WebURLRequest::RequestContextFavicon:
+        return "favicon";
+    case WebURLRequest::RequestContextFetch:
+        return "fetch";
+    case WebURLRequest::RequestContextFont:
+        return "font";
+    case WebURLRequest::RequestContextForm:
+        return "form";
+    case WebURLRequest::RequestContextFrame:
+        return "frame";
+    case WebURLRequest::RequestContextHyperlink:
+        return "hyperlink";
+    case WebURLRequest::RequestContextIframe:
+        return "iframe";
+    case WebURLRequest::RequestContextImage:
+        return "image";
+    case WebURLRequest::RequestContextImageSet:
+        return "imageset";
+    case WebURLRequest::RequestContextImport:
+        return "import";
+    case WebURLRequest::RequestContextInternal:
+        return "internal";
+    case WebURLRequest::RequestContextLocation:
+        return "location";
+    case WebURLRequest::RequestContextManifest:
+        return "manifest";
+    case WebURLRequest::RequestContextObject:
+        return "object";
+    case WebURLRequest::RequestContextPing:
+        return "ping";
+    case WebURLRequest::RequestContextPlugin:
+        return "plugin";
+    case WebURLRequest::RequestContextPrefetch:
+        return "prefetch";
+    case WebURLRequest::RequestContextScript:
+        return "script";
+    case WebURLRequest::RequestContextServiceWorker:
+        return "serviceworker";
+    case WebURLRequest::RequestContextSharedWorker:
+        return "sharedworker";
+    case WebURLRequest::RequestContextSubresource:
+        return "subresource";
+    case WebURLRequest::RequestContextStyle:
+        return "style";
+    case WebURLRequest::RequestContextTrack:
+        return "track";
+    case WebURLRequest::RequestContextVideo:
+        return "video";
+    case WebURLRequest::RequestContextWorker:
+        return "worker";
+    case WebURLRequest::RequestContextXMLHttpRequest:
+        return "xmlhttprequest";
+    case WebURLRequest::RequestContextXSLT:
+        return "xslt";
+    }
+    ASSERT_NOT_REACHED();
+    return "";
+}
+
 String Request::credentials() const
 {
     // "The credentials attribute's getter must return the value corresponding
     // to the first matching statement, switching on request's credentials
     // mode:"
     switch (m_request->credentials()) {
     case WebURLRequest::FetchCredentialsModeOmit:
         return "omit";
     case WebURLRequest::FetchCredentialsModeSameOrigin:
         return "same-origin";
@@ skipping 22 matching lines @@
 FetchRequestData* Request::passRequestData()
 {
     ASSERT(!bodyUsed());
     setBodyUsed();
     return m_request->pass();
 }
 
 void Request::populateWebServiceWorkerRequest(WebServiceWorkerRequest& webRequest) const
 {
     webRequest.setMethod(method());
+    webRequest.setRequestContext(m_request->context());
     // 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 28 matching lines @@
 }
 
 DEFINE_TRACE(Request)
 {
     Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
 }
 
 } // namespace blink