Migrate references of blink::mojom::IDBCursor to new Mojo types

Convert both the implementation and clients in the browser and renderer
processes for the blink.mojom.IDBCursor interface, and
adapt unit tests.

Bug: 955171, 978694
Change-Id: I80027402a0bce5dcf568cbbcb4229385cd9d6ea0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1768471
Commit-Queue: Mario Sanchez Prada <mario@igalia.com>
Reviewed-by: Chase Phillips <cmp@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Cr-Commit-Position: refs/heads/master@{#692014}

content/browser/indexed_db/database_impl.cc

@@ -94,7 +94,7 @@ void DatabaseImpl::RenameObjectStore(int64_t transaction_id,
 
 void DatabaseImpl::CreateTransaction(
     mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-        pending_receiver,
+        transaction_receiver,
     int64_t transaction_id,
     const std::vector<int64_t>& object_store_ids,
     blink::mojom::IDBTransactionMode mode) {
@@ -121,7 +121,7 @@ void DatabaseImpl::CreateTransaction(
   connection_->database()->RegisterAndScheduleTransaction(transaction);
 
   dispatcher_host_->CreateAndBindTransactionImpl(
-      std::move(pending_receiver), origin_, transaction->AsWeakPtr());
+      std::move(transaction_receiver), origin_, transaction->AsWeakPtr());
 }
 
 void DatabaseImpl::Close() {

content/browser/indexed_db/database_impl.h

@@ -44,7 +44,7 @@ class DatabaseImpl : public blink::mojom::IDBDatabase {
                          int64_t object_store_id,
                          const base::string16& new_name) override;
   void CreateTransaction(mojo::PendingAssociatedReceiver<
-                             blink::mojom::IDBTransaction> pending_receiver,
+                             blink::mojom::IDBTransaction> transaction_receiver,
                          int64_t transaction_id,
                          const std::vector<int64_t>& object_store_ids,
                          blink::mojom::IDBTransactionMode mode) override;

content/browser/indexed_db/indexed_db_dispatcher_host.cc

@@ -94,7 +94,7 @@ void IndexedDBDispatcherHost::AddDatabaseBinding(
   database_bindings_.AddBinding(std::move(database), std::move(request));
 }
 
-blink::mojom::IDBCursorAssociatedPtrInfo
+mojo::PendingAssociatedRemote<blink::mojom::IDBCursor>
 IndexedDBDispatcherHost::CreateCursorBinding(
     const url::Origin& origin,
     std::unique_ptr<IndexedDBCursor> cursor) {
@@ -102,26 +102,26 @@ IndexedDBDispatcherHost::CreateCursorBinding(
   auto cursor_impl = std::make_unique<CursorImpl>(std::move(cursor), origin,
                                                   this, IDBTaskRunner());
   auto* cursor_impl_ptr = cursor_impl.get();
-  blink::mojom::IDBCursorAssociatedPtrInfo ptr_info;
-  mojo::BindingId binding_id = cursor_bindings_.AddBinding(
-      std::move(cursor_impl), mojo::MakeRequest(&ptr_info));
+  mojo::PendingAssociatedRemote<blink::mojom::IDBCursor> pending_remote;
+  mojo::ReceiverId receiver_id = cursor_receivers_.Add(
+      std::move(cursor_impl),
+      pending_remote.InitWithNewEndpointAndPassReceiver());
   cursor_impl_ptr->OnRemoveBinding(
       base::BindOnce(&IndexedDBDispatcherHost::RemoveCursorBinding,
-                     weak_factory_.GetWeakPtr(), binding_id));
-  return ptr_info;
+                     weak_factory_.GetWeakPtr(), receiver_id));
+  return pending_remote;
 }
 
-void IndexedDBDispatcherHost::RemoveCursorBinding(mojo::BindingId binding_id) {
-  cursor_bindings_.RemoveBinding(binding_id);
+void IndexedDBDispatcherHost::RemoveCursorBinding(
+    mojo::ReceiverId receiver_id) {
+  cursor_receivers_.Remove(receiver_id);
 }
 
 void IndexedDBDispatcherHost::AddTransactionBinding(
     std::unique_ptr<blink::mojom::IDBTransaction> transaction,
-    mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-        pending_receiver) {
+    mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction> receiver) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  transaction_receivers_.Add(std::move(transaction),
-                             std::move(pending_receiver));
+  transaction_receivers_.Add(std::move(transaction), std::move(receiver));
 }
 
 void IndexedDBDispatcherHost::RenderProcessExited(
@@ -170,7 +170,7 @@ void IndexedDBDispatcherHost::Open(
     const base::string16& name,
     int64_t version,
     mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-        transaction_pending_receiver,
+        transaction_receiver,
     int64_t transaction_id) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
@@ -186,7 +186,7 @@ void IndexedDBDispatcherHost::Open(
 
   auto create_transaction_callback = base::BindOnce(
       &IndexedDBDispatcherHost::CreateAndBindTransactionImpl, AsWeakPtr(),
-      std::move(transaction_pending_receiver), context.origin);
+      std::move(transaction_receiver), context.origin);
   std::unique_ptr<IndexedDBPendingConnection> connection =
       std::make_unique<IndexedDBPendingConnection>(
           std::move(callbacks), std::move(database_callbacks), ipc_process_id_,
@@ -236,20 +236,20 @@ void IndexedDBDispatcherHost::AbortTransactionsForDatabase(
 
 void IndexedDBDispatcherHost::CreateAndBindTransactionImpl(
     mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-        transaction_pending_receiver,
+        transaction_receiver,
     const url::Origin& origin,
     base::WeakPtr<IndexedDBTransaction> transaction) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto transaction_impl = std::make_unique<TransactionImpl>(
       transaction, origin, this->AsWeakPtr(), IDBTaskRunner());
   AddTransactionBinding(std::move(transaction_impl),
-                        std::move(transaction_pending_receiver));
+                        std::move(transaction_receiver));
 }
 
 void IndexedDBDispatcherHost::InvalidateWeakPtrsAndClearBindings() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   weak_factory_.InvalidateWeakPtrs();
-  cursor_bindings_.CloseAllBindings();
+  cursor_receivers_.Clear();
   database_bindings_.CloseAllBindings();
   transaction_receivers_.Clear();
 }

content/browser/indexed_db/indexed_db_dispatcher_host.h

@@ -22,6 +22,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding_set.h"
 #include "mojo/public/cpp/bindings/unique_associated_receiver_set.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
@@ -57,15 +58,14 @@ class CONTENT_EXPORT IndexedDBDispatcherHost
   void AddDatabaseBinding(std::unique_ptr<blink::mojom::IDBDatabase> database,
                           blink::mojom::IDBDatabaseAssociatedRequest request);
 
-  blink::mojom::IDBCursorAssociatedPtrInfo CreateCursorBinding(
+  mojo::PendingAssociatedRemote<blink::mojom::IDBCursor> CreateCursorBinding(
       const url::Origin& origin,
       std::unique_ptr<IndexedDBCursor> cursor);
-  void RemoveCursorBinding(mojo::BindingId binding_id);
+  void RemoveCursorBinding(mojo::ReceiverId receiver_id);
 
   void AddTransactionBinding(
       std::unique_ptr<blink::mojom::IDBTransaction> transaction,
-      mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-          pending_receiver);
+      mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction> receiver);
 
   // A shortcut for accessing our context.
   IndexedDBContextImpl* context() const { return indexed_db_context_.get(); }
@@ -81,7 +81,7 @@ class CONTENT_EXPORT IndexedDBDispatcherHost
 
   void CreateAndBindTransactionImpl(
       mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-          transaction_pending_receiver,
+          transaction_receiver,
       const url::Origin& origin,
       base::WeakPtr<IndexedDBTransaction> transaction);
 
@@ -110,7 +110,7 @@ class CONTENT_EXPORT IndexedDBDispatcherHost
             const base::string16& name,
             int64_t version,
             mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
-                transaction_pending_receiver,
+                transaction_receiver,
             int64_t transaction_id) override;
   void DeleteDatabase(
       blink::mojom::IDBCallbacksAssociatedPtrInfo callbacks_info,
@@ -139,7 +139,7 @@ class CONTENT_EXPORT IndexedDBDispatcherHost
   mojo::BindingSet<blink::mojom::IDBFactory, BindingState> bindings_;
   mojo::StrongAssociatedBindingSet<blink::mojom::IDBDatabase>
       database_bindings_;
-  mojo::StrongAssociatedBindingSet<blink::mojom::IDBCursor> cursor_bindings_;
+  mojo::UniqueAssociatedReceiverSet<blink::mojom::IDBCursor> cursor_receivers_;
   mojo::UniqueAssociatedReceiverSet<blink::mojom::IDBTransaction>
       transaction_receivers_;
 

third_party/blink/public/mojom/indexeddb/indexeddb.mojom

@@ -321,7 +321,7 @@ union IDBDatabaseGetAllResult {
 };
 
 struct IDBDatabaseOpenCursorValue {
-  associated IDBCursor cursor;
+  pending_associated_remote<IDBCursor> pending_cursor;
   IDBKey key;
   IDBKey primary_key;
   IDBValue? value;

third_party/blink/renderer/modules/indexeddb/idb_factory.cc

@@ -32,6 +32,7 @@
 #include <utility>
 
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/public/platform/interface_provider.h"
@@ -134,7 +135,7 @@ class WebIDBGetDBNamesCallbacksImpl : public WebIDBCallbacks {
   void SuccessStringList(const Vector<String>&) override { NOTREACHED(); }
 
   void SuccessCursor(
-      mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
       std::unique_ptr<IDBKey> key,
       std::unique_ptr<IDBKey> primary_key,
       base::Optional<std::unique_ptr<IDBValue>> optional_value) override {

third_party/blink/renderer/modules/indexeddb/idb_request_test.cc

@@ -83,12 +83,11 @@ class BackendDatabaseWithMockedClose
   void RenameObjectStore(int64_t transaction_id,
                          int64_t object_store_id,
                          const WTF::String& new_name) override {}
-  void CreateTransaction(
-      mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-          transaction_pending_receiver,
-      int64_t transaction_id,
-      const WTF::Vector<int64_t>& object_store_ids,
-      mojom::blink::IDBTransactionMode mode) override {}
+  void CreateTransaction(mojo::PendingAssociatedReceiver<
+                             mojom::blink::IDBTransaction> transaction_receiver,
+                         int64_t transaction_id,
+                         const WTF::Vector<int64_t>& object_store_ids,
+                         mojom::blink::IDBTransactionMode mode) override {}
   MOCK_METHOD0(Close, void());
   void VersionChangeIgnored() override {}
   void AddObserver(int64_t transaction_id,

third_party/blink/renderer/modules/indexeddb/mock_web_idb_callbacks.cc

@@ -24,11 +24,11 @@ void MockWebIDBCallbacks::SuccessCursorContinue(
 }
 
 void MockWebIDBCallbacks::SuccessCursor(
-    mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
     std::unique_ptr<IDBKey> key,
     std::unique_ptr<IDBKey> primary_key,
     base::Optional<std::unique_ptr<IDBValue>> optional_value) {
-  DoSuccessCursor(cursor_info, key, primary_key, optional_value);
+  DoSuccessCursor(pending_cursor, key, primary_key, optional_value);
 }
 
 void MockWebIDBCallbacks::SuccessKey(std::unique_ptr<IDBKey> key) {

third_party/blink/renderer/modules/indexeddb/mock_web_idb_callbacks.h

@@ -7,6 +7,7 @@
 
 #include "base/macros.h"
 #include "base/optional.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/public/platform/web_blob_info.h"
@@ -42,13 +43,14 @@ class MockWebIDBCallbacks : public WebIDBCallbacks {
   MOCK_METHOD1(SuccessStringList, void(const Vector<String>&));
 
   void SuccessCursor(
-      mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
       std::unique_ptr<IDBKey> key,
       std::unique_ptr<IDBKey> primary_key,
       base::Optional<std::unique_ptr<IDBValue>> optional_value) override;
   MOCK_METHOD4(
       DoSuccessCursor,
-      void(const mojom::blink::IDBCursorAssociatedPtrInfo& cursor_info,
+      void(const mojo::PendingAssociatedRemote<mojom::blink::IDBCursor>&
+               pending_cursor,
            const std::unique_ptr<IDBKey>& key,
            const std::unique_ptr<IDBKey>& primary_key,
            const base::Optional<std::unique_ptr<IDBValue>>& optional_value));

third_party/blink/renderer/modules/indexeddb/mock_web_idb_database.h

@@ -25,7 +25,7 @@ class MockWebIDBDatabase : public testing::StrictMock<WebIDBDatabase> {
                     const String& new_name));
   MOCK_METHOD4(CreateTransaction,
                void(mojo::PendingAssociatedReceiver<
-                        mojom::blink::IDBTransaction> pending_receiver,
+                        mojom::blink::IDBTransaction> receiver,
                     int64_t id,
                     const Vector<int64_t>& scope,
                     mojom::IDBTransactionMode));

third_party/blink/renderer/modules/indexeddb/mock_web_idb_factory.h

@@ -32,7 +32,7 @@ class MockWebIDBFactory : public testing::StrictMock<blink::WebIDBFactory> {
       void(const WTF::String& name,
            int64_t version,
            mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-               transaction_pending_receiver,
+               transaction_receiver,
            int64_t transaction_id,
            std::unique_ptr<WebIDBCallbacks>,
            std::unique_ptr<WebIDBDatabaseCallbacks>));

third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h

@@ -29,6 +29,7 @@
 #include <memory>
 
 #include "base/memory/weak_ptr.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 
@@ -46,7 +47,7 @@ class WebIDBCallbacks : public mojom::blink::IDBCallbacks {
   virtual void SetState(base::WeakPtr<WebIDBCursorImpl> cursor,
                         int64_t transaction_id) = 0;
   virtual void SuccessCursor(
-      mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
       std::unique_ptr<IDBKey> key,
       std::unique_ptr<IDBKey> primary_key,
       base::Optional<std::unique_ptr<IDBValue>> optional_value) = 0;

third_party/blink/renderer/modules/indexeddb/web_idb_callbacks_impl.cc

@@ -146,7 +146,7 @@ void WebIDBCallbacksImpl::SuccessStringList(const Vector<String>& string_list) {
 }
 
 void WebIDBCallbacksImpl::SuccessCursor(
-    mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
     std::unique_ptr<IDBKey> key,
     std::unique_ptr<IDBKey> primary_key,
     base::Optional<std::unique_ptr<IDBValue>> optional_value) {
@@ -154,7 +154,7 @@ void WebIDBCallbacksImpl::SuccessCursor(
     return;
 
   std::unique_ptr<WebIDBCursorImpl> cursor = std::make_unique<WebIDBCursorImpl>(
-      std::move(cursor_info), transaction_id_, task_runner_);
+      std::move(pending_cursor), transaction_id_, task_runner_);
   std::unique_ptr<IDBValue> value;
   if (optional_value.has_value()) {
     value = std::move(optional_value.value());

third_party/blink/renderer/modules/indexeddb/web_idb_callbacks_impl.h

@@ -32,6 +32,7 @@
 #include <memory>
 
 #include "base/memory/weak_ptr.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/renderer/core/probe/async_task_id.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h"
@@ -67,7 +68,7 @@ class WebIDBCallbacksImpl final : public WebIDBCallbacks {
       Vector<mojom::blink::IDBNameAndVersionPtr>) override;
   void SuccessStringList(const Vector<String>&) override;
   void SuccessCursor(
-      mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
       std::unique_ptr<IDBKey> key,
       std::unique_ptr<IDBKey> primary_key,
       base::Optional<std::unique_ptr<IDBValue>> optional_value) override;

third_party/blink/renderer/modules/indexeddb/web_idb_cursor_impl.cc

@@ -14,12 +14,11 @@
 #include "third_party/blink/renderer/platform/wtf/functional.h"
 
 using blink::mojom::blink::IDBCallbacksAssociatedPtrInfo;
-using blink::mojom::blink::IDBCursorAssociatedPtrInfo;
 
 namespace blink {
 
 WebIDBCursorImpl::WebIDBCursorImpl(
-    mojom::blink::IDBCursorAssociatedPtrInfo cursor_info,
+    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
     int64_t transaction_id,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : transaction_id_(transaction_id),
@@ -28,7 +27,7 @@ WebIDBCursorImpl::WebIDBCursorImpl(
       pending_onsuccess_callbacks_(0),
       prefetch_amount_(kMinPrefetchAmount),
       task_runner_(task_runner) {
-  cursor_.Bind(std::move(cursor_info), std::move(task_runner));
+  cursor_.Bind(std::move(pending_cursor), std::move(task_runner));
   IndexedDBDispatcher::RegisterCursor(this);
 }
 

third_party/blink/renderer/modules/indexeddb/web_idb_cursor_impl.h

@@ -8,6 +8,8 @@
 #include <stdint.h>
 
 #include "base/gtest_prod_util.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_value.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h"
@@ -18,9 +20,10 @@ namespace blink {
 
 class MODULES_EXPORT WebIDBCursorImpl : public WebIDBCursor {
  public:
-  WebIDBCursorImpl(mojom::blink::IDBCursorAssociatedPtrInfo cursor,
-                   int64_t transaction_id,
-                   scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  WebIDBCursorImpl(
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor,
+      int64_t transaction_id,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~WebIDBCursorImpl() override;
 
   void Advance(uint32_t count, WebIDBCallbacks* callback) override;
@@ -65,7 +68,7 @@ class MODULES_EXPORT WebIDBCursorImpl : public WebIDBCursor {
 
   int64_t transaction_id_;
 
-  mojom::blink::IDBCursorAssociatedPtr cursor_;
+  mojo::AssociatedRemote<mojom::blink::IDBCursor> cursor_;
 
   // Prefetch cache. Keys and values are stored in reverse order so that a
   // cache'd continue can pop a value off of the back and prevent new memory

third_party/blink/renderer/modules/indexeddb/web_idb_cursor_impl_unittest.cc

@@ -11,7 +11,9 @@
 
 #include "base/bind.h"
 #include "base/macros.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
@@ -25,9 +27,10 @@ namespace {
 
 class MockCursorImpl : public mojom::blink::IDBCursor {
  public:
-  explicit MockCursorImpl(mojom::blink::IDBCursorAssociatedRequest request)
-      : binding_(this, std::move(request)) {
-    binding_.set_connection_error_handler(base::BindOnce(
+  explicit MockCursorImpl(
+      mojo::PendingAssociatedReceiver<mojom::blink::IDBCursor> pending_receiver)
+      : receiver_(this, std::move(pending_receiver)) {
+    receiver_.set_disconnect_handler(base::BindOnce(
         &MockCursorImpl::CursorDestroyed, base::Unretained(this)));
   }
 
@@ -77,7 +80,7 @@ class MockCursorImpl : public mojom::blink::IDBCursor {
   int continue_calls_ = 0;
   bool destroyed_ = false;
 
-  mojo::AssociatedBinding<IDBCursor> binding_;
+  mojo::AssociatedReceiver<IDBCursor> receiver_;
 };
 
 class MockContinueCallbacks : public testing::StrictMock<MockWebIDBCallbacks> {
@@ -110,11 +113,11 @@ class MockContinueCallbacks : public testing::StrictMock<MockWebIDBCallbacks> {
 class WebIDBCursorImplTest : public testing::Test {
  public:
   WebIDBCursorImplTest() : null_key_(IDBKey::CreateNone()) {
-    mojom::blink::IDBCursorAssociatedPtr ptr;
+    mojo::AssociatedRemote<mojom::blink::IDBCursor> remote;
     mock_cursor_ = std::make_unique<MockCursorImpl>(
-        mojo::MakeRequestAssociatedWithDedicatedPipe(&ptr));
+        remote.BindNewEndpointAndPassDedicatedReceiverForTesting());
     cursor_ = std::make_unique<WebIDBCursorImpl>(
-        ptr.PassInterface(), 1,
+        remote.Unbind(), 1,
         blink::scheduler::GetSingleThreadTaskRunnerForTesting());
   }
 

third_party/blink/renderer/modules/indexeddb/web_idb_database.h

@@ -49,7 +49,7 @@ class MODULES_EXPORT WebIDBDatabase {
                                  const String& name) = 0;
   virtual void CreateTransaction(
       mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-          pending_receiver,
+          transaction_receiver,
       int64_t id,
       const Vector<int64_t>& scope,
       mojom::IDBTransactionMode) = 0;

third_party/blink/renderer/modules/indexeddb/web_idb_database_impl.cc

@@ -33,11 +33,11 @@ void WebIDBDatabaseImpl::RenameObjectStore(int64_t transaction_id,
 
 void WebIDBDatabaseImpl::CreateTransaction(
     mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-        pending_receiver,
+        transaction_receiver,
     int64_t transaction_id,
     const Vector<int64_t>& object_store_ids,
     mojom::IDBTransactionMode mode) {
-  database_->CreateTransaction(std::move(pending_receiver), transaction_id,
+  database_->CreateTransaction(std::move(transaction_receiver), transaction_id,
                                object_store_ids, mode);
 }
 
@@ -210,7 +210,7 @@ void WebIDBDatabaseImpl::OpenCursorCallback(
   }
 
   CHECK(result->is_value());
-  callbacks->SuccessCursor(std::move(result->get_value()->cursor),
+  callbacks->SuccessCursor(std::move(result->get_value()->pending_cursor),
                            std::move(result->get_value()->key),
                            std::move(result->get_value()->primary_key),
                            std::move(result->get_value()->value));

third_party/blink/renderer/modules/indexeddb/web_idb_database_impl.h

@@ -29,7 +29,7 @@ class MODULES_EXPORT WebIDBDatabaseImpl : public WebIDBDatabase {
                          int64_t object_store_id,
                          const String& new_name) override;
   void CreateTransaction(mojo::PendingAssociatedReceiver<
-                             mojom::blink::IDBTransaction> pending_receiver,
+                             mojom::blink::IDBTransaction> transaction_receiver,
                          int64_t transaction_id,
                          const Vector<int64_t>& scope,
                          mojom::IDBTransactionMode mode) override;

third_party/blink/renderer/modules/indexeddb/web_idb_factory.h

@@ -51,7 +51,7 @@ class MODULES_EXPORT WebIDBFactory {
       const WTF::String& name,
       int64_t version,
       mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-          pending_receiver,
+          transaction_receiver,
       int64_t transaction_id,
       std::unique_ptr<WebIDBCallbacks>,
       std::unique_ptr<WebIDBDatabaseCallbacks>) = 0;

third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.cc

@@ -37,7 +37,7 @@ void WebIDBFactoryImpl::Open(
     const String& name,
     int64_t version,
     mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-        pending_receiver,
+        transaction_receiver,
     int64_t transaction_id,
     std::unique_ptr<WebIDBCallbacks> callbacks,
     std::unique_ptr<WebIDBDatabaseCallbacks> database_callbacks) {
@@ -48,7 +48,8 @@ void WebIDBFactoryImpl::Open(
   DCHECK(!name.IsNull());
   factory_->Open(GetCallbacksProxy(std::move(callbacks)),
                  GetDatabaseCallbacksProxy(std::move(database_callbacks_impl)),
-                 name, version, std::move(pending_receiver), transaction_id);
+                 name, version, std::move(transaction_receiver),
+                 transaction_id);
 }
 
 void WebIDBFactoryImpl::DeleteDatabase(

third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.h

@@ -33,7 +33,7 @@ class WebIDBFactoryImpl : public WebIDBFactory {
       const WTF::String& name,
       int64_t version,
       mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-          pending_receiver,
+          transaction_receiver,
       int64_t transaction_id,
       std::unique_ptr<WebIDBCallbacks> callbacks,
       std::unique_ptr<WebIDBDatabaseCallbacks> database_callbacks) override;