Remove ContextLifecycleObserver from ScriptPromisePropertyBase

third_party/WebKit/Source/bindings/core/v8/ScriptPromisePropertyBase.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 "bindings/core/v8/ScriptPromisePropertyBase.h"
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8HiddenValue.h"
 #include "core/dom/ExecutionContext.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 ScriptPromisePropertyBase::ScriptPromisePropertyBase(
     ExecutionContext* executionContext,
     Name name)
-    : ContextLifecycleObserver(executionContext),
+    : m_executionContext(executionContext),
       m_isolate(toIsolate(executionContext)),
       m_name(name),
       m_state(Pending) {}
 
 ScriptPromisePropertyBase::~ScriptPromisePropertyBase() {
   clearWrappers();
 }
 
+ExecutionContext* ScriptPromisePropertyBase::getExecutionContext() const {
+  return m_executionContext;
+}
+
 ScriptPromise ScriptPromisePropertyBase::promise(DOMWrapperWorld& world) {
-  if (!getExecutionContext())
+  if (m_executionContext->isContextDestroyed())
     return ScriptPromise();
 
   v8::HandleScope handleScope(m_isolate);
-  v8::Local<v8::Context> context = toV8Context(getExecutionContext(), world);
+  v8::Local<v8::Context> context = toV8Context(m_executionContext, world);
   if (context.IsEmpty())
     return ScriptPromise();
   ScriptState* scriptState = ScriptState::from(context);
   ScriptState::Scope scope(scriptState);
 
   v8::Local<v8::Object> wrapper = ensureHolderWrapper(scriptState);
-  ASSERT(wrapper->CreationContext() == context);
+  DCHECK(wrapper->CreationContext() == context);
 
   v8::Local<v8::Value> cachedPromise =
       V8HiddenValue::getHiddenValue(scriptState, wrapper, promiseName());
   if (!cachedPromise.IsEmpty() && cachedPromise->IsPromise())
     return ScriptPromise(scriptState, cachedPromise);
 
   // Create and cache the Promise
   v8::Local<v8::Promise::Resolver> resolver;
   if (!v8::Promise::Resolver::New(context).ToLocal(&resolver))
     return ScriptPromise();
   v8::Local<v8::Promise> promise = resolver->GetPromise();
   V8HiddenValue::setHiddenValue(scriptState, wrapper, promiseName(), promise);
 
   switch (m_state) {
     case Pending:
       // Cache the resolver too
       V8HiddenValue::setHiddenValue(scriptState, wrapper, resolverName(),
                                     resolver);
       break;
     case Resolved:
     case Rejected:
       resolveOrRejectInternal(resolver);
       break;
   }
 
   return ScriptPromise(scriptState, promise);
 }
 
 void ScriptPromisePropertyBase::resolveOrReject(State targetState) {
-  ASSERT(getExecutionContext());
-  ASSERT(m_state == Pending);
-  ASSERT(targetState == Resolved || targetState == Rejected);
+  DCHECK(!m_executionContext->isContextDestroyed());
+  DCHECK(m_state == Pending);
+  DCHECK(targetState == Resolved || targetState == Rejected);
 
   m_state = targetState;
 
   v8::HandleScope handleScope(m_isolate);
   size_t i = 0;
   while (i < m_wrappers.size()) {
     const std::unique_ptr<ScopedPersistent<v8::Object>>& persistent =
         m_wrappers[i];
     if (persistent->isEmpty()) {
       // wrapper has died.
@@ skipping 116 matching lines @@
 
     SCRIPT_PROMISE_PROPERTIES(P)
 
 #undef P
   }
   ASSERT_NOT_REACHED();
   return v8::Local<v8::String>();
 }
 
 DEFINE_TRACE(ScriptPromisePropertyBase) {
-  ContextLifecycleObserver::trace(visitor);
+  visitor->trace(m_executionContext);
 }
 
 }  // namespace blink