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

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerClients.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/serviceworkers/ServiceWorkerClients.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
@@ skipping 51 matching lines @@
 
 class GetCallback : public WebServiceWorkerClientCallbacks {
 public:
     explicit GetCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~GetCallback() override { }
 
     void onSuccess(WebPassOwnPtr<WebServiceWorkerClientInfo> webClient) override
     {
         OwnPtr<WebServiceWorkerClientInfo> client = webClient.release();
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         if (!client) {
             // Resolve the promise with undefined.
             m_resolver->resolve();
             return;
         }
         m_resolver->resolve(ServiceWorkerClient::take(m_resolver, client.release()));
     }
 
     void onError(const WebServiceWorkerError& error) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(GetCallback);
 };
 
 } // namespace
 
 ServiceWorkerClients* ServiceWorkerClients::create()
 {
     return new ServiceWorkerClients();
 }
 
 ServiceWorkerClients::ServiceWorkerClients()
 {
 }
 
 ScriptPromise ServiceWorkerClients::get(ScriptState* scriptState, const String& id)
 {
-    ExecutionContext* executionContext = scriptState->executionContext();
+    ExecutionContext* executionContext = scriptState->getExecutionContext();
     // TODO(jungkees): May be null due to worker termination: http://crbug.com/413518.
     if (!executionContext)
         return ScriptPromise();
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     ServiceWorkerGlobalScopeClient::from(executionContext)->getClient(id, new GetCallback(resolver));
     return promise;
 }
 
 ScriptPromise ServiceWorkerClients::matchAll(ScriptState* scriptState, const ClientQueryOptions& options)
 {
-    ExecutionContext* executionContext = scriptState->executionContext();
+    ExecutionContext* executionContext = scriptState->getExecutionContext();
     // FIXME: May be null due to worker termination: http://crbug.com/413518.
     if (!executionContext)
         return ScriptPromise();
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     WebServiceWorkerClientQueryOptions webOptions;
     webOptions.clientType = getClientType(options.type());
     webOptions.includeUncontrolled = options.includeUncontrolled();
     ServiceWorkerGlobalScopeClient::from(executionContext)->getClients(webOptions, new CallbackPromiseAdapter<ClientArray, ServiceWorkerError>(resolver));
     return promise;
 }
 
 ScriptPromise ServiceWorkerClients::claim(ScriptState* scriptState)
 {
-    ExecutionContext* executionContext = scriptState->executionContext();
+    ExecutionContext* executionContext = scriptState->getExecutionContext();
 
     // FIXME: May be null due to worker termination: http://crbug.com/413518.
     if (!executionContext)
         return ScriptPromise();
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     WebServiceWorkerClientsClaimCallbacks* callbacks = new CallbackPromiseAdapter<void, ServiceWorkerError>(resolver);
     ServiceWorkerGlobalScopeClient::from(executionContext)->claim(callbacks);
     return promise;
 }
 
 ScriptPromise ServiceWorkerClients::openWindow(ScriptState* scriptState, const String& url)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    ExecutionContext* context = scriptState->executionContext();
+    ExecutionContext* context = scriptState->getExecutionContext();
 
     KURL parsedUrl = KURL(toWorkerGlobalScope(context)->location()->url(), url);
     if (!parsedUrl.isValid()) {
         resolver->reject(V8ThrowException::createTypeError(scriptState->isolate(), "'" + url + "' is not a valid URL."));
         return promise;
     }
 
-    if (!context->securityOrigin()->canDisplay(parsedUrl)) {
+    if (!context->getSecurityOrigin()->canDisplay(parsedUrl)) {
         resolver->reject(V8ThrowException::createTypeError(scriptState->isolate(), "'" + parsedUrl.elidedString() + "' cannot be opened."));
         return promise;
     }
 
     if (!context->isWindowInteractionAllowed()) {
         resolver->reject(DOMException::create(InvalidAccessError, "Not allowed to open a window."));
         return promise;
     }
     context->consumeWindowInteraction();
 
     ServiceWorkerGlobalScopeClient::from(context)->openWindow(parsedUrl, new NavigateClientCallback(resolver));
     return promise;
 }
 
 } // namespace blink