[IndexedDB] Propogating changes to observers : Renderer

content/child/indexed_db/indexed_db_dispatcher.cc

 // Copyright 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/child/indexed_db/indexed_db_dispatcher.h"
 
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_local.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
 #include "content/child/indexed_db/webidbcursor_impl.h"
 #include "content/child/indexed_db/webidbdatabase_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "ipc/ipc_channel.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseCallbacks.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
+#include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBObservation.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBValue.h"
 
 using blink::WebBlobInfo;
 using blink::WebData;
 using blink::WebIDBCallbacks;
 using blink::WebIDBCursor;
 using blink::WebIDBDatabase;
 using blink::WebIDBDatabaseCallbacks;
 using blink::WebIDBDatabaseError;
 using blink::WebIDBKey;
 using blink::WebIDBMetadata;
+using blink::WebIDBObservation;
 using blink::WebIDBObserver;
 using blink::WebIDBValue;
 using blink::WebString;
 using blink::WebVector;
 using base::ThreadLocalPointer;
 
 namespace content {
 static base::LazyInstance<ThreadLocalPointer<IndexedDBDispatcher> >::Leaky
     g_idb_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 75 matching lines @@
       web_index_metadata.keyPath =
           WebIDBKeyPathBuilder::Build(idb_index_metadata.key_path);
       web_index_metadata.unique = idb_index_metadata.unique;
       web_index_metadata.multiEntry = idb_index_metadata.multi_entry;
     }
   }
 
   return web_metadata;
 }
 
+std::vector<WebIDBObservation> IndexedDBDispatcher::ConvertObservations(
+    const std::vector<IndexedDBMsg_Observation>& idb_observations) {
+  std::vector<WebIDBObservation> web_observations;
+  for (const auto& idb_observation : idb_observations) {
+    WebIDBObservation web_observation;
+    web_observation.objectStoreId = idb_observation.object_store_id;
+    web_observation.type = idb_observation.type;
+    web_observation.keyRange =
+        WebIDBKeyRangeBuilder::Build(idb_observation.key_range);
+    web_observations.push_back(std::move(web_observation));
+  }
+  return web_observations;
+}
+
 void IndexedDBDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(IndexedDBDispatcher, msg)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBCursor,
                         OnSuccessOpenCursor)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessCursorAdvance,
                         OnSuccessCursorContinue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessCursorContinue,
                         OnSuccessCursorContinue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessCursorPrefetch,
@@ skipping 11 matching lines @@
                         OnSuccessUndefined)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksError, OnError)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksIntBlocked, OnIntBlocked)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksUpgradeNeeded, OnUpgradeNeeded)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksForcedClose,
                         OnForcedClose)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksVersionChange,
                         OnVersionChange)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksAbort, OnAbort)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksComplete, OnComplete)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksChanges, OnDatabaseChange)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // If a message gets here, IndexedDBMessageFilter already determined that it
   // is an IndexedDB message.
   DCHECK(handled) << "Didn't handle a message defined at line "
                   << IPC_MESSAGE_ID_LINE(msg.type());
 }
 
 bool IndexedDBDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
 int32_t IndexedDBDispatcher::AddIDBObserver(
     int32_t ipc_database_id,
     int64_t transaction_id,
     std::unique_ptr<WebIDBObserver> observer) {
+  IndexedDBHostMsg_DatabaseObserve_Params params;
+  params.include_transaction = observer->transaction();
+  params.no_records = observer->noRecords();
+  params.values = observer->values();
   int32_t observer_id = observers_.Add(observer.release());
-  Send(new IndexedDBHostMsg_DatabaseObserve(ipc_database_id, transaction_id,
-                                            observer_id));
+  params.ipc_database_id = ipc_database_id;
+  params.transaction_id = transaction_id;
+  params.observer_id = observer_id;
+  Send(new IndexedDBHostMsg_DatabaseObserve(params));
   return observer_id;
 }
 
 void IndexedDBDispatcher::RemoveIDBObserversFromDatabase(
     int32_t ipc_database_id,
     const std::vector<int32_t>& observer_ids_to_remove) {
   for (int32_t id_to_remove : observer_ids_to_remove) {
     observers_.Remove(id_to_remove);
   }
   Send(new IndexedDBHostMsg_DatabaseUnobserve(ipc_database_id,
@@ skipping 602 matching lines @@
                                      int32_t ipc_database_callbacks_id,
                                      int64_t transaction_id) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onComplete(transaction_id);
 }
 
+void IndexedDBDispatcher::OnDatabaseChange(
+    int32_t ipc_thread_id,
+    int32_t ipc_database_id,
+    const IndexedDBMsg_ObserverChanges& changes) {
+  DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
+  std::vector<WebIDBObservation> observations(
+      ConvertObservations(changes.observations));
+  for (auto& obs : changes.observation_index) {
+    WebIDBObserver* observer = observers_.Lookup(obs.first);
+    // TODO(palakj): Get IDBDatabase object from ipc_database_id.

[dmurph, 2016/07/13 23:29:13]

Does this TODO still apply?

[palakj1, 2016/07/14 17:52:06]

removed.

+    observer->onChange(observations, std::move(obs.second));
+  }
+}
+
 void IndexedDBDispatcher::OnForcedClose(int32_t ipc_thread_id,
                                         int32_t ipc_database_callbacks_id) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onForcedClose();
 }
 
@@ skipping 17 matching lines @@
   typedef std::map<int32_t, WebIDBCursorImpl*>::iterator Iterator;
   for (Iterator i = cursors_.begin(); i != cursors_.end(); ++i) {
     if (i->first == ipc_exception_cursor_id ||
         i->second->transaction_id() != transaction_id)
       continue;
     i->second->ResetPrefetchCache();
   }
 }
 
 }  // namespace content