[IndexedDB] Adding transaction and value support to observers

content/browser/indexed_db/indexed_db_database.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/indexed_db/indexed_db_database.h"
 
 #include <math.h>
 
 #include <limits>
 #include <set>
@@ skipping 782 matching lines @@
 }
 
 void IndexedDBDatabase::AddPendingObserver(
     IndexedDBTransaction* transaction,
     int32_t observer_id,
     const IndexedDBObserver::Options& options) {
   DCHECK(transaction);
   transaction->AddPendingObserver(observer_id, options);
 }
 
-// TODO(palakj): Augment the function with IDBValue later. Issue
-// crbug.com/609934.
 void IndexedDBDatabase::FilterObservation(IndexedDBTransaction* transaction,
                                           int64_t object_store_id,
                                           blink::WebIDBOperationType type,
-                                          const IndexedDBKeyRange& key_range) {
+                                          const IndexedDBKeyRange& key_range,
+                                          const IndexedDBValue* value) {
   for (auto* connection : connections_) {
     bool recorded = false;
     for (const auto& observer : connection->active_observers()) {
       if (!observer->IsRecordingType(type) ||
           !observer->IsRecordingObjectStore(object_store_id))
         continue;
       if (!recorded) {
         auto observation = ::indexed_db::mojom::Observation::New();
         observation->object_store_id = object_store_id;
         observation->type = type;
         if (type != blink::WebIDBClear)
           observation->key_range = key_range;
         transaction->AddObservation(connection->id(), std::move(observation));
         recorded = true;
       }
-      transaction->RecordObserverForLastObservation(connection->id(),
-                                                    observer->id());
+      ::indexed_db::mojom::ObserverChangesPtr& changes =
+          *transaction->GetPendingChangesForConnection(connection->id());
+
+      changes->observation_index_map[observer->id()].push_back(
+          changes->observations.size() - 1);

[palmer, 2017/01/18 19:56:01]

Why - 1 ?

[dmurph, 2017/01/18 21:00:57]

We want the last index.

+      if (observer->include_transaction() &&
+          !base::ContainsKey(changes->transaction_map, observer->id())) {
+        auto mojo_transaction = ::indexed_db::mojom::ObserverTransaction::New();
+        mojo_transaction->id = connection->NewObserverTransactionId();
+        mojo_transaction->scope.insert(mojo_transaction->scope.end(),
+                                       observer->object_store_ids().begin(),
+                                       observer->object_store_ids().end());
+        changes->transaction_map[observer->id()] = std::move(mojo_transaction);
+      }
+      if (value && observer->values() && !changes->observations.back()->value) {
+        IndexedDBValue copy = *value;

[palmer, 2017/01/18 19:56:01]

Yeah, here's the copy you were talking about, right? Its sole purpose seems to
be to make ConvertValue work, so if this is the only call site, maybe you could
refactor ConvertValue to do the copy. Then maybe you could get both cleaner
semantics and not-worse performance? Your call; I don't know this code like you
do.

[dmurph, 2017/01/18 21:00:57]

I added a bug mention here - we want to avoid IndexedDBValue copies when
avoidable. Bug has solution idea.

+        changes->observations.back()->value =
+            IndexedDBCallbacks::ConvertValue(&copy);
+      }
     }
   }
 }
 
 void IndexedDBDatabase::SendObservations(
     std::map<int32_t, ::indexed_db::mojom::ObserverChangesPtr> changes_map) {
   for (auto* conn : connections_) {
     auto it = changes_map.find(conn->id());
-    if (it != changes_map.end())
-      conn->callbacks()->OnDatabaseChange(std::move(it->second));
+    if (it == changes_map.end())
+      continue;
+
+    // Start all of the transactions.
+    ::indexed_db::mojom::ObserverChangesPtr& changes = it->second;
+    for (const auto& transaction_pair : changes->transaction_map) {
+      std::set<int64_t> scope(transaction_pair.second->scope.begin(),
+                              transaction_pair.second->scope.end());
+      IndexedDBTransaction* transaction = conn->CreateTransaction(
+          transaction_pair.second->id, scope,
+          blink::WebIDBTransactionModeReadOnly,
+          new IndexedDBBackingStore::Transaction(backing_store_.get()));
+      DCHECK(transaction);
+      transaction_coordinator_.DidCreateObserverTransaction(transaction);
+      transaction_count_++;
+      transaction->GrabSnapshotThenStart();
+    }
+
+    conn->callbacks()->OnDatabaseChange(std::move(it->second));
   }
 }
 
 void IndexedDBDatabase::GetAll(IndexedDBTransaction* transaction,
                                int64_t object_store_id,
                                int64_t index_id,
                                std::unique_ptr<IndexedDBKeyRange> key_range,
                                bool key_only,
                                int64_t max_count,
                                scoped_refptr<IndexedDBCallbacks> callbacks) {
@@ skipping 483 matching lines @@
   }
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.Callbacks", "txn.id",
                transaction->id());
     params->callbacks->OnSuccess(*key);
   }
   FilterObservation(transaction, params->object_store_id,
                     params->put_mode == blink::WebIDBPutModeAddOnly
                         ? blink::WebIDBAdd
                         : blink::WebIDBPut,
-                    IndexedDBKeyRange(*key));
+                    IndexedDBKeyRange(*key), &params->value);
   return s;
 }
 
 void IndexedDBDatabase::SetIndexKeys(
     IndexedDBTransaction* transaction,
     int64_t object_store_id,
     std::unique_ptr<IndexedDBKey> primary_key,
     const std::vector<IndexedDBIndexKeys>& index_keys) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::SetIndexKeys", "txn.id", transaction->id());
@@ skipping 293 matching lines @@
   IDB_TRACE1("IndexedDBDatabase::DeleteRangeOperation", "txn.id",
              transaction->id());
   size_t delete_count = 0;
   leveldb::Status s =
       backing_store_->DeleteRange(transaction->BackingStoreTransaction(), id(),
                                   object_store_id, *key_range, &delete_count);
   if (!s.ok())
     return s;
   callbacks->OnSuccess();
   FilterObservation(transaction, object_store_id, blink::WebIDBDelete,
-                    *key_range);
+                    *key_range, nullptr);
   return s;
 }
 
 void IndexedDBDatabase::Clear(IndexedDBTransaction* transaction,
                               int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(transaction);
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction->id());
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::ClearOperation, this, object_store_id, callbacks));
 }
 
 leveldb::Status IndexedDBDatabase::ClearOperation(
     int64_t object_store_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::ClearOperation", "txn.id", transaction->id());
   leveldb::Status s = backing_store_->ClearObjectStore(
       transaction->BackingStoreTransaction(), id(), object_store_id);
   if (!s.ok())
     return s;
   callbacks->OnSuccess();
 
   FilterObservation(transaction, object_store_id, blink::WebIDBClear,
-                    IndexedDBKeyRange());
+                    IndexedDBKeyRange(), nullptr);
   return s;
 }
 
 leveldb::Status IndexedDBDatabase::DeleteObjectStoreOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
              transaction->id());
 
@@ skipping 213 matching lines @@
   if (status.IsCorruption()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  message);
     factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
   } else {
     factory_->HandleBackingStoreFailure(backing_store_->origin());
   }
 }
 
 }  // namespace content