Remove ContextLifecycleObserver from WaitUntilObserver

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 73 matching lines @@
 }
 
 void WaitUntilObserver::willDispatchEvent() {
   m_eventDispatchTime = WTF::currentTime();
   // 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)
-    getExecutionContext()->allowWindowInteraction();
+    m_executionContext->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 (!getExecutionContext())
+  if (!m_executionContext)
     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);
 
   incrementPendingActivity();
   scriptPromise.then(
       ThenFunction::createFunction(scriptState, this, ThenFunction::Fulfilled),
       ThenFunction::createFunction(scriptState, this, ThenFunction::Rejected));
 }
 
 WaitUntilObserver::WaitUntilObserver(ExecutionContext* context,
                                      EventType type,
                                      int eventID)
-    : ContextLifecycleObserver(context),
+    : m_executionContext(context),
       m_type(type),
       m_eventID(eventID),
       m_consumeWindowInteractionTimer(
           this,
           &WaitUntilObserver::consumeWindowInteraction) {}
 
 void WaitUntilObserver::reportError(const ScriptValue& value) {
   // FIXME: Propagate error message to the client for onerror handling.
   NOTIMPLEMENTED();
 
   m_hasError = true;
 }
 
 void WaitUntilObserver::incrementPendingActivity() {
   ++m_pendingActivity;
 }
 
 void WaitUntilObserver::decrementPendingActivity() {
   ASSERT(m_pendingActivity > 0);
-  if (!getExecutionContext() || (!m_hasError && --m_pendingActivity))
+  if (!m_executionContext || (!m_hasError && --m_pendingActivity))
     return;
 
   ServiceWorkerGlobalScopeClient* client =
-      ServiceWorkerGlobalScopeClient::from(getExecutionContext());
+      ServiceWorkerGlobalScopeClient::from(m_executionContext);
   WebServiceWorkerEventResult result =
       m_hasError ? WebServiceWorkerEventResultRejected
                  : WebServiceWorkerEventResultCompleted;
   switch (m_type) {
     case Activate:
       client->didHandleActivateEvent(m_eventID, result, m_eventDispatchTime);
       break;
     case Fetch:
       client->didHandleFetchEvent(m_eventID, result, m_eventDispatchTime);
       break;
@@ skipping 18 matching lines @@
       client->didHandlePushEvent(m_eventID, result, m_eventDispatchTime);
       break;
     case Sync:
       client->didHandleSyncEvent(m_eventID, result, m_eventDispatchTime);
       break;
     case PaymentRequest:
       client->didHandlePaymentRequestEvent(m_eventID, result,
                                            m_eventDispatchTime);
       break;
   }
-  setContext(nullptr);
+  m_executionContext = nullptr;
 }
 
 void WaitUntilObserver::consumeWindowInteraction(TimerBase*) {
-  if (!getExecutionContext())
+  if (!m_executionContext)
     return;
-  getExecutionContext()->consumeWindowInteraction();
+  m_executionContext->consumeWindowInteraction();
 }
 
 DEFINE_TRACE(WaitUntilObserver) {
-  ContextLifecycleObserver::trace(visitor);
+  visitor->trace(m_executionContext);
 }
 
 }  // namespace blink