Reduce SuspendableObjects

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 38 matching lines @@
 
 IDBTransaction* IDBTransaction::createNonVersionChange(
     ScriptState* scriptState,
     int64_t id,
     const HashSet<String>& scope,
     WebIDBTransactionMode mode,
     IDBDatabase* db) {
   DCHECK_NE(mode, WebIDBTransactionModeVersionChange);
   DCHECK(!scope.isEmpty()) << "Non-version transactions should operate on a "
                               "well-defined set of stores";
-  IDBTransaction* transaction =
-      new IDBTransaction(scriptState, id, scope, mode, db);
-  transaction->suspendIfNeeded();
-  return transaction;
+  return new IDBTransaction(scriptState, id, scope, mode, db);
 }
 
 IDBTransaction* IDBTransaction::createVersionChange(
     ExecutionContext* executionContext,
     int64_t id,
     IDBDatabase* db,
     IDBOpenDBRequest* openDBRequest,
     const IDBDatabaseMetadata& oldMetadata) {
-  IDBTransaction* transaction =
-      new IDBTransaction(executionContext, id, db, openDBRequest, oldMetadata);
-  transaction->suspendIfNeeded();
-  return transaction;
+  return new IDBTransaction(executionContext, id, db, openDBRequest,
+                            oldMetadata);
 }
 
 namespace {
 
 class DeactivateTransactionTask : public V8PerIsolateData::EndOfScopeTask {
  public:
   static std::unique_ptr<DeactivateTransactionTask> create(
       IDBTransaction* transaction) {
     return WTF::wrapUnique(new DeactivateTransactionTask(transaction));
   }
@@ skipping 10 matching lines @@
   Persistent<IDBTransaction> m_transaction;
 };
 
 }  // namespace
 
 IDBTransaction::IDBTransaction(ScriptState* scriptState,
                                int64_t id,
                                const HashSet<String>& scope,
                                WebIDBTransactionMode mode,
                                IDBDatabase* db)
-    : SuspendableObject(scriptState->getExecutionContext()),
+    : ContextLifecycleObserver(scriptState->getExecutionContext()),
       m_id(id),
       m_database(db),
       m_mode(mode),
       m_scope(scope) {
   DCHECK(m_database);
   DCHECK(!m_scope.isEmpty()) << "Non-versionchange transactions must operate "
                                 "on a well-defined set of stores";
   DCHECK(m_mode == WebIDBTransactionModeReadOnly ||
          m_mode == WebIDBTransactionModeReadWrite)
       << "Invalid transaction mode";
 
   DCHECK_EQ(m_state, Active);
   V8PerIsolateData::from(scriptState->isolate())
       ->addEndOfScopeTask(DeactivateTransactionTask::create(this));
 
   m_database->transactionCreated(this);
 }
 
 IDBTransaction::IDBTransaction(ExecutionContext* executionContext,
                                int64_t id,
                                IDBDatabase* db,
                                IDBOpenDBRequest* openDBRequest,
                                const IDBDatabaseMetadata& oldMetadata)
-    : SuspendableObject(executionContext),
+    : ContextLifecycleObserver(executionContext),
       m_id(id),
       m_database(db),
       m_openDBRequest(openDBRequest),
       m_mode(WebIDBTransactionModeVersionChange),
       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 || !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);
   EventTargetWithInlineData::trace(visitor);
-  SuspendableObject::trace(visitor);
+  ContextLifecycleObserver::trace(visitor);
 }
 
 void IDBTransaction::setError(DOMException* error) {
   DCHECK_NE(m_state, Finished);
   DCHECK(error);
 
   // The first error to be set is the true cause of the
   // transaction abort.
   if (!m_error)
     m_error = error;
@@ skipping 282 matching lines @@
     objectStoreNames->append(objectStoreName);
   objectStoreNames->sort();
   return objectStoreNames;
 }
 
 const AtomicString& IDBTransaction::interfaceName() const {
   return EventTargetNames::IDBTransaction;
 }
 
 ExecutionContext* IDBTransaction::getExecutionContext() const {
-  return SuspendableObject::getExecutionContext();
+  return ContextLifecycleObserver::getExecutionContext();
 }
 
 DispatchEventResult IDBTransaction::dispatchEventInternal(Event* event) {
   IDB_TRACE("IDBTransaction::dispatchEvent");
   if (!getExecutionContext()) {
     m_state = Finished;
     return DispatchEventResult::CanceledBeforeDispatch;
   }
   DCHECK_NE(m_state, Finished);
   DCHECK(m_hasPendingActivity);
@@ skipping 102 matching lines @@
     IDBObjectStore* objectStore = it.key;
     objectStore->clearIndexCache();
   }
   m_oldStoreMetadata.clear();
 
   m_deletedIndexes.clear();
   m_deletedObjectStores.clear();
 }
 
 }  // namespace blink