[IndexedDB] Propogating changes to observers : Renderer

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 <memory>
@@ skipping 11 matching lines @@
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_class_factory.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_factory.h"
 #include "content/browser/indexed_db/indexed_db_index_writer.h"
+#include "content/browser/indexed_db/indexed_db_observation.h"
+#include "content/browser/indexed_db/indexed_db_observer_changes.h"
 #include "content/browser/indexed_db/indexed_db_pending_connection.h"
 #include "content/browser/indexed_db/indexed_db_return_value.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/common/indexed_db/indexed_db_constants.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 #include "content/public/common/content_switches.h"
 #include "storage/browser/blob/blob_data_handle.h"
@@ skipping 512 matching lines @@
     const std::vector<int32_t>& pending_observer_ids) {
   TransactionMap::iterator it;
   for (it = transactions_.begin(); it != transactions_.end(); it++) {
     // Avoid call to RemovePendingObservers for transactions on other
     // connections.
     if (it->second->connection() == connection)
       it->second->RemovePendingObservers(pending_observer_ids);
   }
 }
 
+// TODO(palakj): Augment the function with IDBValue later.
+void IndexedDBDatabase::FilterObservation(IndexedDBTransaction* transaction,
+                                          int64_t object_store_id,
+                                          blink::WebIDBOperationType type,
+                                          const IndexedDBKeyRange& key_range) {
+  for (const auto* connection : connections_) {
+    bool recorded = false;
+    for (const auto& observer : connection->active_observers()) {
+      if (observer->IsRecordingType(type) &&
+          observer->IsRecordingObjectStore(object_store_id)) {

[jsbell, 2016/07/11 18:25:33]

It might be more readable to invert this test and `continue;` rather than
indenting further.

[palakj1, 2016/07/11 22:25:40]

Done.

+        if (!recorded) {
+          if (type == blink::WebIDBClear) {
+            transaction->AddObservation(
+                connection->id(), base::WrapUnique(new IndexedDBObservation(
+                                      object_store_id, type)));
+          } else {
+            transaction->AddObservation(
+                connection->id(), base::WrapUnique(new IndexedDBObservation(
+                                      object_store_id, type, key_range)));
+          }
+          recorded = true;
+        }
+        transaction->RecordObserverForLastObservation(observer->id(),
+                                                      connection->id());
+      }
+    }
+  }
+}
+
+void IndexedDBDatabase::SendObservations(
+    std::map<int32_t, std::unique_ptr<IndexedDBObserverChanges>> change_map) {
+  for (const auto& it : connections_)
+    it->callbacks()->OnDatabaseChange(it->id(),
+                                      std::move(change_map[it->id()]));
+}
+
 void IndexedDBDatabase::GetAll(int64_t transaction_id,
                                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) {
   IDB_TRACE1("IndexedDBDatabase::GetAll", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
@@ skipping 534 matching lines @@
       if (s.IsCorruption())
         factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
       return;
     }
   }
   {
     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));
 }
 
 void IndexedDBDatabase::SetIndexKeys(int64_t transaction_id,
                                      int64_t object_store_id,
                                      std::unique_ptr<IndexedDBKey> primary_key,
                                      const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE1("IndexedDBDatabase::SetIndexKeys", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
@@ skipping 323 matching lines @@
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
   if (experimental_web_platform_features_enabled_) {
     callbacks->OnSuccess(base::checked_cast<int64_t>(delete_count));
   } else {
     callbacks->OnSuccess();
   }
+  FilterObservation(transaction, object_store_id, blink::WebIDBDelete,
+                    *key_range);
 }
 
 void IndexedDBDatabase::Clear(int64_t transaction_id,
                               int64_t object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Clear", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
@@ skipping 15 matching lines @@
   if (!s.ok()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error clearing object store");
     callbacks->OnError(error);
     if (s.IsCorruption()) {
       factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
     }
     return;
   }
   callbacks->OnSuccess();
+
+  FilterObservation(transaction, object_store_id, blink::WebIDBClear,
+                    IndexedDBKeyRange());
 }
 
 void IndexedDBDatabase::DeleteObjectStoreOperation(
     int64_t object_store_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::DeleteObjectStoreOperation",
              "txn.id",
              transaction->id());
 
   const IndexedDBObjectStoreMetadata object_store_metadata =
@@ skipping 464 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content