[IndexedDB] Propogating Changes to Observer : Browser

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"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.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_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
+#include "content/browser/indexed_db/indexed_db_observation.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_value.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ skipping 145 matching lines @@
 
 int32_t IndexedDBDispatcherHost::Add(IndexedDBConnection* connection,
                                      int32_t ipc_thread_id,
                                      const url::Origin& origin) {
   if (!database_dispatcher_host_) {
     connection->Close();
     delete connection;
     return -1;
   }
   int32_t ipc_database_id = database_dispatcher_host_->map_.Add(connection);
+  connection->set_id(ipc_database_id);
   context()->ConnectionOpened(origin, connection);
   database_dispatcher_host_->database_origin_map_[ipc_database_id] = origin;
   return ipc_database_id;
 }
 
 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;
@@ skipping 109 matching lines @@
       idb_index_metadata.key_path = web_index_metadata.key_path;
       idb_index_metadata.unique = web_index_metadata.unique;
       idb_index_metadata.multi_entry = web_index_metadata.multi_entry;
       idb_store_metadata.indexes.push_back(idb_index_metadata);
     }
     metadata.object_stores.push_back(idb_store_metadata);
   }
   return metadata;
 }
 
+IndexedDBMsg_ObserverChanges IndexedDBDispatcherHost::ConvertObserverChanges(
+    std::unique_ptr<IndexedDBObserverChanges> changes) {
+  IndexedDBMsg_ObserverChanges idb_changes;
+  idb_changes.observation_index = changes->release_observation_indices_map();
+  for (auto& observation : changes->release_observations())
+    idb_changes.observations.push_back(ConvertObservation(observation.get()));
+  return idb_changes;
+}
+
+IndexedDBMsg_Observation IndexedDBDispatcherHost::ConvertObservation(
+    const IndexedDBObservation* observation) {
+  // TODO(palakj): Modify function for indexed_db_value. Issue crbug.com/609934.
+  IndexedDBMsg_Observation idb_observation;
+  idb_observation.object_store_id = observation->object_store_id();
+  idb_observation.type = observation->type();
+  idb_observation.key_range = observation->key_range();
+  return idb_observation;
+}
+
 void IndexedDBDispatcherHost::OnIDBFactoryGetDatabaseNames(
     const IndexedDBHostMsg_FactoryGetDatabaseNames_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   if (!IsValidOrigin(params.origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::IDBDH_INVALID_ORIGIN);
     return;
   }
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
@@ skipping 183 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_DatabaseUnobserve, OnUnobserve)
     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;
+  IndexedDBObserver::Options options(params.include_transaction,
+                                     params.no_records, params.values,
+                                     params.operation_types);
+  connection->database()->AddPendingObserver(
+      parent_->HostTransactionId(params.transaction_id), params.observer_id,
+      options);
+}
+
+void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnUnobserve(
+    int32_t ipc_database_id,
+    const std::vector<int32_t>& observer_ids_to_remove) {
+  DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
+  DCHECK(!observer_ids_to_remove.empty());
+  IndexedDBConnection* connection =
+      parent_->GetOrTerminateProcess(&map_, ipc_database_id);
+  if (!connection || !connection->IsConnected())
+    return;
+  connection->RemoveObservers(observer_ids_to_remove);
+}
+
 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