Port messages sent by WebIDBDatabaseImpl to Mojo.

content/child/indexed_db/indexed_db_callbacks_impl.cc

 // Copyright 2016 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_callbacks_impl.h"
 
 #include "content/child/indexed_db/indexed_db_dispatcher.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_constants.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBCallbacks.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h"
+#include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBValue.h"
 
+using blink::WebBlobInfo;
 using blink::WebIDBCallbacks;
 using blink::WebIDBDatabase;
 using blink::WebIDBMetadata;
+using blink::WebIDBValue;
 using blink::WebString;
 using blink::WebVector;
+using indexed_db::mojom::DatabaseAssociatedPtrInfo;
 
 namespace content {
 
 namespace {
 
 void ConvertIndexMetadata(const content::IndexedDBIndexMetadata& metadata,
                           WebIDBMetadata::Index* output) {
   output->id = metadata.id;
   output->name = metadata.name;
   output->keyPath = WebIDBKeyPathBuilder::Build(metadata.key_path);
@@ skipping 21 matching lines @@
   output->name = metadata.name;
   output->version = metadata.version;
   output->maxObjectStoreId = metadata.max_object_store_id;
   output->objectStores =
       WebVector<WebIDBMetadata::ObjectStore>(metadata.object_stores.size());
   size_t i = 0;
   for (const auto& iter : metadata.object_stores)
     ConvertObjectStoreMetadata(iter.second, &output->objectStores[i++]);
 }
 
+void ConvertValue(const indexed_db::mojom::ValuePtr& value,
+                  WebIDBValue* web_value) {
+  if (value->bits.empty())
+    return;
+
+  blink::WebVector<WebBlobInfo> local_blob_info(
+      value->blob_or_file_info.size());
+  for (size_t i = 0; i < value->blob_or_file_info.size(); ++i) {
+    const auto& info = value->blob_or_file_info[i];
+    if (info->file) {
+      local_blob_info[i] = WebBlobInfo(
+          WebString::fromUTF8(info->uuid), info->file->path.AsUTF16Unsafe(),
+          info->file->name, info->mime_type,
+          info->file->last_modified.ToDoubleT(), info->size);
+    } else {
+      local_blob_info[i] = WebBlobInfo(WebString::fromUTF8(info->uuid),
+                                       info->mime_type, info->size);
+    }
+  }
+
+  web_value->data.assign(&*value->bits.begin(), value->bits.size());
+  web_value->webBlobInfo.swap(local_blob_info);
+}
+
+void ConvertReturnValue(const indexed_db::mojom::ReturnValuePtr& value,
+                        WebIDBValue* web_value) {
+  ConvertValue(value->value, web_value);
+  web_value->primaryKey = WebIDBKeyBuilder::Build(value->primary_key);
+  web_value->keyPath = WebIDBKeyPathBuilder::Build(value->key_path);
+}
+
 }  // namespace
 
 IndexedDBCallbacksImpl::IndexedDBCallbacksImpl(
     std::unique_ptr<WebIDBCallbacks> callbacks,
+    int64_t transaction_id,
+    scoped_refptr<base::SingleThreadTaskRunner> io_runner,
     scoped_refptr<ThreadSafeSender> thread_safe_sender)
     : internal_state_(new InternalState(std::move(callbacks),
+                                        transaction_id,
+                                        std::move(io_runner),
                                         std::move(thread_safe_sender))),
       callback_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
 IndexedDBCallbacksImpl::~IndexedDBCallbacksImpl() {
   callback_runner_->DeleteSoon(FROM_HERE, internal_state_);
 }
 
 void IndexedDBCallbacksImpl::Error(int32_t code,
                                    const base::string16& message) {
   callback_runner_->PostTask(
       FROM_HERE, base::Bind(&InternalState::Error,
                             base::Unretained(internal_state_), code, message));
 }
 
 void IndexedDBCallbacksImpl::SuccessStringList(
     const std::vector<base::string16>& value) {
   callback_runner_->PostTask(
       FROM_HERE, base::Bind(&InternalState::SuccessStringList,
                             base::Unretained(internal_state_), value));
 }
 
 void IndexedDBCallbacksImpl::Blocked(int64_t existing_version) {
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InternalState::Blocked, base::Unretained(internal_state_),
                  existing_version));
 }
 
 void IndexedDBCallbacksImpl::UpgradeNeeded(
-    int32_t database_id,
+    DatabaseAssociatedPtrInfo database,
     int64_t old_version,
     blink::WebIDBDataLoss data_loss,
     const std::string& data_loss_message,
     const content::IndexedDBDatabaseMetadata& metadata) {
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InternalState::UpgradeNeeded,
-                 base::Unretained(internal_state_), database_id, old_version,
-                 data_loss, data_loss_message, metadata));
+                 base::Unretained(internal_state_), base::Passed(&database),
+                 old_version, data_loss, data_loss_message, metadata));
 }
 
 void IndexedDBCallbacksImpl::SuccessDatabase(
-    int32_t database_id,
+    DatabaseAssociatedPtrInfo database,
     const content::IndexedDBDatabaseMetadata& metadata) {
+  callback_runner_->PostTask(FROM_HERE,
+                             base::Bind(&InternalState::SuccessDatabase,
+                                        base::Unretained(internal_state_),
+                                        base::Passed(&database), metadata));
+}
+
+void IndexedDBCallbacksImpl::SuccessCursor(int32_t cursor_id,
+                                           const IndexedDBKey& key,
+                                           const IndexedDBKey& primary_key,
+                                           indexed_db::mojom::ValuePtr value) {
+  callback_runner_->PostTask(
+      FROM_HERE, base::Bind(&InternalState::SuccessCursor,
+                            base::Unretained(internal_state_), cursor_id, key,
+                            primary_key, base::Passed(&value)));
+}
+
+void IndexedDBCallbacksImpl::SuccessValue(
+    indexed_db::mojom::ReturnValuePtr value) {
   callback_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&InternalState::SuccessDatabase,
-                 base::Unretained(internal_state_), database_id, metadata));
+      base::Bind(&InternalState::SuccessValue,
+                 base::Unretained(internal_state_), base::Passed(&value)));
+}
+
+void IndexedDBCallbacksImpl::SuccessArray(
+    std::vector<indexed_db::mojom::ReturnValuePtr> values) {
+  callback_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&InternalState::SuccessArray,
+                 base::Unretained(internal_state_), base::Passed(&values)));
+}
+
+void IndexedDBCallbacksImpl::SuccessKey(const IndexedDBKey& key) {
+  callback_runner_->PostTask(
+      FROM_HERE, base::Bind(&InternalState::SuccessKey,
+                            base::Unretained(internal_state_), key));
 }
 
 void IndexedDBCallbacksImpl::SuccessInteger(int64_t value) {
   callback_runner_->PostTask(
       FROM_HERE, base::Bind(&InternalState::SuccessInteger,
                             base::Unretained(internal_state_), value));
 }
 
