Port messages sent by WebIDBCursorImpl to Mojo.

content/child/indexed_db/webidbdatabase_impl.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/child/indexed_db/webidbdatabase_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/stl_util.h"
 #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/thread_safe_sender.h"
 #include "content/child/worker_thread_registry.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
 #include "third_party/WebKit/public/platform/WebBlobInfo.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBKeyPath.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h"
@@ skipping 130 matching lines @@
   CallbacksAssociatedPtrInfo GetCallbacksProxy(
       std::unique_ptr<IndexedDBCallbacksImpl> callbacks);
 
   indexed_db::mojom::DatabaseAssociatedPtr database_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadHelper);
 };
 
 WebIDBDatabaseImpl::WebIDBDatabaseImpl(
     DatabaseAssociatedPtrInfo database_info,
-    scoped_refptr<base::SingleThreadTaskRunner> io_runner,
-    scoped_refptr<ThreadSafeSender> thread_safe_sender)
-    : helper_(new IOThreadHelper()),
-      io_runner_(std::move(io_runner)),
-      thread_safe_sender_(std::move(thread_safe_sender)) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_runner)
+    : helper_(new IOThreadHelper()), io_runner_(std::move(io_runner)) {
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Bind, base::Unretained(helper_),
                             base::Passed(&database_info)));
 }
 
 WebIDBDatabaseImpl::~WebIDBDatabaseImpl() {
   io_runner_->DeleteSoon(FROM_HERE, helper_);
 }
 
 void WebIDBDatabaseImpl::createObjectStore(long long transaction_id,
@@ skipping 30 matching lines @@
     blink::WebIDBTransactionMode mode) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::CreateTransaction, base::Unretained(helper_),
                  transaction_id, std::vector<int64_t>(object_store_ids.begin(),
                                                       object_store_ids.end()),
                  mode));
 }
 
 void WebIDBDatabaseImpl::close() {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   std::vector<int32_t> remove_observer_ids(observer_ids_.begin(),
                                            observer_ids_.end());
-  dispatcher->RemoveObservers(remove_observer_ids);
+  IndexedDBDispatcher::ThreadSpecificInstance()->RemoveObservers(
+      remove_observer_ids);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Close, base::Unretained(helper_)));
 }
 
 void WebIDBDatabaseImpl::versionChangeIgnored() {
   io_runner_->PostTask(FROM_HERE,
                        base::Bind(&IOThreadHelper::VersionChangeIgnored,
                                   base::Unretained(helper_)));
 }
 
 int32_t WebIDBDatabaseImpl::addObserver(
     std::unique_ptr<WebIDBObserver> observer,
     long long transaction_id) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   WebIDBObserver* observer_ptr = observer.get();
