IndexedDB: Remove m_contextStopped from ActiveDOMObjecs

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 80 matching lines @@
 
 ScriptValue IDBRequest::result(ScriptState* scriptState,
                                ExceptionState& exceptionState) {
   if (m_readyState != DONE) {
     // Must throw if returning an empty value. Message is arbitrary since it
     // will never be seen.
     exceptionState.throwDOMException(
         InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
     return ScriptValue();
   }
-  if (m_contextStopped || !getExecutionContext()) {
+  if (!getExecutionContext()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return ScriptValue();
   }
   m_resultDirty = false;
   ScriptValue value = ScriptValue::from(scriptState, 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(ScriptState* scriptState) const {
-  if (m_contextStopped || !getExecutionContext())
+  if (!getExecutionContext())
     return ScriptValue();
 
   return ScriptValue::from(scriptState, m_source);
 }
 
 const String& IDBRequest::readyState() const {
   DCHECK(m_readyState == PENDING || m_readyState == DONE);
 
   if (m_readyState == PENDING)
     return IndexedDBNames::pending;
 
   return IndexedDBNames::done;
 }
 
 std::unique_ptr<WebIDBCallbacks> IDBRequest::createWebCallbacks() {
   DCHECK(!m_webCallbacks);
   std::unique_ptr<WebIDBCallbacks> callbacks =
       WebIDBCallbacksImpl::create(this);
   m_webCallbacks = callbacks.get();
   return callbacks;
 }
 
 void IDBRequest::webCallbacksDestroyed() {
   DCHECK(m_webCallbacks);
   m_webCallbacks = nullptr;
 }
 
 void IDBRequest::abort() {
   DCHECK(!m_requestAborted);
-  if (m_contextStopped || !getExecutionContext())
+  if (!getExecutionContext())
     return;
   DCHECK(m_readyState == PENDING || m_readyState == DONE);
   if (m_readyState == DONE)
     return;
 
   EventQueue* eventQueue = getExecutionContext()->getEventQueue();
   for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
     bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
     DCHECK(removed);
   }
@@ skipping 60 matching lines @@
   if (!uuids.isEmpty())
     m_transaction->backendDB()->ackReceivedBlobs(uuids);
 }
 
 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 || !getExecutionContext())
+  if (!getExecutionContext())
     return false;
   DCHECK(m_readyState == PENDING || m_readyState == DONE);
   if (m_requestAborted)
     return false;
   DCHECK_EQ(m_readyState, PENDING);
   DCHECK(!m_error && !m_result);
   return true;
 }
 
 void IDBRequest::onError(DOMException* error) {
@@ skipping 109 matching lines @@
 }
 
 void IDBRequest::onSuccess() {
   IDB_TRACE("IDBRequest::onSuccess()");
   if (!shouldEnqueueEvent())
     return;
   onSuccessInternal(IDBAny::createUndefined());
 }
 
 void IDBRequest::onSuccessInternal(IDBAny* result) {
-  DCHECK(!m_contextStopped);
+  DCHECK(getExecutionContext());
   DCHECK(!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;
 
   DCHECK(m_pendingCursor);
   setResultCursor(m_pendingCursor.release(), key, primaryKey, std::move(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 && getExecutionContext();
 }
 
 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)
@@ skipping 11 matching lines @@
 const AtomicString& IDBRequest::interfaceName() const {
   return EventTargetNames::IDBRequest;
 }
 
 ExecutionContext* IDBRequest::getExecutionContext() const {
   return ActiveDOMObject::getExecutionContext();
 }
 
 DispatchEventResult IDBRequest::dispatchEventInternal(Event* event) {
   IDB_TRACE("IDBRequest::dispatchEvent");
-  if (m_contextStopped || !getExecutionContext())
+  if (!getExecutionContext())
     return DispatchEventResult::CanceledBeforeDispatch;
   DCHECK_EQ(m_readyState, PENDING);
   DCHECK(m_hasPendingActivity);
   DCHECK(m_enqueuedEvents.size());
   DCHECK_EQ(event->target(), this);
 
   if (event->type() != EventTypeNames::blocked)
     m_readyState = DONE;
   dequeueEvent(event);
 
@@ skipping 83 matching lines @@
 }
 
 void IDBRequest::transactionDidFinishAndDispatch() {
   DCHECK(m_transaction);
   DCHECK(m_transaction->isVersionChange());
   DCHECK(m_didFireUpgradeNeededEvent);
   DCHECK_EQ(m_readyState, DONE);
   DCHECK(getExecutionContext());
   m_transaction.clear();
 
-  if (m_contextStopped)
+  if (!getExecutionContext())
     return;
 
   m_readyState = PENDING;
 }
 
 void IDBRequest::enqueueEvent(Event* event) {
   DCHECK(m_readyState == PENDING || m_readyState == DONE);
 
-  if (m_contextStopped || !getExecutionContext())
+  if (!getExecutionContext())
     return;
 
   DCHECK(m_readyState == PENDING || m_didFireUpgradeNeededEvent)
       << "When queueing event " << event->type() << ", m_readyState was "
       << m_readyState;
 
   EventQueue* eventQueue = getExecutionContext()->getEventQueue();
   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))
     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