blink: Rename modules/ method to prefix with get when they collide.

third_party/WebKit/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 "modules/fetch/Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/FetchUtils.h"
@@ skipping 18 matching lines @@
     FetchRequestData* request = FetchRequestData::create();
     request->setURL(original->url());
     request->setMethod(original->method());
     request->setHeaderList(original->headerList()->clone());
     request->setUnsafeRequestFlag(true);
     // FIXME: Set client.
     DOMWrapperWorld& world = scriptState->world();
     if (world.isIsolatedWorld())
         request->setOrigin(world.isolatedWorldSecurityOrigin());
     else
-        request->setOrigin(scriptState->executionContext()->securityOrigin());
+        request->setOrigin(scriptState->getExecutionContext()->getSecurityOrigin());
     // FIXME: Set ForceOriginHeaderFlag.
     request->setSameOriginDataURLFlag(true);
     request->setReferrer(original->referrer());
     request->setMode(original->mode());
     request->setCredentials(original->credentials());
     request->setRedirect(original->redirect());
     request->setIntegrity(original->integrity());
     // FIXME: Set cache mode.
     // TODO(yhirano): Set redirect mode.
     return request;
 }
 
 Request* Request::createRequestWithRequestOrString(ScriptState* scriptState, Request* inputRequest, const String& inputString, RequestInit& init, ExceptionState& exceptionState)
 {
     // - "If |input| is a Request object and it is disturbed, throw a
     //   TypeError."
     if (inputRequest && inputRequest->bodyUsed()) {
         exceptionState.throwTypeError("Cannot construct a Request with a Request object that has already been used.");
         return nullptr;
     }
     // - "Let |temporaryBody| be |input|'s request's body if |input| is a
     //   Request object, and null otherwise."
     BodyStreamBuffer* temporaryBody = inputRequest ? inputRequest->bodyBuffer() : nullptr;
 
     // "Let |request| be |input|'s request, if |input| is a Request object,
     // and a new request otherwise."
 
-    RefPtr<SecurityOrigin> origin = scriptState->executionContext()->securityOrigin();
+    RefPtr<SecurityOrigin> origin = scriptState->getExecutionContext()->getSecurityOrigin();
 
     // TODO(yhirano): Implement the following steps:
     // - "Let |window| be client."
     // - "If |request|'s window is an environment settings object and its
     //   origin is same origin with entry settings object's origin, set
     //   |window| to |request|'s window."
     // - "If |init|'s window member is present and it is not null, throw a
     //   TypeError."
     // - "If |init|'s window member is present, set |window| to no-window."
     //
@@ skipping 10 matching lines @@
     FetchRequestData* request = createCopyOfFetchRequestDataForFetch(scriptState, inputRequest ? inputRequest->request() : FetchRequestData::create());
 
     // We don't use fallback values. We set these flags directly in below.
     // - "Let |fallbackMode| be null."
     // - "Let |fallbackCredentials| be null."
     // - "Let |baseURL| be entry settings object's API base URL."
 
     // "If |input| is a string, run these substeps:"
     if (!inputRequest) {
         // "Let |parsedURL| be the result of parsing |input| with |baseURL|."
-        KURL parsedURL = scriptState->executionContext()->completeURL(inputString);
+        KURL parsedURL = scriptState->getExecutionContext()->completeURL(inputString);
         // "If |parsedURL| is failure, throw a TypeError."
         if (!parsedURL.isValid()) {
             exceptionState.throwTypeError("Failed to parse URL from " + inputString);
             return nullptr;
         }
         //   "If |parsedURL| includes credentials, throw a TypeError."
         if (!parsedURL.user().isEmpty() || !parsedURL.pass().isEmpty()) {
             exceptionState.throwTypeError("Request cannot be constructed from a URL that includes credentials: " + inputString);
             return nullptr;
         }
@@ skipping 43 matching lines @@
         // Nothing to do for the step "Let |referrer| be |init|'s referrer
         // member."
 
         if (init.referrer.referrer.isEmpty()) {
             // "If |referrer| is the empty string, set |request|'s referrer to
             // "no-referrer" and terminate these substeps."
             request->setReferrerString(FetchRequestData::noReferrerString());
         } else {
             // "Let |parsedReferrer| be the result of parsing |referrer| with
             // |baseURL|."
-            KURL parsedReferrer = scriptState->executionContext()->completeURL(init.referrer.referrer);
+            KURL parsedReferrer = scriptState->getExecutionContext()->completeURL(init.referrer.referrer);
             if (!parsedReferrer.isValid()) {
                 // "If |parsedReferrer| is failure, throw a TypeError."
                 exceptionState.throwTypeError("Referrer '" + init.referrer.referrer + "' is not a valid URL.");
                 return nullptr;
             }
             if (parsedReferrer.protocolIsAbout() && parsedReferrer.host().isEmpty() && parsedReferrer.path() == "client") {
                 // "If |parsedReferrer|'s non-relative flag is set, scheme is
                 // "about", and path contains a single string "client", set
                 // request's referrer to "client" and terminate these
                 // substeps."
@@ skipping 79 matching lines @@
         if (FetchUtils::isForbiddenMethod(init.method)) {
             exceptionState.throwTypeError("'" + init.method + "' HTTP method is unsupported.");
             return nullptr;
         }
         // "Normalize |method|."
         // "Set |request|'s method to |method|."
         request->setMethod(FetchUtils::normalizeMethod(AtomicString(init.method)));
     }
     // "Let |r| be a new Request object associated with |request| and a new
     // Headers object whose guard is "request"."
-    Request* r = Request::create(scriptState->executionContext(), request);
+    Request* r = Request::create(scriptState->getExecutionContext(), request);
     // Perform the following steps:
     // - "Let |headers| be a copy of |r|'s Headers object."
     // - "If |init|'s headers member is present, set |headers| to |init|'s
     //   headers member."
     //
     // We don't create a copy of r's Headers object when init's headers member
     // is present.
     Headers* headers = nullptr;
     if (!init.headers && init.headersDictionary.isUndefinedOrNull()) {
-        headers = r->headers()->clone();
+        headers = r->getHeaders()->clone();
     }
     // "Empty |r|'s request's header list."
     r->m_request->headerList()->clearList();
     // "If |r|'s request's mode is "no-cors", run these substeps:
     if (r->request()->mode() == WebURLRequest::FetchRequestModeNoCORS) {
         // "If |r|'s request's method is not a simple method, throw a
         // TypeError."
         if (!FetchUtils::isSimpleMethod(r->request()->method())) {
             exceptionState.throwTypeError("'" + r->request()->method() + "' is unsupported in no-cors mode.");
             return nullptr;
         }
         // "If |request|'s integrity metadata is not the empty string, throw a
         // TypeError."
         if (!request->integrity().isEmpty()) {
             exceptionState.throwTypeError("The integrity attribute is unsupported in no-cors mode.");
             return nullptr;
         }
         // "Set |r|'s Headers object's guard to "request-no-cors"."
-        r->headers()->setGuard(Headers::RequestNoCORSGuard);
+        r->getHeaders()->setGuard(Headers::RequestNoCORSGuard);
     }
     // "Fill |r|'s Headers object with |headers|. Rethrow any exceptions."
     if (init.headers) {
         ASSERT(init.headersDictionary.isUndefinedOrNull());
-        r->headers()->fillWith(init.headers.get(), exceptionState);
+        r->getHeaders()->fillWith(init.headers.get(), exceptionState);
     } else if (!init.headersDictionary.isUndefinedOrNull()) {
-        r->headers()->fillWith(init.headersDictionary, exceptionState);
+        r->getHeaders()->fillWith(init.headersDictionary, exceptionState);
     } else {
         ASSERT(headers);
-        r->headers()->fillWith(headers, exceptionState);
+        r->getHeaders()->fillWith(headers, exceptionState);
     }
     if (exceptionState.hadException())
         return nullptr;
 
     // "If either |init|'s body member is present or |temporaryBody| is
     // non-null, and |request|'s method is `GET` or `HEAD`, throw a TypeError.
     if (init.body || temporaryBody) {
         if (request->method() == HTTPNames::GET || request->method() == HTTPNames::HEAD) {
             exceptionState.throwTypeError("Request with GET/HEAD method cannot have body.");
             return nullptr;
         }
     }
 
     // "If |init|'s body member is present, run these substeps:"
     if (init.body) {
         // Perform the following steps:
         // - "Let |stream| and |Content-Type| be the result of extracting
         //   |init|'s body member."
         // - "Set |temporaryBody| to |stream|.
         // - "If |Content-Type| is non-null and |r|'s request's header list
         //   contains no header named `Content-Type`, append
         //   `Content-Type`/|Content-Type| to |r|'s Headers object. Rethrow any
         //   exception."
         temporaryBody = new BodyStreamBuffer(init.body.release());
-        if (!init.contentType.isEmpty() && !r->headers()->has(HTTPNames::Content_Type, exceptionState)) {
-            r->headers()->append(HTTPNames::Content_Type, init.contentType, exceptionState);
+        if (!init.contentType.isEmpty() && !r->getHeaders()->has(HTTPNames::Content_Type, exceptionState)) {
+            r->getHeaders()->append(HTTPNames::Content_Type, init.contentType, exceptionState);
         }
         if (exceptionState.hadException())
             return nullptr;
     }
 
     // "Set |r|'s request's body to |temporaryBody|.
     if (temporaryBody)
         r->m_request->setBuffer(temporaryBody);
 
     // https://w3c.github.io/webappsec-credential-management/#monkey-patching-fetch-3
@@ skipping 37 matching lines @@
     return create(scriptState, input.getAsRequest(), init, exceptionState);
 }
 
 Request* Request::create(ScriptState* scriptState, const String& input, ExceptionState& exceptionState)
 {
     return create(scriptState, input, Dictionary(), exceptionState);
 }
 
 Request* Request::create(ScriptState* scriptState, const String& input, const Dictionary& init, ExceptionState& exceptionState)
 {
-    RequestInit requestInit(scriptState->executionContext(), init, exceptionState);
+    RequestInit requestInit(scriptState->getExecutionContext(), init, exceptionState);
     return createRequestWithRequestOrString(scriptState, nullptr, input, requestInit, exceptionState);
 }
 
 Request* Request::create(ScriptState* scriptState, Request* input, ExceptionState& exceptionState)
 {
     return create(scriptState, input, Dictionary(), exceptionState);
 }
 
 Request* Request::create(ScriptState* scriptState, Request* input, const Dictionary& init, ExceptionState& exceptionState)
 {
-    RequestInit requestInit(scriptState->executionContext(), init, exceptionState);
+    RequestInit requestInit(scriptState->getExecutionContext(), init, exceptionState);
     return createRequestWithRequestOrString(scriptState, input, String(), requestInit, exceptionState);
 }
 
 Request* Request::create(ExecutionContext* context, FetchRequestData* request)
 {
     return new Request(context, request);
 }
 
 Request::Request(ExecutionContext* context, FetchRequestData* request)
     : Body(context)
@@ skipping 178 matching lines @@
     return m_request->integrity();
 }
 
 Request* Request::clone(ExceptionState& exceptionState)
 {
     if (isBodyLocked() || bodyUsed()) {
         exceptionState.throwTypeError("Request body is already used");
         return nullptr;
     }
 
-    FetchRequestData* request = m_request->clone(executionContext());
+    FetchRequestData* request = m_request->clone(getExecutionContext());
     Headers* headers = Headers::create(request->headerList());
     headers->setGuard(m_headers->getGuard());
-    return new Request(executionContext(), request, headers);
+    return new Request(getExecutionContext(), request, headers);
 }
 
 FetchRequestData* Request::passRequestData()
 {
     ASSERT(!bodyUsed());
-    return m_request->pass(executionContext());
+    return m_request->pass(getExecutionContext());
 }
 
 bool Request::hasBody() const
 {
     return bodyBuffer();
 }
 
 void Request::stop()
 {
     if (bodyBuffer())
@@ skipping 24 matching lines @@
 }
 
 DEFINE_TRACE(Request)
 {
     Body::trace(visitor);
     visitor->trace(m_request);
     visitor->trace(m_headers);
 }
 
 } // namespace blink