+void IndexedDBCallbacksImpl::Success() {
+  callback_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&InternalState::Success, base::Unretained(internal_state_)));
+}
+
 IndexedDBCallbacksImpl::InternalState::InternalState(
     std::unique_ptr<blink::WebIDBCallbacks> callbacks,
+    int64_t transaction_id,
+    scoped_refptr<base::SingleThreadTaskRunner> io_runner,
     scoped_refptr<ThreadSafeSender> thread_safe_sender)
     : callbacks_(std::move(callbacks)),
+      transaction_id_(transaction_id),
+      io_runner_(std::move(io_runner)),
       thread_safe_sender_(std::move(thread_safe_sender)) {
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   dispatcher->RegisterMojoOwnedCallbacks(this);
 }
 
 IndexedDBCallbacksImpl::InternalState::~InternalState() {
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   dispatcher->UnregisterMojoOwnedCallbacks(this);
 }
 
 void IndexedDBCallbacksImpl::InternalState::Error(
     int32_t code,
     const base::string16& message) {
   callbacks_->onError(blink::WebIDBDatabaseError(code, message));
+  callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::SuccessStringList(
     const std::vector<base::string16>& value) {
   callbacks_->onSuccess(WebVector<WebString>(value));
+  callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::Blocked(int64_t existing_version) {
   callbacks_->onBlocked(existing_version);
+  // Not resetting |callbacks_|.
 }
 
 void IndexedDBCallbacksImpl::InternalState::UpgradeNeeded(
-    int32_t database_id,
+    DatabaseAssociatedPtrInfo database_info,
     int64_t old_version,
     blink::WebIDBDataLoss data_loss,
     const std::string& data_loss_message,
     const content::IndexedDBDatabaseMetadata& metadata) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  WebIDBDatabase* database = dispatcher->RegisterDatabase(database_id);
+  WebIDBDatabase* database = new WebIDBDatabaseImpl(
+      std::move(database_info), io_runner_, thread_safe_sender_);
   WebIDBMetadata web_metadata;
   ConvertDatabaseMetadata(metadata, &web_metadata);
   callbacks_->onUpgradeNeeded(old_version, database, web_metadata, data_loss,
                               WebString::fromUTF8(data_loss_message));
+  // Not resetting |callbacks_|.
 }
 
 void IndexedDBCallbacksImpl::InternalState::SuccessDatabase(
-    int32_t database_id,
+    DatabaseAssociatedPtrInfo database_info,
     const content::IndexedDBDatabaseMetadata& metadata) {
   WebIDBDatabase* database = nullptr;
-  if (database_id != kNoDatabase) {
-    IndexedDBDispatcher* dispatcher =
-        IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-    database = dispatcher->RegisterDatabase(database_id);
+  if (database_info.is_valid()) {
+    database = new WebIDBDatabaseImpl(std::move(database_info), io_runner_,
+                                      thread_safe_sender_);
   }
   WebIDBMetadata web_metadata;
   ConvertDatabaseMetadata(metadata, &web_metadata);
   callbacks_->onSuccess(database, web_metadata);
+  callbacks_.reset();
+}
+
+void IndexedDBCallbacksImpl::InternalState::SuccessCursor(
+    int32_t cursor_id,
+    const IndexedDBKey& key,
+    const IndexedDBKey& primary_key,
+    indexed_db::mojom::ValuePtr value) {
+  WebIDBValue web_value;
+  if (value)
+    ConvertValue(value, &web_value);
+
+  WebIDBCursorImpl* cursor = new WebIDBCursorImpl(cursor_id, transaction_id_,
+                                                  thread_safe_sender_.get());
+  IndexedDBDispatcher* dispatcher =
+      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
+  dispatcher->RegisterCursor(cursor_id, cursor);
+  callbacks_->onSuccess(cursor, WebIDBKeyBuilder::Build(key),
+                        WebIDBKeyBuilder::Build(primary_key), web_value);
+  callbacks_.reset();
+}
+
+void IndexedDBCallbacksImpl::InternalState::SuccessKey(
+    const IndexedDBKey& key) {
+  callbacks_->onSuccess(WebIDBKeyBuilder::Build(key));
+  callbacks_.reset();
+}
+
+void IndexedDBCallbacksImpl::InternalState::SuccessValue(
+    indexed_db::mojom::ReturnValuePtr value) {
+  WebIDBValue web_value;
+  if (value)
+    ConvertReturnValue(value, &web_value);
+  callbacks_->onSuccess(web_value);
+  callbacks_.reset();
+}
+
+void IndexedDBCallbacksImpl::InternalState::SuccessArray(
+    std::vector<indexed_db::mojom::ReturnValuePtr> values) {
+  blink::WebVector<WebIDBValue> web_values(values.size());
+  for (size_t i = 0; i < values.size(); ++i)
+    ConvertReturnValue(values[i], &web_values[i]);
+  callbacks_->onSuccess(web_values);
+  callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::SuccessInteger(int64_t value) {
   callbacks_->onSuccess(value);
+  callbacks_.reset();
+}
+
+void IndexedDBCallbacksImpl::InternalState::Success() {
+  callbacks_->onSuccess();
+  callbacks_.reset();
 }
 
 }  // namespace content