IDBObserver: Lifetime Management: Adding Observer

content/browser/indexed_db/indexed_db_dispatcher_host.cc

 // Copyright (c) 2012 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_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 175 matching lines @@
     connection->Close();
     delete connection;
     return -1;
   }
   int32_t ipc_database_id = database_dispatcher_host_->map_.Add(connection);
   context()->ConnectionOpened(origin, connection);
   database_dispatcher_host_->database_origin_map_[ipc_database_id] = origin;
   return ipc_database_id;
 }
 
+int64_t IndexedDBDispatcherHost::HostObserverId(int64_t observer_id) {
+  // Inject the renderer process id into the observer id, to
+  // uniquely identify this observer, and effectively bind it to
+  // the renderer that initiated it. The lower 32 bits of
+  // observer_id are guaranteed to be unique within that renderer.

[Marijn Kruisselbrink, 2016/06/15 13:14:57]

There is no such guarantee. There is a separate IndexedDBDispatcher for each
thread in the renderer (so documents and workers don't share the same dispatcher
instance). And at least as currently implemented there are no guarantees that
those two separate dispatchers don't create the same IDs.
Separately I'm not quite sure what these IDs are used for/why we need this
complicated ID scheme. It all seems rather fragile/complicated...

[palakj1, 2016/06/16 07:05:40]

Oh, I was trying to imitate the way host transaction id are generated. Changed
now to djb2 hash suggested by dmurph.

+  base::ProcessId pid = peer_pid();
+  DCHECK(!(observer_id >> 32)) << "observer ids can only be 32 bits";
+  static_assert(sizeof(base::ProcessId) <= sizeof(int32_t),
+                "Process ID must fit in 32 bits");
+
+  return observer_id | (static_cast<uint64_t>(pid) << 32);
+}
+
+int64_t IndexedDBDispatcherHost::RendererObserverId(int64_t host_observer_id) {
+  DCHECK(host_observer_id >> 32 == peer_pid())
+      << "Invalid renderer target for observer id";
+  return host_observer_id & 0xffffffff;
+}
+
+// Do I need this for observer? origin?
 void IndexedDBDispatcherHost::RegisterTransactionId(int64_t host_transaction_id,
                                                     const url::Origin& origin) {
   if (!database_dispatcher_host_)
     return;
   database_dispatcher_host_->transaction_size_map_[host_transaction_id] = 0;
   database_dispatcher_host_->transaction_origin_map_[host_transaction_id] =
       origin;
 }
 
 int64_t IndexedDBDispatcherHost::HostTransactionId(int64_t transaction_id) {
@@ skipping 307 matching lines @@
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCreateObjectStore,
                         OnCreateObjectStore)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDeleteObjectStore,
                         OnDeleteObjectStore)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCreateTransaction,
                         OnCreateTransaction)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseClose, OnClose)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseVersionChangeIgnored,
                         OnVersionChangeIgnored)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDestroyed, OnDestroyed)
+    IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseObserve, OnObserve)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseGet, OnGet)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseGetAll, OnGetAll)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabasePut, OnPutWrapper)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseSetIndexKeys, OnSetIndexKeys)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseSetIndexesReady,
                         OnSetIndexesReady)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseOpenCursor, OnOpenCursor)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseCount, OnCount)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseDeleteRange, OnDeleteRange)
     IPC_MESSAGE_HANDLER(IndexedDBHostMsg_DatabaseClear, OnClear)
@@ skipping 89 matching lines @@
   if (!connection)
     return;
   if (connection->IsConnected())
     connection->Close();
   parent_->context()->ConnectionClosed(database_origin_map_[ipc_object_id],
                                        connection);
   database_origin_map_.erase(ipc_object_id);
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnObserve(
+    const IndexedDBHostMsg_DatabaseObserve_Params& params) {
+  DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
+  IndexedDBConnection* connection =
+      parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
+  if (!connection || !connection->IsConnected())
+    return;
+
+  observers_.push_back(params.observer_id);
+  connection->database()->Observe(
+      parent_->HostTransactionId(params.transaction_id),
+      parent_->HostObserverId(params.observer_id));
+}
+
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGet(
     const IndexedDBHostMsg_DatabaseGet_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
@@ skipping 400 matching lines @@
     DLOG(ERROR) << "Unable to reset prefetch";
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32_t ipc_object_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content