Port messages sent by WebIDBCursorImpl to Mojo.

content/browser/indexed_db/indexed_db_callbacks.cc

Index: content/browser/indexed_db/indexed_db_callbacks.cc
diff --git a/content/browser/indexed_db/indexed_db_callbacks.cc b/content/browser/indexed_db/indexed_db_callbacks.cc
index 1c16bd0b058ec092f055d378a8ee214a31e17458..eb62231f780031f52471b0920c2b079ea5ca8409 100644
--- a/content/browser/indexed_db/indexed_db_callbacks.cc
+++ b/content/browser/indexed_db/indexed_db_callbacks.cc
@@ -14,6 +14,7 @@
 #include "base/time/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/fileapi/fileapi_message_filter.h"
+#include "content/browser/indexed_db/cursor_impl.h"
 #include "content/browser/indexed_db/database_impl.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
@@ -38,7 +39,6 @@ using storage::ShareableFileReference;
 namespace content {
 
 namespace {
-const int32_t kNoCursor = -1;
 const int64_t kNoTransaction = -1;
 
 void ConvertBlobInfo(
@@ -77,6 +77,15 @@ void ConvertBlobInfo(
   return mojo_value;
 }
 
+// Destructively converts an IndexedDBValue to a Mojo Value.
+::indexed_db::mojom::ValuePtr ConvertValue(IndexedDBValue* value) {
+  auto mojo_value = ::indexed_db::mojom::Value::New();
+  if (!value->empty())
+    swap(mojo_value->bits, value->bits);
+  ConvertBlobInfo(value->blob_info, &mojo_value->blob_or_file_info);
+  return mojo_value;
+}
+
 }  // namespace
 
 class IndexedDBCallbacks::IOThreadHelper {
@@ -95,13 +104,23 @@ class IndexedDBCallbacks::IOThreadHelper {
                          const content::IndexedDBDatabaseMetadata& metadata);
   void SendSuccessDatabase(std::unique_ptr<DatabaseImpl> database,
                            const content::IndexedDBDatabaseMetadata& metadata);
-  void SendSuccessCursor(int32_t cursor_id,
+  void SendSuccessCursor(std::unique_ptr<CursorImpl> cursor,
                          const IndexedDBKey& key,
                          const IndexedDBKey& primary_key,
                          ::indexed_db::mojom::ValuePtr value,
                          const std::vector<IndexedDBBlobInfo>& blob_info);
   void SendSuccessValue(::indexed_db::mojom::ReturnValuePtr value,
                         const std::vector<IndexedDBBlobInfo>& blob_info);
+  void SendSuccessCursorContinue(
+      const IndexedDBKey& key,
+      const IndexedDBKey& primary_key,
+      ::indexed_db::mojom::ValuePtr value,
+      const std::vector<IndexedDBBlobInfo>& blob_info);
+  void SendSuccessCursorPrefetch(
+      const std::vector<IndexedDBKey>& keys,
+      const std::vector<IndexedDBKey>& primary_keys,
+      std::vector<::indexed_db::mojom::ValuePtr> mojo_values,
+      const std::vector<IndexedDBValue>& values);
   void SendSuccessArray(
       std::vector<::indexed_db::mojom::ReturnValuePtr> mojo_values,
       const std::vector<IndexedDBReturnValue>& values);
@@ -121,37 +140,11 @@ class IndexedDBCallbacks::IOThreadHelper {
   DISALLOW_COPY_AND_ASSIGN(IOThreadHelper);
 };
 
-IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
-                                       int32_t ipc_thread_id,
-                                       int32_t ipc_callbacks_id)
-    : dispatcher_host_(dispatcher_host),
-      ipc_callbacks_id_(ipc_callbacks_id),
-      ipc_thread_id_(ipc_thread_id),
-      ipc_cursor_id_(kNoCursor),
-      host_transaction_id_(kNoTransaction),
-      data_loss_(blink::WebIDBDataLossNone),
-      sent_blocked_(false),
-      io_helper_(nullptr) {}
-
-IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
-                                       int32_t ipc_thread_id,
-                                       int32_t ipc_callbacks_id,
-                                       int32_t ipc_cursor_id)
-    : dispatcher_host_(dispatcher_host),
-      ipc_callbacks_id_(ipc_callbacks_id),
-      ipc_thread_id_(ipc_thread_id),
-      ipc_cursor_id_(ipc_cursor_id),
-      host_transaction_id_(kNoTransaction),
-      data_loss_(blink::WebIDBDataLossNone),
-      sent_blocked_(false),
-      io_helper_(nullptr) {}
-
 IndexedDBCallbacks::IndexedDBCallbacks(
     IndexedDBDispatcherHost* dispatcher_host,
     const url::Origin& origin,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info)
     : dispatcher_host_(dispatcher_host),
-      ipc_cursor_id_(kNoCursor),
       host_transaction_id_(kNoTransaction),
       origin_(origin),
       data_loss_(blink::WebIDBDataLossNone),
@@ -170,15 +163,10 @@ void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
 
-  if (io_helper_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&IOThreadHelper::SendError,
-                   base::Unretained(io_helper_.get()), error));
-  } else {
-    dispatcher_host_->Send(new IndexedDBMsg_CallbacksError(
-        ipc_thread_id_, ipc_callbacks_id_, error.code(), error.message()));
-  }
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&IOThreadHelper::SendError, base::Unretained(io_helper_.get()),
+                 error));
   dispatcher_host_ = nullptr;
 
   if (!connection_open_start_time_.is_null()) {
@@ -193,7 +181,6 @@ void IndexedDBCallbacks::OnSuccess(const std::vector<base::string16>& value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
 
   BrowserThread::PostTask(
@@ -207,7 +194,6 @@ void IndexedDBCallbacks::OnBlocked(int64_t existing_version) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
 
   if (sent_blocked_)
     return;
@@ -237,7 +223,6 @@ void IndexedDBCallbacks::OnUpgradeNeeded(
   DCHECK(io_helper_);
 
   DCHECK_NE(kNoTransaction, host_transaction_id_);
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK(!database_sent_);
 
   data_loss_ = data_loss_info.status;
@@ -268,7 +253,6 @@ void IndexedDBCallbacks::OnSuccess(
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
 
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_NE(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(database_sent_, !connection);
 
@@ -295,105 +279,6 @@ void IndexedDBCallbacks::OnSuccess(
   }
 }
 
-static std::string CreateBlobData(
-    const IndexedDBBlobInfo& blob_info,
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
-    base::TaskRunner* task_runner) {
-  if (!blob_info.uuid().empty()) {
-    // We're sending back a live blob, not a reference into our backing store.
-    return dispatcher_host->HoldBlobData(blob_info);
-  }
-  scoped_refptr<ShareableFileReference> shareable_file =
-      ShareableFileReference::Get(blob_info.file_path());
-  if (!shareable_file.get()) {
-    shareable_file = ShareableFileReference::GetOrCreate(
-        blob_info.file_path(),
-        ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
-        task_runner);
-    if (!blob_info.release_callback().is_null())
-      shareable_file->AddFinalReleaseCallback(blob_info.release_callback());
-  }
-  return dispatcher_host->HoldBlobData(blob_info);
-}
-
-static bool CreateAllBlobs(
-    const std::vector<IndexedDBBlobInfo>& blob_info,
-    std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info,
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host) {
-  IDB_TRACE("IndexedDBCallbacks::CreateAllBlobs");
-  DCHECK_EQ(blob_info.size(), blob_or_file_info->size());
-  size_t i;
-  if (!dispatcher_host->blob_storage_context())
-    return false;
-  for (i = 0; i < blob_info.size(); ++i) {
-    (*blob_or_file_info)[i].uuid =
-        CreateBlobData(blob_info[i], dispatcher_host,
-                       dispatcher_host->context()->TaskRunner());
-  }
-  return true;
-}
-
-template <class ParamType, class MsgType>
-static void CreateBlobsAndSend(
-    ParamType* params,
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
-    const std::vector<IndexedDBBlobInfo>& blob_info,
-    std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host))
-    dispatcher_host->Send(new MsgType(*params));
-}
-
-static void BlobLookupForCursorPrefetch(
-    IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params* params,
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
-    const std::vector<IndexedDBValue>& values) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(values.size(), params->values.size());
-
-  for (size_t i = 0; i < values.size(); ++i) {
-    if (!CreateAllBlobs(values[i].blob_info,
-                        &params->values[i].blob_or_file_info, dispatcher_host))
-      return;
-  }
-
-  dispatcher_host->Send(
-      new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params));
-}
-
-static void FillInBlobData(
-    const std::vector<IndexedDBBlobInfo>& blob_info,
-    std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) {
-  for (const auto& iter : blob_info) {
-    if (iter.is_file()) {
-      IndexedDBMsg_BlobOrFileInfo info;
-      info.is_file = true;
-      info.mime_type = iter.type();
-      info.file_name = iter.file_name();
-      info.file_path = iter.file_path().AsUTF16Unsafe();
-      info.size = iter.size();
-      info.last_modified = iter.last_modified().ToDoubleT();
-      blob_or_file_info->push_back(info);
-    } else {
-      IndexedDBMsg_BlobOrFileInfo info;
-      info.mime_type = iter.type();
-      info.size = iter.size();
-      blob_or_file_info->push_back(info);
-    }
-  }
-}
-
-void IndexedDBCallbacks::RegisterBlobsAndSend(
-    const std::vector<IndexedDBBlobInfo>& blob_info,
-    const base::Closure& callback) {
-  for (const auto& iter : blob_info) {
-    if (!iter.mark_used_callback().is_null())
-      iter.mark_used_callback().Run();
-  }
-  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback);
-}
-
 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
                                    const IndexedDBKey& key,
                                    const IndexedDBKey& primary_key,
