[IndexedDB] Adding transaction and value support to observers

content/browser/indexed_db/indexed_db_transaction.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_transaction.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 209 matching lines @@
       // re-entrantly as that may renter the coordinator.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&CommitUnused, ptr_factory_.GetWeakPtr()));
     }
     return;
   }
 
   RunTasksIfStarted();
 }
 
+void IndexedDBTransaction::GrabSnapshotThenStart() {
+  DCHECK(!backing_store_transaction_begun_);
+  transaction_->Begin();
+  backing_store_transaction_begun_ = true;
+  Start();
+}
+
 class BlobWriteCallbackImpl : public IndexedDBBackingStore::BlobWriteCallback {
  public:
   explicit BlobWriteCallbackImpl(
       base::WeakPtr<IndexedDBTransaction> transaction)
       : transaction_(std::move(transaction)) {}
 
   leveldb::Status Run(IndexedDBBackingStore::BlobWriteResult result) override {
     if (!transaction_)
       return leveldb::Status::OK();
     return transaction_->BlobWriteComplete(result);
@@ skipping 117 matching lines @@
     if (!connection_changes_map_.empty()) {
       database_->SendObservations(std::move(connection_changes_map_));
       connection_changes_map_.clear();
     }
     {
       IDB_TRACE1(
           "IndexedDBTransaction::CommitPhaseTwo.TransactionCompleteCallbacks",
           "txn.id", id());
       callbacks_->OnComplete(*this);
     }
-    if (!pending_observers_.empty() && connection_) {
+    if (!pending_observers_.empty() && connection_)
       connection_->ActivatePendingObservers(std::move(pending_observers_));
-      pending_observers_.clear();
-    }
 
     database_->TransactionFinished(this, true);
     // RemoveTransaction will delete |this|.
     connection_->RemoveTransaction(id_);
     return s;
   } else {
     while (!abort_task_stack_.empty())
       abort_task_stack_.pop().Run();
 
     IndexedDBDatabaseError error;
@@ skipping 94 matching lines @@
 void IndexedDBTransaction::CloseOpenCursors() {
   IDB_TRACE1("IndexedDBTransaction::CloseOpenCursors", "txn.id", id());
   for (auto* cursor : open_cursors_)
     cursor->Close();
   open_cursors_.clear();
 }
 
 void IndexedDBTransaction::AddPendingObserver(
     int32_t observer_id,
     const IndexedDBObserver::Options& options) {
+  CHECK_NE(mode(), blink::WebIDBTransactionModeVersionChange);

[jsbell, 2017/01/13 00:14:12]

It seems like DCHECK_NE would be fine here?

[dmurph, 2017/01/13 01:50:43]

Sure.

   pending_observers_.push_back(base::MakeUnique<IndexedDBObserver>(
       observer_id, object_store_ids_, options));
 }
 
 void IndexedDBTransaction::RemovePendingObservers(
     const std::vector<int32_t>& pending_observer_ids) {
   const auto& it = std::remove_if(
       pending_observers_.begin(), pending_observers_.end(),
       [&pending_observer_ids](const std::unique_ptr<IndexedDBObserver>& o) {
         return base::ContainsValue(pending_observer_ids, o->id());
       });
   if (it != pending_observers_.end())
     pending_observers_.erase(it, pending_observers_.end());
 }
 
 void IndexedDBTransaction::AddObservation(
     int32_t connection_id,
     ::indexed_db::mojom::ObservationPtr observation) {
   auto it = connection_changes_map_.find(connection_id);
   if (it == connection_changes_map_.end()) {
     it = connection_changes_map_
              .insert(std::make_pair(
                  connection_id, ::indexed_db::mojom::ObserverChanges::New()))
              .first;
   }
   it->second->observations.push_back(std::move(observation));
 }
 
-void IndexedDBTransaction::RecordObserverForLastObservation(
-    int32_t connection_id,
-    int32_t observer_id) {
+::indexed_db::mojom::ObserverChangesPtr*
+IndexedDBTransaction::GetPendingChangesForConnection(int32_t connection_id) {
   auto it = connection_changes_map_.find(connection_id);
-  DCHECK(it != connection_changes_map_.end());
-  it->second->observation_index_map[observer_id].push_back(
-      it->second->observations.size() - 1);
+  if (it != connection_changes_map_.end())
+    return &it->second;
+  return nullptr;
 }
 
 }  // namespace content