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

third_party/WebKit/Source/core/xmlhttprequest/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 157 matching lines @@
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_xhr);
     }
 
 private:
     BlobLoader(XMLHttpRequest* xhr, PassRefPtr<BlobDataHandle> handle)
         : m_xhr(xhr)
         , m_loader(FileReaderLoader::ReadByClient, this)
     {
-        m_loader.start(m_xhr->executionContext(), handle);
+        m_loader.start(m_xhr->getExecutionContext(), handle);
     }
 
     Member<XMLHttpRequest> m_xhr;
     FileReaderLoader m_loader;
 };
 
 XMLHttpRequest* XMLHttpRequest::create(ScriptState* scriptState)
 {
-    ExecutionContext* context = scriptState->executionContext();
+    ExecutionContext* context = scriptState->getExecutionContext();
     DOMWrapperWorld& world = scriptState->world();
     RefPtr<SecurityOrigin> isolatedWorldSecurityOrigin = world.isIsolatedWorld() ? world.isolatedWorldSecurityOrigin() : nullptr;
     XMLHttpRequest* xmlHttpRequest = new XMLHttpRequest(context, isolatedWorldSecurityOrigin);
     xmlHttpRequest->suspendIfNeeded();
 
     return xmlHttpRequest;
 }
 
 XMLHttpRequest* XMLHttpRequest::create(ExecutionContext* context)
 {
@@ skipping 30 matching lines @@
     ASSERT(IS_EAGERLY_FINALIZED());
 #endif
 }
 
 XMLHttpRequest::~XMLHttpRequest()
 {
 }
 
 Document* XMLHttpRequest::document() const
 {
-    ASSERT(executionContext()->isDocument());
-    return toDocument(executionContext());
+    ASSERT(getExecutionContext()->isDocument());
+    return toDocument(getExecutionContext());
 }
 