@@ -402,10 +287,12 @@ void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
 
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
+  std::unique_ptr<CursorImpl> cursor_impl(
+      new CursorImpl(cursor, origin_, dispatcher_host_));
+
   ::indexed_db::mojom::ValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
@@ -419,9 +306,9 @@ void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&IOThreadHelper::SendSuccessCursor,
-                 base::Unretained(io_helper_.get()),
-                 dispatcher_host_->Add(cursor.get()), key, primary_key,
-                 base::Passed(&mojo_value), base::Passed(&blob_info)));
+                 base::Unretained(io_helper_.get()), base::Passed(&cursor_impl),
+                 key, primary_key, base::Passed(&mojo_value),
+                 base::Passed(&blob_info)));
   dispatcher_host_ = nullptr;
 }
 
@@ -430,45 +317,26 @@ void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key,
                                    IndexedDBValue* value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
-  DCHECK(!io_helper_);
+  DCHECK(io_helper_);
 
-  DCHECK_NE(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
-  IndexedDBCursor* idb_cursor =
-      dispatcher_host_->GetCursorFromId(ipc_cursor_id_);
-
-  DCHECK(idb_cursor);
-  if (!idb_cursor)
-    return;
-
-  std::unique_ptr<IndexedDBMsg_CallbacksSuccessCursorContinue_Params> params(
-      new IndexedDBMsg_CallbacksSuccessCursorContinue_Params());
-  params->ipc_thread_id = ipc_thread_id_;
-  params->ipc_callbacks_id = ipc_callbacks_id_;
-  params->ipc_cursor_id = ipc_cursor_id_;
-  params->key = key;
-  params->primary_key = primary_key;
-  if (value && !value->empty())
-    swap(params->value.bits, value->bits);
-  // TODO(alecflett): Avoid a copy here: the whole params object is
-  // being copied into the message.
-  if (!value || value->blob_info.empty()) {
-    dispatcher_host_->Send(
-        new IndexedDBMsg_CallbacksSuccessCursorContinue(*params));
-  } else {
-    IndexedDBMsg_CallbacksSuccessCursorContinue_Params* p = params.get();
-    FillInBlobData(value->blob_info, &p->value.blob_or_file_info);
-    RegisterBlobsAndSend(
-        value->blob_info,
-        base::Bind(CreateBlobsAndSend<
-                       IndexedDBMsg_CallbacksSuccessCursorContinue_Params,
-                       IndexedDBMsg_CallbacksSuccessCursorContinue>,
-                   base::Owned(params.release()), dispatcher_host_,
-                   value->blob_info,
-                   base::Unretained(&p->value.blob_or_file_info)));
+  ::indexed_db::mojom::ValuePtr mojo_value;
+  std::vector<IndexedDBBlobInfo> blob_info;
+  if (value) {
+    mojo_value = ::indexed_db::mojom::Value::New();
+    if (!value->empty())
+      std::swap(mojo_value->bits, value->bits);

[dcheng, 2016/11/17 03:46:23]

No std:: to get ADL

[Reilly Grant (use Gerrit), 2016/11/17 20:04:52]

Done.

+    ConvertBlobInfo(value->blob_info, &mojo_value->blob_or_file_info);
+    blob_info = value->blob_info;
   }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&IOThreadHelper::SendSuccessCursorContinue,
+                 base::Unretained(io_helper_.get()), key, primary_key,
+                 base::Passed(&mojo_value), base::Passed(&blob_info)));
   dispatcher_host_ = nullptr;
 }
 
@@ -478,56 +346,23 @@ void IndexedDBCallbacks::OnSuccessWithPrefetch(
     std::vector<IndexedDBValue>* values) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
-  DCHECK(!io_helper_);
+  DCHECK(io_helper_);
   DCHECK_EQ(keys.size(), primary_keys.size());
   DCHECK_EQ(keys.size(), values->size());
 
-  DCHECK_NE(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
-  std::vector<IndexedDBKey> msg_keys;
-  std::vector<IndexedDBKey> msg_primary_keys;
-
-  for (size_t i = 0; i < keys.size(); ++i) {
-    msg_keys.push_back(keys[i]);
-    msg_primary_keys.push_back(primary_keys[i]);
-  }
-
-  std::unique_ptr<IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params> params(
-      new IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params());
-  params->ipc_thread_id = ipc_thread_id_;
-  params->ipc_callbacks_id = ipc_callbacks_id_;
-  params->ipc_cursor_id = ipc_cursor_id_;
-  params->keys = msg_keys;
-  params->primary_keys = msg_primary_keys;
-  params->values.resize(values->size());
-
-  bool found_blob_info = false;
-  for (size_t i = 0; i < values->size(); ++i) {
-    params->values[i].bits.swap(values->at(i).bits);
-    if (!values->at(i).blob_info.empty()) {
-      found_blob_info = true;
-      FillInBlobData(values->at(i).blob_info,
-                     &params->values[i].blob_or_file_info);
-      for (const auto& blob_iter : values->at(i).blob_info) {
-        if (!blob_iter.mark_used_callback().is_null())
-          blob_iter.mark_used_callback().Run();
-      }
-    }
-  }
+  std::vector<::indexed_db::mojom::ValuePtr> mojo_values;
+  mojo_values.reserve(values->size());
+  for (size_t i = 0; i < values->size(); ++i)
+    mojo_values.push_back(ConvertValue(&(*values)[i]));
 
-  if (found_blob_info) {
-    BrowserThread::PostTask(BrowserThread::IO,
-                            FROM_HERE,
-                            base::Bind(BlobLookupForCursorPrefetch,
-                                       base::Owned(params.release()),
-                                       dispatcher_host_,
-                                       *values));
-  } else {
-    dispatcher_host_->Send(
-        new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params.get()));
-  }
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&IOThreadHelper::SendSuccessCursorPrefetch,
+                 base::Unretained(io_helper_.get()), keys, primary_keys,
+                 base::Passed(&mojo_values), *values));
   dispatcher_host_ = nullptr;
 }
 
