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->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) {
         // "1. If input's used flag is set, throw a TypeError."
         if (inputRequest->bodyUsed()) {
             exceptionState.throwTypeError("Cannot construct a Request with a Request object that has already been used.");
             return 0;
         }
         // "2. Set input's used flag."
         inputRequest->lockBody(PassBody);
     }
 
     // "2. Let |request| be |input|'s associated request, if |input| is a
     // Request object, and a new request otherwise."
     // "3. Set |request| to a new request whose url is |request|'s url, method

[yhirano, 2015/04/14 07:07:11]

(Mainly for module/fetch reviewers) As the spec changes, this comment  should be
changed **if we want to keep it updated**, or delete it otherwise. There are
other spec text changes as well, and I'm wondering if we can / should keep the
spec comments updated in modules/fetch. What do you think?

     // is |request|'s method, header list is a copy of |request|'s header list,
     // unsafe request flag is set, body is |request|'s body, client is entry
     // settings object, origin is entry settings object's origin, force Origin
     // header flag is set, same-origin data URL flag is set, referrer is client,
     // context is fetch, mode is |request|'s mode, credentials mode is
     // |request|'s credentials mode, and cache mode is |request|'s cache mode."
     FetchRequestData* request = createCopyOfFetchRequestDataForFetch(context, inputRequest ? inputRequest->request() : FetchRequestData::create());
 
     if (inputRequest && inputRequest->blobDataHandle() && inputRequest->isBodyConsumed()) {
         // Currently the only methods that can consume body data without
@@ skipping 217 matching lines @@
 KURL Request::url() const
 {
     // The url attribute's getter must return request's url, serialized with the exclude fragment flag set.
     if (!m_request->url().hasFragmentIdentifier())
         return m_request->url();
     KURL url(m_request->url());
     url.removeFragmentIdentifier();
     return url;
 }
 
+String Request::context() const
+{
+    // "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::referrer() const
 {
     // "The referrer attribute's getter must return the empty string if
     // request's referrer is no referrer, "about:client" if request's referrer
     // is client and request's referrer, serialized, otherwise."
     if (m_request->referrer().isNoReferrer())
         return String();
     if (m_request->referrer().isClient())
         return String("about:client");
     return m_request->referrer().referrer().referrer;
@@ skipping 62 matching lines @@
 FetchRequestData* Request::passRequestData()
 {
     ASSERT(!bodyUsed());
     lockBody(PassBody);
     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