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

third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.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/WaitUntilObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 51 matching lines @@
         , m_resolveType(type)
     {
     }
 
     ScriptValue call(ScriptValue value) override
     {
         ASSERT(m_observer);
         ASSERT(m_resolveType == Fulfilled || m_resolveType == Rejected);
         if (m_resolveType == Rejected) {
             m_observer->reportError(value);
-            value = ScriptPromise::reject(value.scriptState(), value).getScriptValue();
+            value = ScriptPromise::reject(value.getScriptState(), value).getScriptValue();
         }
         m_observer->decrementPendingActivity();
         m_observer = nullptr;
         return value;
     }
 
     Member<WaitUntilObserver> m_observer;
     ResolveType m_resolveType;
 };
 
 WaitUntilObserver* WaitUntilObserver::create(ExecutionContext* context, EventType type, int eventID)
 {
     return new WaitUntilObserver(context, type, eventID);
 }
 
 void WaitUntilObserver::willDispatchEvent()
 {
     // When handling a notificationclick event, we want to allow one window to
     // be focused or opened. These calls are allowed between the call to
     // willDispatchEvent() and the last call to decrementPendingActivity(). If
     // waitUntil() isn't called, that means between willDispatchEvent() and
     // didDispatchEvent().
     if (m_type == NotificationClick)
-        executionContext()->allowWindowInteraction();
+        getExecutionContext()->allowWindowInteraction();
 
     incrementPendingActivity();
 }
 
 void WaitUntilObserver::didDispatchEvent(bool errorOccurred)
 {
     if (errorOccurred)
         m_hasError = true;
     decrementPendingActivity();
     m_eventDispatched = true;
 }
 
 void WaitUntilObserver::waitUntil(ScriptState* scriptState, ScriptPromise scriptPromise, ExceptionState& exceptionState)
 {
     if (m_eventDispatched) {
         exceptionState.throwDOMException(InvalidStateError, "The event handler is already finished.");
         return;
     }
 
-    if (!executionContext())
+    if (!getExecutionContext())
         return;
 
     // When handling a notificationclick event, we want to allow one window to
     // be focused or opened. See comments in ::willDispatchEvent(). When
     // waitUntil() is being used, opening or closing a window must happen in a
     // timeframe specified by windowInteractionTimeout(), otherwise the calls
     // will fail.
     if (m_type == NotificationClick)
         m_consumeWindowInteractionTimer.startOneShot(windowInteractionTimeout(), BLINK_FROM_HERE);
 
@@ skipping 23 matching lines @@
 }
 
 void WaitUntilObserver::incrementPendingActivity()
 {
     ++m_pendingActivity;
 }
 
 void WaitUntilObserver::decrementPendingActivity()
 {
     ASSERT(m_pendingActivity > 0);
-    if (!executionContext() || (!m_hasError && --m_pendingActivity))
+    if (!getExecutionContext() || (!m_hasError && --m_pendingActivity))
         return;
 
-    ServiceWorkerGlobalScopeClient* client = ServiceWorkerGlobalScopeClient::from(executionContext());
+    ServiceWorkerGlobalScopeClient* client = ServiceWorkerGlobalScopeClient::from(getExecutionContext());
     WebServiceWorkerEventResult result = m_hasError ? WebServiceWorkerEventResultRejected : WebServiceWorkerEventResultCompleted;
     switch (m_type) {
     case Activate:
         client->didHandleActivateEvent(m_eventID, result);
         break;
     case Install:
         client->didHandleInstallEvent(m_eventID, result);
         break;
     case Message:
         client->didHandleExtendableMessageEvent(m_eventID, result);
@@ skipping 11 matching lines @@
         break;
     case Sync:
         client->didHandleSyncEvent(m_eventID, result);
         break;
     }
     setContext(nullptr);
 }
 
 void WaitUntilObserver::consumeWindowInteraction(Timer<WaitUntilObserver>*)
 {
-    if (!executionContext())
+    if (!getExecutionContext())
         return;
-    executionContext()->consumeWindowInteraction();
+    getExecutionContext()->consumeWindowInteraction();
 }
 
 DEFINE_TRACE(WaitUntilObserver)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink