Remove ExecutionContext::activeDOMObjectsAreStopped()

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerContainer.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 40 matching lines @@
 #include "modules/serviceworkers/ServiceWorkerRegistration.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/modules/serviceworker/WebServiceWorker.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerProvider.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRegistration.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
+#include <utility>
 
 namespace blink {
 
 class RegistrationCallback
     : public WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks {
  public:
   explicit RegistrationCallback(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
   ~RegistrationCallback() override {}
 
   void onSuccess(
       std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+    if (!m_resolver->getExecutionContext())
       return;
     m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(
-        m_resolver->getExecutionContext(), wrapUnique(handle.release())));
+        m_resolver->getExecutionContext(), std::move(handle)));
   }
 
   void onError(const WebServiceWorkerError& error) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+    if (!m_resolver->getExecutionContext())
       return;
     ScriptState::Scope scope(m_resolver->getScriptState());
     if (error.errorType == WebServiceWorkerError::ErrorTypeType) {
       m_resolver->reject(V8ThrowException::createTypeError(
           m_resolver->getScriptState()->isolate(), error.message));
     } else {
       m_resolver->reject(
           ServiceWorkerErrorForUpdate::take(m_resolver.get(), error));
     }
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
   WTF_MAKE_NONCOPYABLE(RegistrationCallback);
 };
 
 class GetRegistrationCallback : public WebServiceWorkerProvider::
                                     WebServiceWorkerGetRegistrationCallbacks {
  public:
   explicit GetRegistrationCallback(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
   ~GetRegistrationCallback() override {}
 
   void onSuccess(std::unique_ptr<WebServiceWorkerRegistration::Handle>
                      webPassHandle) override {
     std::unique_ptr<WebServiceWorkerRegistration::Handle> handle =
-        wrapUnique(webPassHandle.release());
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        std::move(webPassHandle);
+    if (!m_resolver->getExecutionContext())
       return;
     if (!handle) {
       // Resolve the promise with undefined.
       m_resolver->resolve();
       return;
     }
     m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(
         m_resolver->getExecutionContext(), std::move(handle)));
   }
 
   void onError(const WebServiceWorkerError& error) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+    if (!m_resolver->getExecutionContext())
       return;
     m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
   WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
 };
 
 class GetRegistrationsCallback : public WebServiceWorkerProvider::
                                      WebServiceWorkerGetRegistrationsCallbacks {
  public:
   explicit GetRegistrationsCallback(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
   ~GetRegistrationsCallback() override {}
 
   void onSuccess(
       std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>
           webPassRegistrations) override {
     Vector<std::unique_ptr<WebServiceWorkerRegistration::Handle>> handles;
     std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>
-        webRegistrations = wrapUnique(webPassRegistrations.release());
+        webRegistrations = std::move(webPassRegistrations);
     for (auto& handle : *webRegistrations) {
       handles.append(wrapUnique(handle));
     }
 
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+    if (!m_resolver->getExecutionContext())
       return;
     m_resolver->resolve(
         ServiceWorkerRegistrationArray::take(m_resolver.get(), &handles));
   }
 
   void onError(const WebServiceWorkerError& error) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+    if (!m_resolver->getExecutionContext())
       return;
     m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
   WTF_MAKE_NONCOPYABLE(GetRegistrationsCallback);
 };
 
 class ServiceWorkerContainer::GetRegistrationForReadyCallback
     : public WebServiceWorkerProvider::
           WebServiceWorkerGetRegistrationForReadyCallbacks {
  public:
   explicit GetRegistrationForReadyCallback(ReadyProperty* ready)
       : m_ready(ready) {}
   ~GetRegistrationForReadyCallback() override {}
 
   void onSuccess(
       std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override {
     ASSERT(m_ready->getState() == ReadyProperty::Pending);
 
-    if (m_ready->getExecutionContext() &&
-        !m_ready->getExecutionContext()->activeDOMObjectsAreStopped())
+    if (m_ready->getExecutionContext()) {
       m_ready->resolve(ServiceWorkerRegistration::getOrCreate(
-          m_ready->getExecutionContext(), wrapUnique(handle.release())));
+          m_ready->getExecutionContext(), std::move(handle)));
+    }
   }
 
  private:
   Persistent<ReadyProperty> m_ready;
   WTF_MAKE_NONCOPYABLE(GetRegistrationForReadyCallback);
 };
 
 ServiceWorkerContainer* ServiceWorkerContainer::create(
     ExecutionContext* executionContext) {
   return new ServiceWorkerContainer(executionContext);
@@ skipping 331 matching lines @@
 
   if (ServiceWorkerContainerClient* client =
           ServiceWorkerContainerClient::from(executionContext)) {
     m_provider = client->provider();
     if (m_provider)
       m_provider->setClient(this);
   }
 }
 
 }  // namespace blink