Replace ActiveDOMObjects in modules/indexeddb/ with ContextLifecycleObservers

third_party/WebKit/Source/modules/indexeddb/IDBTransaction.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 29 matching lines @@
 #include "modules/indexeddb/IDBOpenDBRequest.h"
 #include "modules/indexeddb/IDBTracing.h"
 
 using blink::WebIDBDatabase;
 
 namespace blink {
 
 IDBTransaction* IDBTransaction::create(ScriptState* scriptState, int64_t id, const HashSet<String>& objectStoreNames, WebIDBTransactionMode mode, IDBDatabase* db)
 {
     IDBOpenDBRequest* openDBRequest = nullptr;
-    IDBTransaction* transaction = new IDBTransaction(scriptState, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata());
-    transaction->suspendIfNeeded();
-    return transaction;
+    return new IDBTransaction(scriptState, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata());
 }
 
 IDBTransaction* IDBTransaction::create(ScriptState* scriptState, int64_t id, IDBDatabase* db, IDBOpenDBRequest* openDBRequest, const IDBDatabaseMetadata& previousMetadata)
 {
-    IDBTransaction* transaction = new IDBTransaction(scriptState, id, HashSet<String>(), WebIDBTransactionModeVersionChange, db, openDBRequest, previousMetadata);
-    transaction->suspendIfNeeded();
-    return transaction;
+    return new IDBTransaction(scriptState, id, HashSet<String>(), WebIDBTransactionModeVersionChange, db, openDBRequest, previousMetadata);
 }
 
 namespace {
 
 class DeactivateTransactionTask : public V8PerIsolateData::EndOfScopeTask {
 public:
     static PassOwnPtr<DeactivateTransactionTask> create(IDBTransaction* transaction)
     {
         return adoptPtr(new DeactivateTransactionTask(transaction));
     }
 
     void run() override
     {
         m_transaction->setActive(false);
         m_transaction.clear();
     }
 
 private:
     explicit DeactivateTransactionTask(IDBTransaction* transaction)
         : m_transaction(transaction) { }
 
     Persistent<IDBTransaction> m_transaction;
 };
 
 } // namespace
 
 IDBTransaction::IDBTransaction(ScriptState* scriptState, int64_t id, const HashSet<String>& objectStoreNames, WebIDBTransactionMode mode, IDBDatabase* db, IDBOpenDBRequest* openDBRequest, const IDBDatabaseMetadata& previousMetadata)
-    : ActiveDOMObject(scriptState->executionContext())
+    : ContextLifecycleObserver(scriptState->executionContext())
     , m_id(id)
     , m_database(db)
     , m_objectStoreNames(objectStoreNames)
     , m_openDBRequest(openDBRequest)
     , m_mode(mode)
     , m_previousMetadata(previousMetadata)
 {
     if (mode == WebIDBTransactionModeVersionChange) {
         // Not active until the callback.
         m_state = Inactive;
     }
 
     if (m_state == Active)
         V8PerIsolateData::from(scriptState->isolate())->addEndOfScopeTask(DeactivateTransactionTask::create(this));
     m_database->transactionCreated(this);
 }
 
 IDBTransaction::~IDBTransaction()
 {
-    ASSERT(m_state == Finished || m_contextStopped);
-    ASSERT(m_requestList.isEmpty() || m_contextStopped);
+    ASSERT(m_state == Finished || !executionContext());
+    ASSERT(m_requestList.isEmpty() || !executionContext());
 }
 
 DEFINE_TRACE(IDBTransaction)
 {
     visitor->trace(m_database);
     visitor->trace(m_openDBRequest);
     visitor->trace(m_error);
     visitor->trace(m_requestList);
     visitor->trace(m_objectStoreMap);
     visitor->trace(m_deletedObjectStores);
     visitor->trace(m_objectStoreCleanupMap);
     RefCountedGarbageCollectedEventTargetWithInlineData<IDBTransaction>::trace(visitor);
-    ActiveDOMObject::trace(visitor);
+    ContextLifecycleObserver::trace(visitor);
 }
 
 void IDBTransaction::setError(DOMException* error)
 {
     ASSERT(m_state != Finished);
     ASSERT(error);
 
     // The first error to be set is the true cause of the
     // transaction abort.
     if (!m_error) {
@@ skipping 67 matching lines @@
 
 void IDBTransaction::abort(ExceptionState& exceptionState)
 {
     if (m_state == Finishing || m_state == Finished) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::transactionFinishedErrorMessage);
         return;
     }
 
     m_state = Finishing;
 
-    if (m_contextStopped)
+    if (!executionContext())
         return;
 
     for (IDBRequest* request : m_requestList)
         request->abort();
     m_requestList.clear();
 
     if (backendDB())
         backendDB()->abort(m_id);
 }
 
 void IDBTransaction::registerRequest(IDBRequest* request)
 {
     ASSERT(request);
     ASSERT(m_state == Active);
     m_requestList.add(request);
 }
 
 void IDBTransaction::unregisterRequest(IDBRequest* request)
 {
     ASSERT(request);
     // If we aborted the request, it will already have been removed.
     m_requestList.remove(request);
 }
 
 void IDBTransaction::onAbort(DOMException* error)
 {
     IDB_TRACE("IDBTransaction::onAbort");
-    if (m_contextStopped) {
+    if (!executionContext()) {
         m_database->transactionFinished(this);
         return;
     }
 
     ASSERT(m_state != Finished);
     if (m_state != Finishing) {
         ASSERT(error);
         setError(error);
 
         // Abort was not triggered by front-end, so outstanding requests must
@@ skipping 15 matching lines @@
 
     // Enqueue events before notifying database, as database may close which enqueues more events and order matters.
     enqueueEvent(Event::createBubble(EventTypeNames::abort));
 
     m_database->transactionFinished(this);
 }
 
 void IDBTransaction::onComplete()
 {
     IDB_TRACE("IDBTransaction::onComplete");
-    if (m_contextStopped) {
+    if (!executionContext()) {
         m_database->transactionFinished(this);
         return;
     }
 
     ASSERT(m_state != Finished);
     m_state = Finishing;
     m_objectStoreCleanupMap.clear();
 
     // Enqueue events before notifying database, as database may close which enqueues more events and order matters.
     enqueueEvent(Event::create(EventTypeNames::complete));
 
     m_database->transactionFinished(this);
 }
 
 bool IDBTransaction::hasPendingActivity() const
 {
     // FIXME: In an ideal world, we should return true as long as anyone has a or can
     //        get a handle to us or any child request object and any of those have
     //        event listeners. This is  in order to handle user generated events properly.
-    return m_hasPendingActivity && !m_contextStopped;
+    return m_hasPendingActivity && executionContext();
 }
 
 WebIDBTransactionMode IDBTransaction::stringToMode(const String& modeString)
 {
     if (modeString == IndexedDBNames::readonly)
         return WebIDBTransactionModeReadOnly;
     if (modeString == IndexedDBNames::readwrite)
         return WebIDBTransactionModeReadWrite;
     if (modeString == IndexedDBNames::versionchange)
         return WebIDBTransactionModeVersionChange;
@@ skipping 30 matching lines @@
     return objectStoreNames.release();
 }
 
 const AtomicString& IDBTransaction::interfaceName() const
 {
     return EventTargetNames::IDBTransaction;
 }
 
 ExecutionContext* IDBTransaction::executionContext() const
 {
-    return ActiveDOMObject::executionContext();
+    return ContextLifecycleObserver::executionContext();
 }
 
 DispatchEventResult IDBTransaction::dispatchEventInternal(PassRefPtrWillBeRawPtr<Event> event)
 {
     IDB_TRACE("IDBTransaction::dispatchEvent");
-    if (m_contextStopped || !executionContext()) {
+    if (!executionContext()) {
         m_state = Finished;
         return DispatchEventResult::CanceledBeforeDispatch;
     }
     ASSERT(m_state != Finished);
     ASSERT(m_hasPendingActivity);
     ASSERT(executionContext());
     ASSERT(event->target() == this);
     m_state = Finished;
 
     // Break reference cycles.
@@ skipping 14 matching lines @@
     // FIXME: Try to construct a test where |this| outlives openDBRequest and we
     // get a crash.
     if (m_openDBRequest) {
         ASSERT(isVersionChange());
         m_openDBRequest->transactionDidFinishAndDispatch();
     }
     m_hasPendingActivity = false;
     return dispatchResult;
 }
 
-void IDBTransaction::stop()
+void IDBTransaction::contextDestroyed()
 {
-    if (m_contextStopped)
-        return;
-
-    m_contextStopped = true;
-
     abort(IGNORE_EXCEPTION);

[sof, 2016/03/01 07:04:26]

afaict, the abort() call here used to be a no-op. It no longer is as
executionContext() isn't cleared by the time contextDestroyed() notifications
run.

 }
 
 void IDBTransaction::enqueueEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to enqueue an event of type %s.", event->type().utf8().data());
-    if (m_contextStopped || !executionContext())
+    if (!executionContext())
         return;
 
     EventQueue* eventQueue = executionContext()->eventQueue();
     event->setTarget(this);
     eventQueue->enqueueEvent(event);
 }
 
 WebIDBDatabase* IDBTransaction::backendDB() const
 {
     return m_database->backend();
 }
 
 } // namespace blink