IndexedDB: Remove m_contextStopped from ActiveDOMObjecs

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 125 matching lines @@
       m_state(Inactive),
       m_oldDatabaseMetadata(oldMetadata) {
   DCHECK(m_database);
   DCHECK(m_openDBRequest);
   DCHECK(m_scope.isEmpty());
 
   m_database->transactionCreated(this);
 }
 
 IDBTransaction::~IDBTransaction() {
-  DCHECK(m_state == Finished || m_contextStopped);
-  DCHECK(m_requestList.isEmpty() || m_contextStopped);
+  DCHECK(m_state == Finished || !getExecutionContext());
+  DCHECK(m_requestList.isEmpty() || !getExecutionContext());
 }
 
 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_oldStoreMetadata);
   visitor->trace(m_deletedIndexes);
@@ skipping 172 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 (!getExecutionContext())
     return;
 
   abortOutstandingRequests();
   revertDatabaseMetadata();
 
   if (backendDB())
     backendDB()->abort(m_id);
 }
 
 void IDBTransaction::registerRequest(IDBRequest* request) {
   DCHECK(request);
   DCHECK_EQ(m_state, Active);
   m_requestList.add(request);
 }
 
 void IDBTransaction::unregisterRequest(IDBRequest* request) {
   DCHECK(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 (!getExecutionContext()) {
     finished();
     return;
   }
 
   DCHECK_NE(m_state, Finished);
   if (m_state != Finishing) {
     // Abort was not triggered by front-end.
     DCHECK(error);
     setError(error);
 
     abortOutstandingRequests();
     revertDatabaseMetadata();
 
     m_state = Finishing;
   }
 
   if (isVersionChange())
     m_database->close();
 
   // Enqueue events before notifying database, as database may close which
   // enqueues more events and order matters.
   enqueueEvent(Event::createBubble(EventTypeNames::abort));
   finished();
 }
 
 void IDBTransaction::onComplete() {
   IDB_TRACE("IDBTransaction::onComplete");
-  if (m_contextStopped) {
+  if (!getExecutionContext()) {
     finished();
     return;
   }
 
   DCHECK_NE(m_state, Finished);
   m_state = Finishing;
 
   // Enqueue events before notifying database, as database may close which
   // enqueues more events and order matters.
   enqueueEvent(Event::create(EventTypeNames::complete));
   finished();
 }
 
 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 && getExecutionContext();
 }
 
 WebIDBTransactionMode IDBTransaction::stringToMode(const String& modeString) {
   if (modeString == IndexedDBNames::readonly)
     return WebIDBTransactionModeReadOnly;
   if (modeString == IndexedDBNames::readwrite)
     return WebIDBTransactionModeReadWrite;
   if (modeString == IndexedDBNames::versionchange)
     return WebIDBTransactionModeVersionChange;
   NOTREACHED();
@@ skipping 35 matching lines @@
 const AtomicString& IDBTransaction::interfaceName() const {
   return EventTargetNames::IDBTransaction;
 }
 
 ExecutionContext* IDBTransaction::getExecutionContext() const {
   return ActiveDOMObject::getExecutionContext();
 }
 
 DispatchEventResult IDBTransaction::dispatchEventInternal(Event* event) {
   IDB_TRACE("IDBTransaction::dispatchEvent");
-  if (m_contextStopped || !getExecutionContext()) {
+  if (!getExecutionContext()) {
     m_state = Finished;
     return DispatchEventResult::CanceledBeforeDispatch;
   }
   DCHECK_NE(m_state, Finished);
   DCHECK(m_hasPendingActivity);
   DCHECK(getExecutionContext());
   DCHECK_EQ(event->target(), this);
   m_state = Finished;
 
   HeapVector<Member<EventTarget>> targets;
   targets.append(this);
   targets.append(db());
 
   // FIXME: When we allow custom event dispatching, this will probably need to
   // change.
   DCHECK(event->type() == EventTypeNames::complete ||
          event->type() == EventTypeNames::abort);
   DispatchEventResult dispatchResult =
       IDBEventDispatcher::dispatch(event, targets);
   // FIXME: Try to construct a test where |this| outlives openDBRequest and we
   // get a crash.
   if (m_openDBRequest) {
     DCHECK(isVersionChange());
     m_openDBRequest->transactionDidFinishAndDispatch();
   }
   m_hasPendingActivity = false;
   return dispatchResult;
 }
 
-void IDBTransaction::contextDestroyed() {
-  if (m_contextStopped)
-    return;
-
-  m_contextStopped = true;
-
-  abort(IGNORE_EXCEPTION);
-}
-
 void IDBTransaction::enqueueEvent(Event* event) {
   DCHECK_NE(m_state, Finished)
       << "A finished transaction tried to enqueue an event of type "
       << event->type() << ".";
-  if (m_contextStopped || !getExecutionContext())
+  if (!getExecutionContext())
     return;
 
   EventQueue* eventQueue = getExecutionContext()->getEventQueue();
   event->setTarget(this);
   eventQueue->enqueueEvent(event);
 }
 
 void IDBTransaction::abortOutstandingRequests() {
   for (IDBRequest* request : m_requestList)
     request->abort();
@@ skipping 63 matching lines @@
     IDBObjectStore* objectStore = it.key;
     objectStore->clearIndexCache();
   }
   m_oldStoreMetadata.clear();
 
   m_deletedIndexes.clear();
   m_deletedObjectStores.clear();
 }
 
 }  // namespace blink