@@ -535,52 +370,21 @@ void IndexedDBCallbacks::OnSuccess(IndexedDBReturnValue* value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
 
-  if (value && value->primary_key.IsValid()) {
-    DCHECK_EQ(kNoCursor, ipc_cursor_id_);
-  } else {
-    DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL);
-  }
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
-  if (io_helper_) {
-    DCHECK_EQ(kNoCursor, ipc_cursor_id_);
-
-    ::indexed_db::mojom::ReturnValuePtr mojo_value;
-    std::vector<IndexedDBBlobInfo> blob_info;
-    if (value) {
-      mojo_value = ConvertReturnValue(value);
-      blob_info = value->blob_info;
-    }
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&IOThreadHelper::SendSuccessValue,
-                   base::Unretained(io_helper_.get()),
-                   base::Passed(&mojo_value), base::Passed(&blob_info)));
-  } else {
-    auto params = base::MakeUnique<IndexedDBMsg_CallbacksSuccessValue_Params>();
-    params->ipc_thread_id = ipc_thread_id_;
-    params->ipc_callbacks_id = ipc_callbacks_id_;
-    if (value && value->primary_key.IsValid()) {
-      params->value.primary_key = value->primary_key;
-      params->value.key_path = value->key_path;
-    }
-    if (value && !value->empty())
-      swap(params->value.bits, value->bits);
-    if (!value || value->blob_info.empty()) {
-      dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(*params));
-    } else {
-      IndexedDBMsg_CallbacksSuccessValue_Params* p = params.get();
-      FillInBlobData(value->blob_info, &p->value.blob_or_file_info);
-      RegisterBlobsAndSend(
-          value->blob_info,
-          base::Bind(
-              CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValue_Params,
-                                 IndexedDBMsg_CallbacksSuccessValue>,
-              base::Owned(params.release()), dispatcher_host_, value->blob_info,
-              base::Unretained(&p->value.blob_or_file_info)));
-    }
+  ::indexed_db::mojom::ReturnValuePtr mojo_value;
+  std::vector<IndexedDBBlobInfo> blob_info;
+  if (value) {
+    mojo_value = ConvertReturnValue(value);
+    blob_info = value->blob_info;
   }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&IOThreadHelper::SendSuccessValue,
