Turn IDBTransaction into the ContextLifecycleObserver it needs to be.

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 90 matching lines @@
 
   Persistent<IDBTransaction> m_transaction;
 };
 
 }  // namespace
 
 IDBTransaction::IDBTransaction(ExecutionContext* executionContext,
                                int64_t id,
                                const HashSet<String>& scope,
                                IDBDatabase* db)
-    : ContextClient(executionContext),
+    : ContextLifecycleObserver(executionContext),
       m_id(id),
       m_database(db),
       m_mode(WebIDBTransactionModeReadOnly),
       m_scope(scope),
       m_state(Active) {
   DCHECK(m_database);
   DCHECK(!m_scope.isEmpty()) << "Observer transactions must operate "
                                 "on a well-defined set of stores";
   m_database->transactionCreated(this);
 }
 
 IDBTransaction::IDBTransaction(ScriptState* scriptState,
                                int64_t id,
                                const HashSet<String>& scope,
                                WebIDBTransactionMode mode,
                                IDBDatabase* db)
-    : ContextClient(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)
-    : ContextClient(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() {
+  // Note: IDBTransaction is a ContextLifecycleObserver (rather than
+  // ContextClient) only in order to be able call upon getExecutionContext()
+  // during this destructor.
   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);
-  ContextClient::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 281 matching lines @@
     objectStoreNames->append(objectStoreName);
   objectStoreNames->sort();
   return objectStoreNames;
 }
 
 const AtomicString& IDBTransaction::interfaceName() const {
   return EventTargetNames::IDBTransaction;
 }
 
 ExecutionContext* IDBTransaction::getExecutionContext() const {
-  return ContextClient::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