-  int32_t observer_id = dispatcher->RegisterObserver(std::move(observer));
+  int32_t observer_id =
+      IndexedDBDispatcher::ThreadSpecificInstance()->RegisterObserver(
+          std::move(observer));
   observer_ids_.insert(observer_id);
   static_assert(blink::WebIDBOperationTypeCount < sizeof(uint16_t) * CHAR_BIT,
                 "WebIDBOperationType Count exceeds size of uint16_t");
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::AddObserver, base::Unretained(helper_),
                  transaction_id, observer_id, observer_ptr->transaction(),
                  observer_ptr->noRecords(), observer_ptr->values(),
                  observer_ptr->operationTypes().to_ulong()));
   return observer_id;
 }
 
 void WebIDBDatabaseImpl::removeObservers(
     const WebVector<int32_t>& observer_ids_to_remove) {
   std::vector<int32_t> remove_observer_ids(
       observer_ids_to_remove.data(),
       observer_ids_to_remove.data() + observer_ids_to_remove.size());
   for (int32_t id : observer_ids_to_remove)
     observer_ids_.erase(id);
 
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->RemoveObservers(remove_observer_ids);
+  IndexedDBDispatcher::ThreadSpecificInstance()->RemoveObservers(
+      remove_observer_ids);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::RemoveObservers,
                             base::Unretained(helper_), remove_observer_ids));
 }
 
 void WebIDBDatabaseImpl::get(long long transaction_id,
                              long long object_store_id,
                              long long index_id,
                              const WebIDBKeyRange& key_range,
                              bool key_only,
                              WebIDBCallbacks* callbacks) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Get, base::Unretained(helper_),
                             transaction_id, object_store_id, index_id,
                             IndexedDBKeyRangeBuilder::Build(key_range),
                             key_only, base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::getAll(long long transaction_id,
                                 long long object_store_id,
                                 long long index_id,
                                 const WebIDBKeyRange& key_range,
                                 long long max_count,
                                 bool key_only,
                                 WebIDBCallbacks* callbacks) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::GetAll, base::Unretained(helper_),
                  transaction_id, object_store_id, index_id,
                  IndexedDBKeyRangeBuilder::Build(key_range), max_count,
                  key_only, base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::put(long long transaction_id,
                              long long object_store_id,
                              const blink::WebData& value,
                              const blink::WebVector<WebBlobInfo>& web_blob_info,
                              const WebIDBKey& web_key,
                              blink::WebIDBPutMode put_mode,
                              WebIDBCallbacks* callbacks,
                              const WebVector<long long>& index_ids,
                              const WebVector<WebIndexKeys>& index_keys) {
   IndexedDBKey key = IndexedDBKeyBuilder::Build(web_key);
 
   if (value.size() + key.size_estimate() > max_put_value_size_) {
     callbacks->onError(blink::WebIDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         WebString::fromUTF8(base::StringPrintf(
             "The serialized value is too large"
             " (size=%" PRIuS " bytes, max=%" PRIuS " bytes).",
             value.size(), max_put_value_size_))));
     return;
   }
 
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto mojo_value = indexed_db::mojom::Value::New();
   mojo_value->bits.assign(value.data(), value.data() + value.size());
   mojo_value->blob_or_file_info.reserve(web_blob_info.size());
   for (const WebBlobInfo& info : web_blob_info) {
     auto blob_info = indexed_db::mojom::BlobInfo::New();
     if (info.isFile()) {
       blob_info->file = indexed_db::mojom::FileInfo::New();
       blob_info->file->path =
           base::FilePath::FromUTF8Unsafe(info.filePath().utf8());
       blob_info->file->name = info.fileName();
       blob_info->file->last_modified =
           base::Time::FromDoubleT(info.lastModified());
     }
     blob_info->size = info.size();
     blob_info->uuid = info.uuid().latin1();
     DCHECK(blob_info->uuid.size());
     blob_info->mime_type = info.type();
     mojo_value->blob_or_file_info.push_back(std::move(blob_info));
   }
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::Put, base::Unretained(helper_),
                  transaction_id, object_store_id, base::Passed(&mojo_value),
                  key, put_mode, base::Passed(&callbacks_impl),
                  ConvertWebIndexKeys(index_ids, index_keys)));
 }
 
 void WebIDBDatabaseImpl::setIndexKeys(
     long long transaction_id,
@@ skipping 22 matching lines @@
 }
 
 void WebIDBDatabaseImpl::openCursor(long long transaction_id,
                                     long long object_store_id,
                                     long long index_id,
                                     const WebIDBKeyRange& key_range,
                                     blink::WebIDBCursorDirection direction,
                                     bool key_only,
                                     blink::WebIDBTaskType task_type,
                                     WebIDBCallbacks* callbacks) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::OpenCursor, base::Unretained(helper_),
                  transaction_id, object_store_id, index_id,
                  IndexedDBKeyRangeBuilder::Build(key_range), direction,
                  key_only, task_type, base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::count(long long transaction_id,
                                long long object_store_id,
                                long long index_id,
                                const WebIDBKeyRange& key_range,
                                WebIDBCallbacks* callbacks) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Count, base::Unretained(helper_),
                             transaction_id, object_store_id, index_id,
                             IndexedDBKeyRangeBuilder::Build(key_range),
                             base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::deleteRange(long long transaction_id,
                                      long long object_store_id,
                                      const WebIDBKeyRange& key_range,
                                      WebIDBCallbacks* callbacks) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::DeleteRange, base::Unretained(helper_),
                  transaction_id, object_store_id,
                  IndexedDBKeyRangeBuilder::Build(key_range),
                  base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::clear(long long transaction_id,
                                long long object_store_id,
                                WebIDBCallbacks* callbacks) {
-  IndexedDBDispatcher* dispatcher =
-      IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
-  dispatcher->ResetCursorPrefetchCaches(transaction_id,
-                                        IndexedDBDispatcher::kAllCursors);
+  IndexedDBDispatcher::ThreadSpecificInstance()->ResetCursorPrefetchCaches(
+      transaction_id, nullptr);
 
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
-      base::WrapUnique(callbacks), transaction_id, io_runner_,
-      thread_safe_sender_);
+      base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Clear, base::Unretained(helper_),
                             transaction_id, object_store_id,
                             base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::createIndex(long long transaction_id,
                                      long long object_store_id,
                                      long long index_id,
                                      const WebString& name,
@@ skipping 248 matching lines @@
     std::unique_ptr<IndexedDBCallbacksImpl> callbacks) {
   CallbacksAssociatedPtrInfo ptr_info;
   indexed_db::mojom::CallbacksAssociatedRequest request;
   database_.associated_group()->CreateAssociatedInterface(
       mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
   mojo::MakeStrongAssociatedBinding(std::move(callbacks), std::move(request));
   return ptr_info;
 }
 
 }  // namespace content