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 <utility>
+
 #include "base/logging.h"
 #include "base/stl_util.h"
+#include "content/browser/indexed_db/database_factory_impl.h"
+#include "content/public/browser/indexed_db_context.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
+#include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.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) {}
+    scoped_refptr<IndexedDBChangeHandler> change_handler)
+    : database_(database),
+      change_handler_(change_handler),
+      weak_factory_(this) {
+  change_handler->SetConnection(GetWeakPtr());
+}
 
 IndexedDBConnection::~IndexedDBConnection() {}
 
 void IndexedDBConnection::set_id(int32_t id) {
   DCHECK_EQ(id_, kInvalidId);
   id_ = id;
 }
 
+void IndexedDBConnection::ForceClose() {
+  if (!change_handler_.get())
+    return;
+
+  // IndexedDBDatabase::Close() can delete this instance.
+  base::WeakPtr<IndexedDBConnection> this_obj = weak_factory_.GetWeakPtr();
+  scoped_refptr<IndexedDBChangeHandler> change_handler(change_handler_);
+  database_->Close(this, true /* forced */);
+  if (this_obj) {
+    database_ = nullptr;
+    change_handler_ = nullptr;
+    active_observers_.clear();
+  }
+  change_handler->OnForcedClose();
+}
+
+bool IndexedDBConnection::IsConnected() {
+  return database_.get() != NULL;
+}
+
+void IndexedDBConnection::CreateObjectStore(int64_t transaction_id,
+                                            int64_t object_store_id,
+                                            const std::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 transaction_id,
+                                            const std::vector<int64_t>& scope,
+                                            TransactionMode transaction_mode) {}
+
 void IndexedDBConnection::Close() {
-  if (!callbacks_.get())
+  if (!change_handler_.get())
     return;
   base::WeakPtr<IndexedDBConnection> this_obj = weak_factory_.GetWeakPtr();
   database_->Close(this, false /* forced */);
   if (this_obj) {
     database_ = nullptr;
-    callbacks_ = nullptr;
+    change_handler_ = 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();
-}
-
 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::OnGotUsageAndQuotaForCommit(
+    int64_t transaction_id,
+    storage::QuotaStatusCode status,
+    int64_t usage,
+    int64_t quota) {
+  DCHECK(context()->TaskRunner()->RunsTasksOnCurrentThread());
+  // May have disconnected while quota check was pending.
+  if (!IsConnected())
+    return;
+  // May have aborted while quota check was pending.
+  if (!base::ContainsKey(transaction_id_to_size_, transaction_id))
+    return;
+  int64_t transaction_size = transaction_id_to_size_[transaction_id];
+
+  if (status == storage::kQuotaStatusOk && usage + transaction_size <= quota) {
+    database()->Commit(transaction_id);
+  } else {
+    database()->Abort(
+        transaction_id,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError));
+  }
+}
+
+void IndexedDBConnection::Commit(int64_t transaction_id) {
+  if (!IsConnected())
+    return;
+
+  // May have been aborted by back end before front-end could request commit.
+  if (!base::ContainsKey(transaction_id_to_size_, transaction_id))
+    return;
+  int64_t transaction_size = transaction_id_to_size_[transaction_id];
+
+  // Always allow empty or delete-only transactions.
+  if (!transaction_size) {
+    database()->Commit(transaction_id);
+    return;
+  }
+
+  context()->quota_manager_proxy()->GetUsageAndQuota(
+      context()->TaskRunner(),
+      GURL(transaction_id_to_origin_[transaction_id].Serialize()),
+      storage::kStorageTypeTemporary,
+      base::Bind(&IndexedDBConnection::OnGotUsageAndQuotaForCommit,
+                 weak_factory_.GetWeakPtr(), transaction_id));
+}
+
+void IndexedDBConnection::CreateIndex(int64_t transaction_id,
+                                      int64_t object_store_id,
+                                      int64_t index_id,
+                                      const std::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 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
+
+  // TODO(cmumford): Set the error data.
+  content::IndexedDBDatabaseError error;
+  // TODO(cmumford): Can we somehow use GetResult::From()?
+  ::indexed_db::mojom::GetResultPtr result =
+      ::indexed_db::mojom::GetResult::New();
+  result->set_error(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,
+                              const std::vector<int8_t>& value,
+                              std::vector<BlobInfoPtr> blob_info,
+                              KeyPtr key,
+                              PutMode put_mode,
+                              const std::vector<int64_t>& index_ids,
+                              std::vector<std::vector<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,
+    const std::vector<int64_t>& index_ids,
+    std::vector<std::vector<KeyPtr>> index_keys) {}
+
+void IndexedDBConnection::SetIndexesReady(
+    int64_t transaction_id,
+    int64_t object_store_id,
+    const std::vector<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(
+    const std::vector<std::string>& uuids) {}
+
+void IndexedDBConnection::Bind(::indexed_db::mojom::DatabaseRequest request) {
+  binding_.AddBinding(this, std::move(request));
 }
 
 // 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();
 }
 
 void IndexedDBConnection::RemoveObservers(
     const std::vector<int32_t>& observer_ids_to_remove) {
   std::vector<int32_t> pending_observer_ids;
   for (int32_t id_to_remove : observer_ids_to_remove) {
     const auto& it = std::find_if(
         active_observers_.begin(), active_observers_.end(),
         [&id_to_remove](const std::unique_ptr<IndexedDBObserver>& o) {
           return o->id() == id_to_remove;
         });
     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);
 }
 
+void IndexedDBConnection::RegisterTransactionId(int64_t transaction_id,
+                                                const url::Origin& origin) {
+  transaction_id_to_size_[transaction_id] = 0;
+  transaction_id_to_origin_[transaction_id] = origin;
+}
+
+void IndexedDBConnection::FinishTransaction(int64_t transaction_id,
+                                            bool committed) {
+  if (committed)
+    context()->TransactionComplete(transaction_id_to_origin_[transaction_id]);
+  transaction_id_to_origin_.erase(transaction_id);
+  transaction_id_to_size_.erase(transaction_id);
+  // TODO(cmumford): transaction_id_to_database_id_ is not currently being set.
+  transaction_id_to_database_id_.erase(transaction_id);
+}
+
+IndexedDBContext* IndexedDBConnection::context() const {
+  return database_->context();
+}
+
 }  // namespace content