[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);
@@ skipping 621 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.

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

Communication from the back end to an IDBDatabase is done via
WebIDBDatabaseCallbacks.

Starting in IndexedDBDatabaseCallbacks::OnDatabaseChange you can pass the
ipc_database_callbacks_id_ through in the message instead of ipc_database_id.
That lets you look up a WebIDBDatabaseCallbacks instance in the
IndexedDBDispatcher; you'd add onChange() there and in
WebIDBDatabaseCallbacksImpl and in IDBDatabaseCallbacks which has an IDBDatabase
weakptr.

Look at how OnAbort is propagated back for an example.

(Converting to Mojo will let us eliminate these indirections!)

[palakj1, 2016/07/11 19:37:54]

Thanks for the insight. This seems a good option. 
Our other alternative is to have IDBObserver hold a map of observer_id to
IDBDatabase weakptr corresponding to each observe call 'observer.observe(db)' 
(we already have a set of observer_id here, need to turn it to a map). 
 A benefit with this apporach is that the unobserve logic gets cleaner.
Currently, for observer.unobserve(db) , IDBObserver needs to check with
WebIDBDatabase if the latter holds the observer_id. 
Having a map of observer_id to IDBDatabase, we can complete the entire logic
within IDBObserver. Moving a bit of logic from webidb to blink.
The downside is creating a new weak ptr.

What would you prefer?

[jsbell, 2016/07/11 21:23:04]

It sounds like the weakptr in IDBObserver would be cleaner, so starting with
that approach sgtm.

+    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