Replace ActiveDOMObjects in modules/indexeddb/ with ContextLifecycleObservers

third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp

 /*
  * Copyright (C) 2010 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 34 matching lines @@
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
 IDBRequest* IDBRequest::create(ScriptState* scriptState, IDBAny* source, IDBTransaction* transaction)
 {
     IDBRequest* request = new IDBRequest(scriptState, source, transaction);
-    request->suspendIfNeeded();
     // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames) are not associated with transactions.
     if (transaction)
         transaction->registerRequest(request);
     return request;
 }
 
 IDBRequest::IDBRequest(ScriptState* scriptState, IDBAny* source, IDBTransaction* transaction)
-    : ActiveDOMObject(scriptState->executionContext())
+    : ContextLifecycleObserver(scriptState->executionContext())
     , m_transaction(transaction)
     , m_scriptState(scriptState)
     , m_source(source)
 {
 }
 
 IDBRequest::~IDBRequest()
 {
     ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !executionContext());
 }
 
 DEFINE_TRACE(IDBRequest)
 {
     visitor->trace(m_transaction);
     visitor->trace(m_source);
     visitor->trace(m_result);
     visitor->trace(m_error);
     visitor->trace(m_enqueuedEvents);
     visitor->trace(m_pendingCursor);
     visitor->trace(m_cursorKey);
     visitor->trace(m_cursorPrimaryKey);
     RefCountedGarbageCollectedEventTargetWithInlineData<IDBRequest>::trace(visitor);
-    ActiveDOMObject::trace(visitor);
+    ContextLifecycleObserver::trace(visitor);
 }
 
 ScriptValue IDBRequest::result(ExceptionState& exceptionState)
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return ScriptValue();
     }
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return ScriptValue();
     m_resultDirty = false;
     ScriptValue value = ScriptValue::from(m_scriptState.get(), m_result);
     return value;
 }
 
 DOMException* IDBRequest::error(ExceptionState& exceptionState) const
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return nullptr;
     }
     return m_error;
 }
 
 ScriptValue IDBRequest::source() const
 {
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return ScriptValue();
 
     return ScriptValue::from(m_scriptState.get(), m_source);
 }
 
 const String& IDBRequest::readyState() const
 {
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
 
     if (m_readyState == PENDING)
         return IndexedDBNames::pending;
 
     return IndexedDBNames::done;
 }
 
 void IDBRequest::abort()
 {
     ASSERT(!m_requestAborted);
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return;
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
     if (m_readyState == DONE)
         return;
 
     EventQueue* eventQueue = executionContext()->eventQueue();
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
         ASSERT_UNUSED(removed, removed);
     }
@@ skipping 61 matching lines @@
 }
 
 void IDBRequest::ackReceivedBlobs(const Vector<RefPtr<IDBValue>>& values)
 {
     for (size_t i = 0; i < values.size(); ++i)
         ackReceivedBlobs(values[i].get());
 }
 
 bool IDBRequest::shouldEnqueueEvent() const
 {
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return false;
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
     if (m_requestAborted)
         return false;
     ASSERT(m_readyState == PENDING);
     ASSERT(!m_error && !m_result);
     return true;
 }
 
 void IDBRequest::onError(DOMException* error)
@@ skipping 114 matching lines @@
 void IDBRequest::onSuccess()
 {
     IDB_TRACE("IDBRequest::onSuccess()");
     if (!shouldEnqueueEvent())
         return;
     onSuccessInternal(IDBAny::createUndefined());
 }
 
 void IDBRequest::onSuccessInternal(IDBAny* result)
 {
-    ASSERT(!m_contextStopped);
+    ASSERT(executionContext());
     ASSERT(!m_pendingCursor);
     setResult(result);
     enqueueEvent(Event::create(EventTypeNames::success));
 }
 
 void IDBRequest::setResult(IDBAny* result)
 {
     m_result = result;
     m_resultDirty = true;
 }
 
 void IDBRequest::onSuccess(IDBKey* key, IDBKey* primaryKey, PassRefPtr<IDBValue> value)
 {
     IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
     if (!shouldEnqueueEvent())
         return;
 
     ASSERT(m_pendingCursor);
     setResultCursor(m_pendingCursor.release(), key, primaryKey, value);
 }
 
 bool IDBRequest::hasPendingActivity() const
 {
     // FIXME: In an ideal world, we should return true as long as anyone has a or can
     //        get a handle to us and we have event listeners. This is order to handle
     //        user generated events properly.
-    return m_hasPendingActivity && !m_contextStopped;
+    return m_hasPendingActivity && executionContext();
 }
 
-void IDBRequest::stop()
+void IDBRequest::contextDestroyed()
 {
-    if (m_contextStopped)
-        return;
-
-    m_contextStopped = true;
-
     if (m_readyState == PENDING) {
         m_readyState = EarlyDeath;
         if (m_transaction) {
             m_transaction->unregisterRequest(this);
             m_transaction.clear();
         }
     }
 
     m_enqueuedEvents.clear();
     if (m_source)
         m_source->contextWillBeDestroyed();
     if (m_result)
         m_result->contextWillBeDestroyed();
     if (m_pendingCursor)
         m_pendingCursor->contextWillBeDestroyed();
 }
 
 const AtomicString& IDBRequest::interfaceName() const
 {
     return EventTargetNames::IDBRequest;
 }
 
 ExecutionContext* IDBRequest::executionContext() const
 {
-    return ActiveDOMObject::executionContext();
+    return ContextLifecycleObserver::executionContext();
 }
 
 DispatchEventResult IDBRequest::dispatchEventInternal(PassRefPtrWillBeRawPtr<Event> event)
 {
     IDB_TRACE("IDBRequest::dispatchEvent");
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return DispatchEventResult::CanceledBeforeDispatch;
     ASSERT(m_readyState == PENDING);
     ASSERT(m_hasPendingActivity);
     ASSERT(m_enqueuedEvents.size());
     ASSERT(event->target() == this);
 
     ScriptState::Scope scope(m_scriptState.get());
 
     if (event->type() != EventTypeNames::blocked)
         m_readyState = DONE;
@@ skipping 69 matching lines @@
 
 void IDBRequest::transactionDidFinishAndDispatch()
 {
     ASSERT(m_transaction);
     ASSERT(m_transaction->isVersionChange());
     ASSERT(m_didFireUpgradeNeededEvent);
     ASSERT(m_readyState == DONE);
     ASSERT(executionContext());
     m_transaction.clear();
 
-    if (m_contextStopped)
+    if (!executionContext())
         return;
 
     m_readyState = PENDING;
 }
 
 void IDBRequest::enqueueEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
 
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return;
 
     ASSERT_WITH_MESSAGE(m_readyState == PENDING || m_didFireUpgradeNeededEvent, "When queueing event %s, m_readyState was %d", event->type().utf8().data(), m_readyState);
 
     EventQueue* eventQueue = executionContext()->eventQueue();
     event->setTarget(this);
 
     // Keep track of enqueued events in case we need to abort prior to dispatch,
     // in which case these must be cancelled. If the events not dispatched for
     // other reasons they must be removed from this list via dequeueEvent().
     if (eventQueue->enqueueEvent(event.get()))
         m_enqueuedEvents.append(event);
 }
 
 void IDBRequest::dequeueEvent(Event* event)
 {
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         if (m_enqueuedEvents[i].get() == event)
             m_enqueuedEvents.remove(i);
     }
 }
 
 } // namespace blink