-SecurityOrigin* XMLHttpRequest::securityOrigin() const
+SecurityOrigin* XMLHttpRequest::getSecurityOrigin() const
 {
-    return m_isolatedWorldSecurityOrigin ? m_isolatedWorldSecurityOrigin.get() : executionContext()->securityOrigin();
+    return m_isolatedWorldSecurityOrigin ? m_isolatedWorldSecurityOrigin.get() : getExecutionContext()->getSecurityOrigin();
 }
 
 XMLHttpRequest::State XMLHttpRequest::readyState() const
 {
     return m_state;
 }
 
 ScriptString XMLHttpRequest::responseText(ExceptionState& exceptionState)
 {
     if (m_responseTypeCode != ResponseTypeDefault && m_responseTypeCode != ResponseTypeText) {
@@ skipping 14 matching lines @@
     return m_responseText;
 }
 
 void XMLHttpRequest::initResponseDocument()
 {
     // The W3C spec requires the final MIME type to be some valid XML type, or text/html.
     // If it is text/html, then the responseType of "document" must have been supplied explicitly.
     bool isHTML = responseIsHTML();
     if ((m_response.isHTTP() && !responseIsXML() && !isHTML)
         || (isHTML && m_responseTypeCode == ResponseTypeDefault)
-        || executionContext()->isWorkerGlobalScope()) {
+        || getExecutionContext()->isWorkerGlobalScope()) {
         m_responseDocument = nullptr;
         return;
     }
 
     DocumentInit init = DocumentInit::fromContext(document()->contextDocument(), m_url);
     if (isHTML)
         m_responseDocument = HTMLDocument::create(init);
     else
         m_responseDocument = XMLDocument::create(init);
 
     // FIXME: Set Last-Modified.
-    m_responseDocument->setSecurityOrigin(securityOrigin());
+    m_responseDocument->setSecurityOrigin(getSecurityOrigin());
     m_responseDocument->setContextFeatures(document()->contextFeatures());
     m_responseDocument->setMimeType(finalResponseMIMETypeWithFallback());
 }
 
 Document* XMLHttpRequest::responseXML(ExceptionState& exceptionState)
 {
     if (m_responseTypeCode != ResponseTypeDefault && m_responseTypeCode != ResponseTypeDocument) {
         exceptionState.throwDOMException(InvalidStateError, "The value is only accessible if the object's 'responseType' is '' or 'document' (was '" + responseType() + "').");
         return nullptr;
     }
@@ skipping 82 matching lines @@
     if (m_error || (m_state != LOADING && m_state != DONE))
         return nullptr;
 
     return m_responseLegacyStream;
 }
 
 void XMLHttpRequest::setTimeout(unsigned timeout, ExceptionState& exceptionState)
 {
     // FIXME: Need to trigger or update the timeout Timer here, if needed. http://webkit.org/b/98156
     // XHR2 spec, 4.7.3. "This implies that the timeout attribute can be set while fetching is in progress. If that occurs it will still be measured relative to the start of fetching."
-    if (executionContext()->isDocument() && !m_async) {
+    if (getExecutionContext()->isDocument() && !m_async) {
         exceptionState.throwDOMException(InvalidAccessError, "Timeouts cannot be set for synchronous requests made from a document.");
         return;
     }
 
     m_timeoutMilliseconds = timeout;
 
     // From http://www.w3.org/TR/XMLHttpRequest/#the-timeout-attribute:
     // Note: This implies that the timeout attribute can be set while fetching is in progress. If
     // that occurs it will still be measured relative to the start of fetching.
     //
     // The timeout may be overridden after send.
     if (m_loader)
         m_loader->overrideTimeout(timeout);
 }
 
 void XMLHttpRequest::setResponseType(const String& responseType, ExceptionState& exceptionState)
 {
     if (m_state >= LOADING) {
         exceptionState.throwDOMException(InvalidStateError, "The response type cannot be set if the object's state is LOADING or DONE.");
         return;
     }
 
     // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
     // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
-    if (!m_async && executionContext()->isDocument()) {
+    if (!m_async && getExecutionContext()->isDocument()) {
         exceptionState.throwDOMException(InvalidAccessError, "The response type cannot be changed for synchronous requests made from a document.");
         return;
     }
 
     if (responseType == "") {
         m_responseTypeCode = ResponseTypeDefault;
     } else if (responseType == "text") {
         m_responseTypeCode = ResponseTypeText;
     } else if (responseType == "json") {
         m_responseTypeCode = ResponseTypeJSON;
@@ skipping 63 matching lines @@
 void XMLHttpRequest::changeState(State newState)
 {
     if (m_state != newState) {
         m_state = newState;
         dispatchReadyStateChangeEvent();
     }
 }
 
 void XMLHttpRequest::dispatchReadyStateChangeEvent()
 {
-    if (!executionContext())
+    if (!getExecutionContext())
         return;
 
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
     if (m_async || (m_state <= OPENED || m_state == DONE)) {
-        TRACE_EVENT1("devtools.timeline", "XHRReadyStateChange", "data", InspectorXhrReadyStateChangeEvent::data(executionContext(), this));
+        TRACE_EVENT1("devtools.timeline", "XHRReadyStateChange", "data", InspectorXhrReadyStateChangeEvent::data(getExecutionContext(), this));
         XMLHttpRequestProgressEventThrottle::DeferredEventAction action = XMLHttpRequestProgressEventThrottle::Ignore;
         if (m_state == DONE) {
             if (m_error)
                 action = XMLHttpRequestProgressEventThrottle::Clear;
             else
                 action = XMLHttpRequestProgressEventThrottle::Flush;
         }
         m_progressEventThrottle->dispatchReadyStateChangeEvent(Event::create(EventTypeNames::readystatechange), action);
         TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
     }
 
     if (m_state == DONE && !m_error) {
-        TRACE_EVENT1("devtools.timeline", "XHRLoad", "data", InspectorXhrLoadEvent::data(executionContext(), this));
+        TRACE_EVENT1("devtools.timeline", "XHRLoad", "data", InspectorXhrLoadEvent::data(getExecutionContext(), this));
         dispatchProgressEventFromSnapshot(EventTypeNames::load);
         dispatchProgressEventFromSnapshot(EventTypeNames::loadend);
         TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
     }
 }
 
 void XMLHttpRequest::setWithCredentials(bool value, ExceptionState& exceptionState)
 {
     if (m_state > OPENED || m_loader) {
         exceptionState.throwDOMException(InvalidStateError,  "The value may only be set if the object's state is UNSENT or OPENED.");
         return;
     }
 
     // FIXME: According to XMLHttpRequest Level 2 we should throw InvalidAccessError exception here.
     // However for time being only print warning message to warn web developers.
     if (!m_async)
-        Deprecation::countDeprecation(executionContext(), UseCounter::SyncXHRWithCredentials);
+        Deprecation::countDeprecation(getExecutionContext(), UseCounter::SyncXHRWithCredentials);
 
     m_includeCredentials = value;
 }
 
 void XMLHttpRequest::open(const AtomicString& method, const String& urlString, ExceptionState& exceptionState)
 {
-    open(method, executionContext()->completeURL(urlString), true, exceptionState);
+    open(method, getExecutionContext()->completeURL(urlString), true, exceptionState);
 }
 
 void XMLHttpRequest::open(const AtomicString& method, const String& urlString, bool async, const String& username, const String& password, ExceptionState& exceptionState)
 {
-    KURL url(executionContext()->completeURL(urlString));
+    KURL url(getExecutionContext()->completeURL(urlString));
     if (!username.isNull())
         url.setUser(username);
     if (!password.isNull())
         url.setPass(password);
 
     open(method, url, async, exceptionState);
 }
 
 void XMLHttpRequest::open(const AtomicString& method, const KURL& url, bool async, ExceptionState& exceptionState)
 {
@@ skipping 10 matching lines @@
     if (!isValidHTTPToken(method)) {
         exceptionState.throwDOMException(SyntaxError, "'" + method + "' is not a valid HTTP method.");
         return;
     }
 
     if (FetchUtils::isForbiddenMethod(method)) {
         exceptionState.throwSecurityError("'" + method + "' HTTP method is unsupported.");
         return;
     }
 
-    if (!ContentSecurityPolicy::shouldBypassMainWorld(executionContext()) && !executionContext()->contentSecurityPolicy()->allowConnectToSource(url)) {
+    if (!ContentSecurityPolicy::shouldBypassMainWorld(getExecutionContext()) && !getExecutionContext()->contentSecurityPolicy()->allowConnectToSource(url)) {
         // We can safely expose the URL to JavaScript, as these checks happen synchronously before redirection. JavaScript receives no new information.
         exceptionState.throwSecurityError("Refused to connect to '" + url.elidedString() + "' because it violates the document's Content Security Policy.");
         return;
     }
 
-    if (!async && executionContext()->isDocument()) {
+    if (!async && getExecutionContext()->isDocument()) {
         if (document()->settings() && !document()->settings()->syncXHRInDocumentsEnabled()) {
             exceptionState.throwDOMException(InvalidAccessError, "Synchronous requests are disabled for this page.");
             return;
         }
 
         // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
         // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
         if (m_responseTypeCode != ResponseTypeDefault) {
             exceptionState.throwDOMException(InvalidAccessError, "Synchronous requests from a document must not set a response type.");
             return;
         }
 
         // Similarly, timeouts are disabled for synchronous requests as well.
         if (m_timeoutMilliseconds > 0) {
             exceptionState.throwDOMException(InvalidAccessError, "Synchronous requests must not set a timeout.");
             return;
         }
 
         // Here we just warn that firing sync XHR's may affect responsiveness.
         // Eventually sync xhr will be deprecated and an "InvalidAccessError" exception thrown.
         // Refer : https://xhr.spec.whatwg.org/#sync-warning
         // Use count for XHR synchronous requests on main thread only.
         if (!document()->processingBeforeUnload())
-            Deprecation::countDeprecation(executionContext(), UseCounter::XMLHttpRequestSynchronousInNonWorkerOutsideBeforeUnload);
+            Deprecation::countDeprecation(getExecutionContext(), UseCounter::XMLHttpRequestSynchronousInNonWorkerOutsideBeforeUnload);
     }
 
     m_method = FetchUtils::normalizeMethod(method);
 
     m_url = url;
 
     m_async = async;
 
     ASSERT(!m_loader);
 
     // Check previous state to avoid dispatching readyState event
     // when calling open several times in a row.
     if (previousState != OPENED)
         changeState(OPENED);
     else
         m_state = OPENED;
 }
 
 bool XMLHttpRequest::initSend(ExceptionState& exceptionState)
 {
-    if (!executionContext())
+    if (!getExecutionContext())
         return false;
 
     if (m_state != OPENED || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, "The object's state must be OPENED.");
         return false;
     }
 
     m_error = false;
     return true;
 }
 
 void XMLHttpRequest::send(const ArrayBufferOrArrayBufferViewOrBlobOrDocumentOrStringOrFormData& body, ExceptionState& exceptionState)
 {
-    InspectorInstrumentation::willSendXMLHttpRequest(executionContext(), url());
+    InspectorInstrumentation::willSendXMLHttpRequest(getExecutionContext(), url());
 
     if (body.isNull()) {
         send(String(), exceptionState);
         return;
     }
 
     if (body.isArrayBuffer()) {
         send(body.getAsArrayBuffer().get(), exceptionState);
         return;
     }
@@ skipping 203 matching lines @@
     // Also, only async requests support upload progress events.
     bool uploadEvents = false;
     if (m_async) {
         dispatchProgressEvent(EventTypeNames::loadstart, 0, 0);
         if (httpBody && m_upload) {
             uploadEvents = m_upload->hasEventListeners();
             m_upload->dispatchEvent(ProgressEvent::create(EventTypeNames::loadstart, false, 0, 0));
         }
     }
 
-    m_sameOriginRequest = securityOrigin()->canRequestNoSuborigin(m_url);
+    m_sameOriginRequest = getSecurityOrigin()->canRequestNoSuborigin(m_url);
 
     // We also remember whether upload events should be allowed for this request in case the upload listeners are
     // added after the request is started.
     m_uploadEventsAllowed = m_sameOriginRequest || uploadEvents || !FetchUtils::isSimpleRequest(m_method, m_requestHeaders);
 
-    ASSERT(executionContext());
-    ExecutionContext& executionContext = *this->executionContext();
+    ASSERT(getExecutionContext());
+    ExecutionContext& executionContext = *this->getExecutionContext();
 
     ResourceRequest request(m_url);
     request.setHTTPMethod(m_method);
     request.setRequestContext(WebURLRequest::RequestContextXMLHttpRequest);
     request.setFetchCredentialsMode(m_includeCredentials ? WebURLRequest::FetchCredentialsModeInclude : WebURLRequest::FetchCredentialsModeSameOrigin);
     request.setSkipServiceWorker(m_isolatedWorldSecurityOrigin);
     request.setExternalRequestStateFromRequestorAddressSpace(executionContext.securityContext().addressSpace());
 
     InspectorInstrumentation::willLoadXHR(&executionContext, this, this, m_method, m_url, m_async, httpBody ? httpBody->deepCopy() : nullptr, m_requestHeaders, m_includeCredentials);
 
     if (httpBody) {
         ASSERT(m_method != HTTPNames::GET);
         ASSERT(m_method != HTTPNames::HEAD);
         request.setHTTPBody(httpBody);
     }
 
     if (m_requestHeaders.size() > 0)
         request.addHTTPHeaderFields(m_requestHeaders);
 
     ThreadableLoaderOptions options;
     options.preflightPolicy = uploadEvents ? ForcePreflight : ConsiderPreflight;
     options.crossOriginRequestPolicy = UseAccessControl;
     options.initiator = FetchInitiatorTypeNames::xmlhttprequest;
     options.contentSecurityPolicyEnforcement = ContentSecurityPolicy::shouldBypassMainWorld(&executionContext) ? DoNotEnforceContentSecurityPolicy : EnforceContentSecurityPolicy;
     options.timeoutMilliseconds = m_timeoutMilliseconds;
 
     ResourceLoaderOptions resourceLoaderOptions;
     resourceLoaderOptions.allowCredentials = (m_sameOriginRequest || m_includeCredentials) ? AllowStoredCredentials : DoNotAllowStoredCredentials;
     resourceLoaderOptions.credentialsRequested = m_includeCredentials ? ClientRequestedCredentials : ClientDidNotRequestCredentials;
-    resourceLoaderOptions.securityOrigin = securityOrigin();
+    resourceLoaderOptions.securityOrigin = getSecurityOrigin();
 
     // When responseType is set to "blob", we redirect the downloaded data to a
     // file-handle directly.
     m_downloadingToFile = getResponseTypeCode() == ResponseTypeBlob;
     if (m_downloadingToFile) {
         request.setDownloadToFile(true);
         resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
     }
 
     m_exceptionCode = 0;
@@ skipping 147 matching lines @@
 
 void XMLHttpRequest::dispatchProgressEvent(const AtomicString& type, long long receivedLength, long long expectedLength)
 {
     bool lengthComputable = expectedLength > 0 && receivedLength <= expectedLength;
     unsigned long long loaded = receivedLength >= 0 ? static_cast<unsigned long long>(receivedLength) : 0;
     unsigned long long total = lengthComputable ? static_cast<unsigned long long>(expectedLength) : 0;
 
     m_progressEventThrottle->dispatchProgressEvent(type, lengthComputable, loaded, total);
 
     if (type == EventTypeNames::loadend)
-        InspectorInstrumentation::didDispatchXHRLoadendEvent(executionContext(), this);
+        InspectorInstrumentation::didDispatchXHRLoadendEvent(getExecutionContext(), this);
 }
 
 void XMLHttpRequest::dispatchProgressEventFromSnapshot(const AtomicString& type)
 {
     dispatchProgressEvent(type, m_receivedLength, m_response.expectedContentLength());
 }
 
 void XMLHttpRequest::handleNetworkError()
 {
     WTF_LOG(Network, "XMLHttpRequest %p handleNetworkError()", this);
@@ skipping 19 matching lines @@
     if (!internalAbort())
         return;
 
     handleRequestError(AbortError, EventTypeNames::abort, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type, long long receivedLength, long long expectedLength)
 {
     WTF_LOG(Network, "XMLHttpRequest %p handleRequestError()", this);
 
-    InspectorInstrumentation::didFailXHRLoading(executionContext(), this, this, m_method, m_url);
+    InspectorInstrumentation::didFailXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
     if (!m_async) {
         ASSERT(exceptionCode);
         m_state = DONE;
         m_exceptionCode = exceptionCode;
         return;
     }
 
     // With m_error set, the state change steps are minimal: any pending
     // progress event is flushed + a readystatechange is dispatched.
@@ skipping 38 matching lines @@
         return;
     }
 
     if (!isValidHTTPHeaderValue(value)) {
         exceptionState.throwDOMException(SyntaxError, "'" + value + "' is not a valid HTTP header field value.");
         return;
     }
 
     // No script (privileged or not) can set unsafe headers.
     if (FetchUtils::isForbiddenHeaderName(name)) {
-        logConsoleError(executionContext(), "Refused to set unsafe header \"" + name + "\"");
+        logConsoleError(getExecutionContext(), "Refused to set unsafe header \"" + name + "\"");
         return;
     }
 
     setRequestHeaderInternal(name, value);
 }
 
 void XMLHttpRequest::setRequestHeaderInternal(const AtomicString& name, const AtomicString& value)
 {
     HeaderValueCategoryByRFC7230 headerValueCategory = HeaderValueValid;
 
@@ skipping 37 matching lines @@
 
     HTTPHeaderSet accessControlExposeHeaderSet;
     parseAccessControlExposeHeadersAllowList(m_response.httpHeaderField(HTTPNames::Access_Control_Expose_Headers), accessControlExposeHeaderSet);
     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
         // Hide any headers whose name is a forbidden response-header name.
         // This is required for all kinds of filtered responses.
         //
         // TODO: Consider removing canLoadLocalResources() call.
         // crbug.com/567527
-        if (FetchUtils::isForbiddenResponseHeaderName(it->key) && !securityOrigin()->canLoadLocalResources())
+        if (FetchUtils::isForbiddenResponseHeaderName(it->key) && !getSecurityOrigin()->canLoadLocalResources())
             continue;
 
         if (!m_sameOriginRequest && !isOnAccessControlResponseHeaderWhitelist(it->key) && !accessControlExposeHeaderSet.contains(it->key))
             continue;
 
         stringBuilder.append(it->key);
         stringBuilder.append(':');
         stringBuilder.append(' ');
         stringBuilder.append(it->value);
         stringBuilder.append('\r');
         stringBuilder.append('\n');
     }
 
     return stringBuilder.toString();
 }
 
 const AtomicString& XMLHttpRequest::getResponseHeader(const AtomicString& name) const
 {
     if (m_state < HEADERS_RECEIVED || m_error)
         return nullAtom;
 
     // See comment in getAllResponseHeaders above.
-    if (FetchUtils::isForbiddenResponseHeaderName(name) && !securityOrigin()->canLoadLocalResources()) {
-        logConsoleError(executionContext(), "Refused to get unsafe header \"" + name + "\"");
+    if (FetchUtils::isForbiddenResponseHeaderName(name) && !getSecurityOrigin()->canLoadLocalResources()) {
+        logConsoleError(getExecutionContext(), "Refused to get unsafe header \"" + name + "\"");
         return nullAtom;
     }
 
     HTTPHeaderSet accessControlExposeHeaderSet;
     parseAccessControlExposeHeadersAllowList(m_response.httpHeaderField(HTTPNames::Access_Control_Expose_Headers), accessControlExposeHeaderSet);
 
     if (!m_sameOriginRequest && !isOnAccessControlResponseHeaderWhitelist(name) && !accessControlExposeHeaderSet.contains(name)) {
-        logConsoleError(executionContext(), "Refused to get unsafe header \"" + name + "\"");
+        logConsoleError(getExecutionContext(), "Refused to get unsafe header \"" + name + "\"");
         return nullAtom;
     }
     return m_response.httpHeaderField(name);
 }
 
 AtomicString XMLHttpRequest::finalResponseMIMEType() const
 {
     AtomicString overriddenType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
     if (!overriddenType.isEmpty())
         return overriddenType;
@@ skipping 63 matching lines @@
     }
 
     if (error.isTimeout()) {
         handleDidTimeout();
         // Now the XMLHttpRequest instance may be dead.
         return;
     }
 
     // Network failures are already reported to Web Inspector by ResourceLoader.
     if (error.domain() == errorDomainBlinkInternal)
-        logConsoleError(executionContext(), "XMLHttpRequest cannot load " + error.failingURL() + ". " + error.localizedDescription());
+        logConsoleError(getExecutionContext(), "XMLHttpRequest cannot load " + error.failingURL() + ". " + error.localizedDescription());
 
     handleNetworkError();
     // Now the XMLHttpRequest instance may be dead.
 }
 
 void XMLHttpRequest::didFailRedirectCheck()
 {
     WTF_LOG(Network, "XMLHttpRequest %p didFailRedirectCheck()", this);
     ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
@@ skipping 104 matching lines @@
     if (!m_responseDocument->wellFormed())
         m_responseDocument = nullptr;
 
     m_parsedResponse = true;
 
     endLoading();
 }
 
 void XMLHttpRequest::endLoading()
 {
-    InspectorInstrumentation::didFinishXHRLoading(executionContext(), this, this, m_method, m_url);
+    InspectorInstrumentation::didFinishXHRLoading(getExecutionContext(), this, this, m_method, m_url);
 
     if (m_loader)
         m_loader = nullptr;
 
     changeState(DONE);
 
-    if (!executionContext()->isDocument() || !document() || !document()->frame() || !document()->frame()->page())
+    if (!getExecutionContext()->isDocument() || !document() || !document()->frame() || !document()->frame()->page())
         return;
 
     if (status() >= 200 && status() < 300) {
         document()->frame()->page()->chromeClient().ajaxSucceeded(document()->frame());
     }
 }
 
 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     WTF_LOG(Network, "XMLHttpRequest %p didSendData(%llu, %llu)", this, bytesSent, totalBytesToBeSent);
@@ skipping 100 matching lines @@
             m_responseText = m_responseText.concatenateWith(text);
             m_responseTextOverflow = m_responseText.isEmpty();
         }
     } else if (m_responseTypeCode == ResponseTypeArrayBuffer || m_responseTypeCode == ResponseTypeBlob) {
         // Buffer binary data.
         if (!m_binaryResponseBuilder)
             m_binaryResponseBuilder = SharedBuffer::create();
         m_binaryResponseBuilder->append(data, len);
     } else if (m_responseTypeCode == ResponseTypeLegacyStream) {
         if (!m_responseLegacyStream)
-            m_responseLegacyStream = Stream::create(executionContext(), responseType());
+            m_responseLegacyStream = Stream::create(getExecutionContext(), responseType());
         m_responseLegacyStream->addData(data, len);
     }
 
     if (m_blobLoader) {
         // In this case, the data is provided by m_blobLoader. As progress
         // events are already fired, we should return here.
         return;
     }
     trackProgress(len);
 }
@@ skipping 41 matching lines @@
     m_progressEventThrottle->suspend();
 }
 
 void XMLHttpRequest::resume()
 {
     m_progressEventThrottle->resume();
 }
 
 void XMLHttpRequest::stop()
 {
-    InspectorInstrumentation::didFailXHRLoading(executionContext(), this, this, m_method, m_url);
+    InspectorInstrumentation::didFailXHRLoading(getExecutionContext(), this, this, m_method, m_url);
     m_progressEventThrottle->stop();
     internalAbort();
 }
 
 bool XMLHttpRequest::hasPendingActivity() const
 {
     // Neither this object nor the JavaScript wrapper should be deleted while
     // a request is in progress because we need to keep the listeners alive,
     // and they are referenced by the JavaScript wrapper.
     // |m_loader| is non-null while request is active and ThreadableLoaderClient
     // callbacks may be called, and |m_responseDocumentParser| is non-null while
     // DocumentParserClient callbacks may be called.
     if (m_loader || m_responseDocumentParser)
         return true;
     return m_eventDispatchRecursionLevel > 0;
 }
 
 void XMLHttpRequest::contextDestroyed()
 {
     ASSERT(!m_loader);
     ActiveDOMObject::contextDestroyed();
 }
 
 const AtomicString& XMLHttpRequest::interfaceName() const
 {
     return EventTargetNames::XMLHttpRequest;
 }
 
-ExecutionContext* XMLHttpRequest::executionContext() const
+ExecutionContext* XMLHttpRequest::getExecutionContext() const
 {
-    return ActiveDOMObject::executionContext();
+    return ActiveDOMObject::getExecutionContext();
 }
 
 DEFINE_TRACE(XMLHttpRequest)
 {
     visitor->trace(m_responseBlob);
     visitor->trace(m_responseLegacyStream);
     visitor->trace(m_responseDocument);
     visitor->trace(m_responseDocumentParser);
     visitor->trace(m_progressEventThrottle);
     visitor->trace(m_upload);
     visitor->trace(m_blobLoader);
     XMLHttpRequestEventTarget::trace(visitor);
     DocumentParserClient::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink