Rename ActiveDOMObject to SuspendableObject

third_party/WebKit/Source/bindings/core/v8/ScriptPromiseResolver.h

 // 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.
 
 #ifndef ScriptPromiseResolver_h
 #define ScriptPromiseResolver_h
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ToV8.h"
 #include "core/CoreExport.h"
-#include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ExecutionContext.h"
+#include "core/dom/SuspendableObject.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/Timer.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/SelfKeepAlive.h"
 #include <v8.h>
 
 namespace blink {
 
 // This class wraps v8::Promise::Resolver and provides the following
 // functionalities.
 //  - A ScriptPromiseResolver retains a ScriptState. A caller
 //    can call resolve or reject from outside of a V8 context.
-//  - This class is an ActiveDOMObject and keeps track of the associated
+//  - This class is an SuspendableObject and keeps track of the associated
 //    ExecutionContext state. When the ExecutionContext is suspended,
 //    resolve or reject will be delayed. When it is stopped, resolve or reject
 //    will be ignored.
 class CORE_EXPORT ScriptPromiseResolver
     : public GarbageCollectedFinalized<ScriptPromiseResolver>,
-      public ActiveDOMObject {
+      public SuspendableObject {
   USING_GARBAGE_COLLECTED_MIXIN(ScriptPromiseResolver);
   WTF_MAKE_NONCOPYABLE(ScriptPromiseResolver);
 
  public:
   static ScriptPromiseResolver* create(ScriptState* scriptState) {
     ScriptPromiseResolver* resolver = new ScriptPromiseResolver(scriptState);
     resolver->suspendIfNeeded();
     return resolver;
   }
 
@@ skipping 35 matching lines @@
   // reject is called.
   ScriptPromise promise() {
 #if ENABLE(ASSERT)
     m_isPromiseCalled = true;
 #endif
     return m_resolver.promise();
   }
 
   ScriptState* getScriptState() const { return m_scriptState.get(); }
 
-  // ActiveDOMObject implementation.
+  // SuspendableObject implementation.
   void suspend() override;
   void resume() override;
   void contextDestroyed() override { detach(); }
 
   // Calling this function makes the resolver release its internal resources.
   // That means the associated promise will never be resolved or rejected
   // unless it's already been resolved or rejected.
   // Do not call this function unless you truly need the behavior.
   void detach();
 
   // Once this function is called this resolver stays alive while the
   // promise is pending and the associated ExecutionContext isn't stopped.
   void keepAliveWhilePending();
 
   DECLARE_VIRTUAL_TRACE();
 
  protected:
   // You need to call suspendIfNeeded after the construction because
-  // this is an ActiveDOMObject.
+  // this is an SuspendableObject.
   explicit ScriptPromiseResolver(ScriptState*);
 
  private:
   typedef ScriptPromise::InternalResolver Resolver;
   enum ResolutionState {
     Pending,
     Resolving,
     Rejecting,
     Detached,
   };
@@ skipping 44 matching lines @@
 
 #if ENABLE(ASSERT)
   // True if promise() is called.
   bool m_isPromiseCalled;
 #endif
 };
 
 }  // namespace blink
 
 #endif  // ScriptPromiseResolver_h