[IndexedDB] Adding transaction and value support to observers

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 22 matching lines @@
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventQueue.h"
 #include "modules/IndexedDBNames.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBIndex.h"
 #include "modules/indexeddb/IDBObjectStore.h"
 #include "modules/indexeddb/IDBOpenDBRequest.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "wtf/PtrUtil.h"
+
 #include <memory>
 
 using blink::WebIDBDatabase;
 
 namespace blink {
 
+IDBTransaction* IDBTransaction::createObserver(
+    ExecutionContext* executionContext,
+    int64_t id,
+    const HashSet<String>& scope,
+    IDBDatabase* db) {
+  DCHECK(!scope.isEmpty()) << "Observer transactions must operate on a "
+                              "well-defined set of stores";
+  IDBTransaction* transaction =
+      new IDBTransaction(executionContext, id, scope, db);
+  return transaction;
+}
+
 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";
   return new IDBTransaction(scriptState, id, scope, mode, db);
@@ skipping 25 matching lines @@
 
  private:
   explicit DeactivateTransactionTask(IDBTransaction* transaction)
       : m_transaction(transaction) {}
 
   Persistent<IDBTransaction> m_transaction;
 };
 
 }  // namespace
 
+IDBTransaction::IDBTransaction(ExecutionContext* executionContext,
+                               int64_t id,
+                               const HashSet<String>& scope,
+                               IDBDatabase* db)
+    : 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)
     : ContextLifecycleObserver(scriptState->getExecutionContext()),
       m_id(id),
       m_database(db),
       m_mode(mode),
       m_scope(scope) {
@@ skipping 463 matching lines @@
     IDBObjectStore* objectStore = it.key;
     objectStore->clearIndexCache();
   }
   m_oldStoreMetadata.clear();
 
   m_deletedIndexes.clear();
   m_deletedObjectStores.clear();
 }
 
 }  // namespace blink