+                 base::Unretained(io_helper_.get()), base::Passed(&mojo_value),
+                 base::Passed(&blob_info)));
   dispatcher_host_ = nullptr;
 }
 
@@ -592,7 +396,6 @@ void IndexedDBCallbacks::OnSuccessArray(
 
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
 
   std::vector<::indexed_db::mojom::ReturnValuePtr> mojo_values;
   mojo_values.reserve(values->size());
@@ -611,7 +414,6 @@ void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) {
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
 
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
@@ -625,19 +427,11 @@ void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) {
 void IndexedDBCallbacks::OnSuccess(int64_t value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
-  if (io_helper_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&IOThreadHelper::SendSuccessInteger,
-                   base::Unretained(io_helper_.get()), value));
-  } else {
-    DCHECK_EQ(kNoCursor, ipc_cursor_id_);
-    DCHECK_EQ(kNoTransaction, host_transaction_id_);
-    DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
-
-    dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessInteger(
-        ipc_thread_id_, ipc_callbacks_id_, value));
-  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&IOThreadHelper::SendSuccessInteger,
+                 base::Unretained(io_helper_.get()), value));
   dispatcher_host_ = nullptr;
 }
 
@@ -646,7 +440,6 @@ void IndexedDBCallbacks::OnSuccess() {
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
 
-  DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
@@ -720,13 +513,21 @@ void IndexedDBCallbacks::IOThreadHelper::SendSuccessDatabase(
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessCursor(
-    int32_t cursor_id,
+    std::unique_ptr<CursorImpl> cursor,
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key,
     ::indexed_db::mojom::ValuePtr value,
     const std::vector<IndexedDBBlobInfo>& blob_info) {
-  if (!value || CreateAllBlobs(blob_info, &value->blob_or_file_info))
-    callbacks_->SuccessCursor(cursor_id, key, primary_key, std::move(value));
+  if (value && !CreateAllBlobs(blob_info, &value->blob_or_file_info))
+    return;
+
+  ::indexed_db::mojom::CursorAssociatedPtrInfo ptr_info;
+  ::indexed_db::mojom::CursorAssociatedRequest request;
+  callbacks_.associated_group()->CreateAssociatedInterface(
+      mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
+  mojo::MakeStrongAssociatedBinding(std::move(cursor), std::move(request));
+  callbacks_->SuccessCursor(std::move(ptr_info), key, primary_key,
+                            std::move(value));
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessValue(
@@ -749,6 +550,32 @@ void IndexedDBCallbacks::IOThreadHelper::SendSuccessArray(
   callbacks_->SuccessArray(std::move(mojo_values));
 }
 
+void IndexedDBCallbacks::IOThreadHelper::SendSuccessCursorContinue(
+    const IndexedDBKey& key,
+    const IndexedDBKey& primary_key,
+    ::indexed_db::mojom::ValuePtr value,
+    const std::vector<IndexedDBBlobInfo>& blob_info) {
+  if (!value || CreateAllBlobs(blob_info, &value->blob_or_file_info))
+    callbacks_->SuccessCursorContinue(key, primary_key, std::move(value));
+}
+
+void IndexedDBCallbacks::IOThreadHelper::SendSuccessCursorPrefetch(
+    const std::vector<IndexedDBKey>& keys,
+    const std::vector<IndexedDBKey>& primary_keys,
+    std::vector<::indexed_db::mojom::ValuePtr> mojo_values,
+    const std::vector<IndexedDBValue>& values) {
+  DCHECK_EQ(mojo_values.size(), values.size());
+
+  for (size_t i = 0; i < mojo_values.size(); ++i) {
+    if (!CreateAllBlobs(values[i].blob_info,
+                        &mojo_values[i]->blob_or_file_info)) {
+      return;
+    }
+  }
+
+  callbacks_->SuccessCursorPrefetch(keys, primary_keys, std::move(mojo_values));
+}
+
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessKey(
     const IndexedDBKey& value) {
   callbacks_->SuccessKey(value);