Replacing Indexed DB Chromium IPC with Mojo

content/browser/indexed_db/indexed_db_connection.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/browser/indexed_db/indexed_db_connection.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 
+using ::indexed_db::mojom::BlobInfoPtr;
+using ::indexed_db::mojom::CursorDirection;
+using ::indexed_db::mojom::KeyPtr;
+using ::indexed_db::mojom::KeyRangePtr;
+using ::indexed_db::mojom::PutMode;
+using ::indexed_db::mojom::TaskType;
+using ::indexed_db::mojom::TransactionMode;
+
 namespace content {
 
 IndexedDBConnection::IndexedDBConnection(
     scoped_refptr<IndexedDBDatabase> database,
     scoped_refptr<IndexedDBDatabaseCallbacks> callbacks)
-    : database_(database), callbacks_(callbacks), weak_factory_(this) {}
+    : database_(database),
+      callbacks_(callbacks),
+      binding_(this),
+      weak_factory_(this) {}
 
 IndexedDBConnection::~IndexedDBConnection() {}
 
-void IndexedDBConnection::Close() {
-  if (!callbacks_.get())
-    return;
-  base::WeakPtr<IndexedDBConnection> this_obj = weak_factory_.GetWeakPtr();
-  database_->Close(this, false /* forced */);
-  if (this_obj) {
-    database_ = nullptr;
-    callbacks_ = nullptr;
-    active_observers_.clear();
-  }
-}
-
 void IndexedDBConnection::ForceClose() {
   if (!callbacks_.get())
     return;
 
   // IndexedDBDatabase::Close() can delete this instance.
   base::WeakPtr<IndexedDBConnection> this_obj = weak_factory_.GetWeakPtr();
   scoped_refptr<IndexedDBDatabaseCallbacks> callbacks(callbacks_);
   database_->Close(this, true /* forced */);
   if (this_obj) {
     database_ = nullptr;
     callbacks_ = nullptr;
     active_observers_.clear();
   }
   callbacks->OnForcedClose();
 }
 
+bool IndexedDBConnection::IsConnected() {
+  return database_.get() != NULL;
+}
+
+void IndexedDBConnection::CreateObjectStore(int64_t transaction_id,
+                                            int64_t object_store_id,
+                                            const mojo::String& name,
+                                            const IndexedDBKeyPath& key_path,
+                                            bool auto_increment) {}
+
+void IndexedDBConnection::DeleteObjectStore(int64_t transaction_id,
+                                            int64_t object_store_id) {}
+
+void IndexedDBConnection::CreateTransaction(int64_t id,
+                                            mojo::Array<int64_t> scope,
+                                            TransactionMode transaction_mode) {}
+
+void IndexedDBConnection::Close() {
+  if (!callbacks_.get())
+    return;
+  base::WeakPtr<IndexedDBConnection> this_obj = weak_factory_.GetWeakPtr();
+  database_->Close(this, false /* forced */);
+  if (this_obj) {
+    database_ = nullptr;
+    callbacks_ = nullptr;
+    active_observers_.clear();
+  }
+}
+
 void IndexedDBConnection::VersionChangeIgnored() {
   if (!database_.get())
     return;
   database_->VersionChangeIgnored();
 }
 
-bool IndexedDBConnection::IsConnected() {
-  return database_.get() != NULL;
+void IndexedDBConnection::Abort(int64_t transaction_id) {}
+
+void IndexedDBConnection::Commit(int64_t transaction_id) {}
+
+void IndexedDBConnection::CreateIndex(int64_t transaction_id,
+                                      int64_t object_store_id,
+                                      int64_t index_id,
+                                      const mojo::String& name,
+                                      const IndexedDBKeyPath& key_path,
+                                      bool unique,
+                                      bool multi_entry) {}
+
+void IndexedDBConnection::DeleteIndex(int64_t transaction_id,
+                                      int64_t object_store_id,
+                                      int64_t index_id) {}
+
+void IndexedDBConnection::Get(int64_t database_id,
+                              int64_t transaction_id,
+                              int64_t object_store_id,
+                              int64_t index_id,
+                              KeyRangePtr key_range,
+                              bool key_only,
+                              const GetCallback& callback) {
+  if (!IsConnected())
+    return;
+
+#if 0
+  connection->database()->Get(
+      HostTransactionId(transaction_id), object_store_id,
+      index_id,
+      base::WrapUnique(new IndexedDBKeyRange(key_range)),
+      params.key_only, callbacks);
+#endif
+#if 0
+  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));
+  connection->database()->Get(
+      parent_->HostTransactionId(params.transaction_id), params.object_store_id,
+      params.index_id,
+      base::WrapUnique(new IndexedDBKeyRange(params.key_range)),
+      params.key_only, callbacks);
+#endif
+
+  ::indexed_db::mojom::GetResultPtr result =
+      ::indexed_db::mojom::GetResult::New();
+  result->type = ::indexed_db::mojom::ResultType::Error;
+  callback.Run(std::move(result));
+}
+
+void IndexedDBConnection::GetAll(int64_t transaction_id,
+                                 int64_t object_store_id,
+                                 int64_t index_id,
+                                 KeyRangePtr key_range,
+                                 int64_t max_count,
+                                 bool key_only) {}
+
+void IndexedDBConnection::Put(int64_t transaction_id,
+                              int64_t object_store_id,
+                              mojo::Array<int8_t> value,
+                              mojo::Array<BlobInfoPtr> blob_info,
+                              KeyPtr key,
+                              PutMode put_mode,
+                              mojo::Array<int64_t> index_ids,
+                              mojo::Array<mojo::Array<KeyPtr>> index_keys) {}
+
+void IndexedDBConnection::DeleteRange(int64_t transaction_id,
+                                      int64_t object_store_id,
+                                      KeyRangePtr key_range) {}
+
+void IndexedDBConnection::Clear(int64_t transaction_id,
+                                int64_t object_store_id) {}
+
+void IndexedDBConnection::SetIndexKeys(
+    int64_t transaction_id,
+    int64_t object_store_id,
+    KeyPtr primary_key,
+    mojo::Array<int64_t> index_ids,
+    mojo::Array<mojo::Array<KeyPtr>> index_keys) {}
+
+void IndexedDBConnection::SetIndexesReady(int64_t transaction_id,
+                                          int64_t object_store_id,
+                                          mojo::Array<int64_t> index_ids) {}
+
+void IndexedDBConnection::OpenCursor(int64_t transaction_id,
+                                     int64_t object_store_id,
+                                     int64_t index_id,
+                                     KeyRangePtr key_range,
+                                     CursorDirection direction,
+                                     bool key_only,
+                                     TaskType task_type) {}
+
+void IndexedDBConnection::Count(int64_t transaction_id,
+                                int64_t object_store_id,
+                                int64_t index_id,
+                                KeyRangePtr key_range) {}
+
+void IndexedDBConnection::AckReceivedBlobs(mojo::Array<mojo::String> uuids) {}
+
+::indexed_db::mojom::DatabasePtr IndexedDBConnection::CreateInterface() {
+  ::indexed_db::mojom::DatabasePtr interface;
+  binding_.Bind(&interface);
+  return interface;
 }
 
 // The observers begin listening to changes only once they are activated.
 void IndexedDBConnection::ActivatePendingObservers(
     std::vector<std::unique_ptr<IndexedDBObserver>> pending_observers) {
   for (auto& observer : pending_observers) {
     active_observers_.push_back(std::move(observer));
   }
   pending_observers.clear();
 }
@@ skipping 10 matching lines @@
     if (it != active_observers_.end())
       active_observers_.erase(it);
     else
       pending_observer_ids.push_back(id_to_remove);
   }
   if (!pending_observer_ids.empty())
     database_->RemovePendingObservers(this, pending_observer_ids);
 }
 
 }  // namespace content