Rename activeDOMObjectsAreStopped to isContextDestroyed

third_party/WebKit/Source/modules/cachestorage/Cache.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/cachestorage/Cache.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 21 matching lines @@
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheMatchCallbacks : public WebServiceWorkerCache::CacheMatchCallbacks {
   WTF_MAKE_NONCOPYABLE(CacheMatchCallbacks);
 
  public:
   explicit CacheMatchCallbacks(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
 
   void onSuccess(const WebServiceWorkerResponse& webResponse) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     ScriptState::Scope scope(m_resolver->getScriptState());
     m_resolver->resolve(
         Response::create(m_resolver->getScriptState(), webResponse));
     m_resolver.clear();
   }
 
   void onError(WebServiceWorkerCacheError reason) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     if (reason == WebServiceWorkerCacheErrorNotFound)
       m_resolver->resolve();
     else
       m_resolver->reject(CacheStorageError::createException(reason));
     m_resolver.clear();
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheWithResponsesCallbacks
     : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
   WTF_MAKE_NONCOPYABLE(CacheWithResponsesCallbacks);
 
  public:
   explicit CacheWithResponsesCallbacks(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
 
   void onSuccess(
       const WebVector<WebServiceWorkerResponse>& webResponses) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     ScriptState::Scope scope(m_resolver->getScriptState());
     HeapVector<Member<Response>> responses;
     for (size_t i = 0; i < webResponses.size(); ++i)
       responses.append(
           Response::create(m_resolver->getScriptState(), webResponses[i]));
     m_resolver->resolve(responses);
     m_resolver.clear();
   }
 
   void onError(WebServiceWorkerCacheError reason) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     m_resolver->reject(CacheStorageError::createException(reason));
     m_resolver.clear();
   }
 
  protected:
   Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheDeleteCallback : public WebServiceWorkerCache::CacheBatchCallbacks {
   WTF_MAKE_NONCOPYABLE(CacheDeleteCallback);
 
  public:
   explicit CacheDeleteCallback(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
 
   void onSuccess() override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     m_resolver->resolve(true);
     m_resolver.clear();
   }
 
   void onError(WebServiceWorkerCacheError reason) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     if (reason == WebServiceWorkerCacheErrorNotFound)
       m_resolver->resolve(false);
     else
       m_resolver->reject(CacheStorageError::createException(reason));
     m_resolver.clear();
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheWithRequestsCallbacks
     : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
   WTF_MAKE_NONCOPYABLE(CacheWithRequestsCallbacks);
 
  public:
   explicit CacheWithRequestsCallbacks(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
 
   void onSuccess(
       const WebVector<WebServiceWorkerRequest>& webRequests) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     ScriptState::Scope scope(m_resolver->getScriptState());
     HeapVector<Member<Request>> requests;
     for (size_t i = 0; i < webRequests.size(); ++i)
       requests.append(
           Request::create(m_resolver->getScriptState(), webRequests[i]));
     m_resolver->resolve(requests);
     m_resolver.clear();
   }
 
   void onError(WebServiceWorkerCacheError reason) override {
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     m_resolver->reject(CacheStorageError::createException(reason));
     m_resolver.clear();
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // Used for UMA. Append only.
@@ skipping 126 matching lines @@
     ASSERT(0 < m_numberOfRemainingOperations);
     m_batchOperations.resize(numberOfOperations);
   }
 
   void onSuccess(size_t index,
                  const WebServiceWorkerCache::BatchOperation& batchOperation) {
     ASSERT(index < m_batchOperations.size());
     if (m_completed)
       return;
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     m_batchOperations[index] = batchOperation;
     if (--m_numberOfRemainingOperations != 0)
       return;
     m_cache->webCache()->dispatchBatch(
         WTF::makeUnique<CallbackPromiseAdapter<void, CacheStorageError>>(
             m_resolver),
         m_batchOperations);
   }
 
   void onError(const String& errorMessage) {
     if (m_completed)
       return;
     m_completed = true;
     if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     ScriptState* state = m_resolver->getScriptState();
     ScriptState::Scope scope(state);
     m_resolver->reject(
         V8ThrowException::createTypeError(state->isolate(), errorMessage));
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_cache);
     visitor->trace(m_resolver);
@@ skipping 369 matching lines @@
       WTF::makeUnique<CacheWithRequestsCallbacks>(resolver), webRequest,
       toWebQueryParams(options));
   return promise;
 }
 
 WebServiceWorkerCache* Cache::webCache() const {
   return m_webCache.get();
 }
 
 }  // namespace blink