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

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

Bug: 955171, 978694
Change-Id: I7bb92e5f5dc5894e33b3fa63edbf893a52c2af61
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1768589
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@{#692018}

content/browser/indexed_db/indexed_db_database_callbacks.cc

@@ -21,18 +21,19 @@ namespace content {
 
 IndexedDBDatabaseCallbacks::IndexedDBDatabaseCallbacks(
     scoped_refptr<IndexedDBContextImpl> context,
-    IDBDatabaseCallbacksAssociatedPtrInfo callbacks_info,
+    mojo::PendingAssociatedRemote<blink::mojom::IDBDatabaseCallbacks>
+        pending_callbacks,
     base::SequencedTaskRunner* idb_runner)
     : indexed_db_context_(std::move(context)) {
   DCHECK(idb_runner->RunsTasksInCurrentSequence());
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  if (!callbacks_info.is_valid())
+  if (!pending_callbacks.is_valid())
     return;
-  callbacks_.Bind(std::move(callbacks_info));
+  callbacks_.Bind(std::move(pending_callbacks));
   // |callbacks_| is owned by |this|, so if |this| is destroyed, then
   // |callbacks_| will also be destroyed.  While |callbacks_| is otherwise
   // alive, |this| will always be valid.
-  callbacks_.set_connection_error_handler(base::BindOnce(
+  callbacks_.set_disconnect_handler(base::BindOnce(
       &IndexedDBDatabaseCallbacks::OnConnectionError, base::Unretained(this)));
 }
 

content/browser/indexed_db/indexed_db_database_callbacks.h

@@ -14,6 +14,8 @@
 #include "base/sequence_checker.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_thread.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.h"
 
 namespace content {
@@ -27,7 +29,8 @@ class CONTENT_EXPORT IndexedDBDatabaseCallbacks
  public:
   IndexedDBDatabaseCallbacks(
       scoped_refptr<IndexedDBContextImpl> context,
-      blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo callbacks_info,
+      mojo::PendingAssociatedRemote<blink::mojom::IDBDatabaseCallbacks>
+          pending_callbacks,
       base::SequencedTaskRunner* idb_runner);
 
   virtual void OnForcedClose();
@@ -48,7 +51,7 @@ class CONTENT_EXPORT IndexedDBDatabaseCallbacks
 
   bool complete_ = false;
   scoped_refptr<IndexedDBContextImpl> indexed_db_context_;
-  blink::mojom::IDBDatabaseCallbacksAssociatedPtr callbacks_;
+  mojo::AssociatedRemote<blink::mojom::IDBDatabaseCallbacks> callbacks_;
   SEQUENCE_CHECKER(sequence_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDatabaseCallbacks);

content/browser/indexed_db/indexed_db_dispatcher_host.cc

@@ -102,14 +102,13 @@ IndexedDBDispatcherHost::CreateCursorBinding(
   auto cursor_impl = std::make_unique<CursorImpl>(std::move(cursor), origin,
                                                   this, IDBTaskRunner());
   auto* cursor_impl_ptr = cursor_impl.get();
-  mojo::PendingAssociatedRemote<blink::mojom::IDBCursor> pending_remote;
+  mojo::PendingAssociatedRemote<blink::mojom::IDBCursor> remote;
   mojo::ReceiverId receiver_id = cursor_receivers_.Add(
-      std::move(cursor_impl),
-      pending_remote.InitWithNewEndpointAndPassReceiver());
+      std::move(cursor_impl), remote.InitWithNewEndpointAndPassReceiver());
   cursor_impl_ptr->OnRemoveBinding(
       base::BindOnce(&IndexedDBDispatcherHost::RemoveCursorBinding,
                      weak_factory_.GetWeakPtr(), receiver_id));
-  return pending_remote;
+  return remote;
 }
 
 void IndexedDBDispatcherHost::RemoveCursorBinding(
@@ -166,7 +165,8 @@ void IndexedDBDispatcherHost::GetDatabaseNames(
 
 void IndexedDBDispatcherHost::Open(
     blink::mojom::IDBCallbacksAssociatedPtrInfo callbacks_info,
-    blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo database_callbacks_info,
+    mojo::PendingAssociatedRemote<blink::mojom::IDBDatabaseCallbacks>
+        pending_database_callbacks,
     const base::string16& name,
     int64_t version,
     mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>
@@ -180,7 +180,7 @@ void IndexedDBDispatcherHost::Open(
                              std::move(callbacks_info), IDBTaskRunner()));
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks(
       new IndexedDBDatabaseCallbacks(indexed_db_context_,
-                                     std::move(database_callbacks_info),
+                                     std::move(pending_database_callbacks),
                                      IDBTaskRunner()));
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 

content/browser/indexed_db/indexed_db_dispatcher_host.h

@@ -105,8 +105,8 @@ class CONTENT_EXPORT IndexedDBDispatcherHost
   void GetDatabaseNames(
       blink::mojom::IDBCallbacksAssociatedPtrInfo callbacks_info) override;
   void Open(blink::mojom::IDBCallbacksAssociatedPtrInfo callbacks_info,
-            blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo
-                database_callbacks_info,
+            mojo::PendingAssociatedRemote<blink::mojom::IDBDatabaseCallbacks>
+                pending_database_callbacks,
             const base::string16& name,
             int64_t version,
             mojo::PendingAssociatedReceiver<blink::mojom::IDBTransaction>

content/browser/indexed_db/indexed_db_dispatcher_host_unittest.cc

@@ -50,8 +50,6 @@ using blink::mojom::IDBCallbacksAssociatedPtrInfo;
 using blink::mojom::IDBDatabaseAssociatedPtr;
 using blink::mojom::IDBDatabaseAssociatedPtrInfo;
 using blink::mojom::IDBDatabaseAssociatedRequest;
-using blink::mojom::IDBDatabaseCallbacks;
-using blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo;
 using blink::mojom::IDBFactory;
 using blink::mojom::IDBFactoryPtr;
 using blink::mojom::IDBValue;

content/browser/indexed_db/indexed_db_factory_unittest.cc

@@ -35,6 +35,7 @@
 #include "content/public/browser/storage_usage_info.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_utils.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
 #include "storage/browser/test/mock_quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/indexeddb/web_idb_types.h"
@@ -705,8 +706,8 @@ TEST_F(IndexedDBFactoryTest, QuotaErrorOnDiskFull) {
 
   auto callbacks = base::MakeRefCounted<LookingForQuotaErrorMockCallbacks>();
   auto dummy_database_callbacks =
-      base::MakeRefCounted<IndexedDBDatabaseCallbacks>(nullptr, nullptr,
-                                                       context()->TaskRunner());
+      base::MakeRefCounted<IndexedDBDatabaseCallbacks>(
+          nullptr, mojo::NullAssociatedRemote(), context()->TaskRunner());
   const Origin origin = Origin::Create(GURL("http://localhost:81"));
   const base::string16 name(ASCIIToUTF16("name"));
   auto create_transaction_callback =

content/browser/indexed_db/mock_indexed_db_database_callbacks.cc

@@ -5,13 +5,14 @@
 #include "content/browser/indexed_db/mock_indexed_db_database_callbacks.h"
 
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 MockIndexedDBDatabaseCallbacks::MockIndexedDBDatabaseCallbacks()
     : IndexedDBDatabaseCallbacks(scoped_refptr<IndexedDBContextImpl>(nullptr),
-                                 nullptr,
+                                 mojo::NullAssociatedRemote(),
                                  base::SequencedTaskRunnerHandle::Get().get()),
       abort_called_(false),
       forced_close_called_(false) {}

content/browser/indexed_db/mock_mojo_indexed_db_database_callbacks.cc

@@ -6,15 +6,14 @@
 
 namespace content {
 
-MockMojoIndexedDBDatabaseCallbacks::MockMojoIndexedDBDatabaseCallbacks()
-    : binding_(this) {}
-MockMojoIndexedDBDatabaseCallbacks::~MockMojoIndexedDBDatabaseCallbacks() {}
+MockMojoIndexedDBDatabaseCallbacks::MockMojoIndexedDBDatabaseCallbacks() =
+    default;
+MockMojoIndexedDBDatabaseCallbacks::~MockMojoIndexedDBDatabaseCallbacks() =
+    default;
 
-blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo
+mojo::PendingAssociatedRemote<blink::mojom::IDBDatabaseCallbacks>
 MockMojoIndexedDBDatabaseCallbacks::CreateInterfacePtrAndBind() {
-  blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo ptr_info;
-  binding_.Bind(::mojo::MakeRequest(&ptr_info));
-  return ptr_info;
+  return receiver_.BindNewEndpointAndPassRemote();
 }
 
 }  // namespace content

content/browser/indexed_db/mock_mojo_indexed_db_database_callbacks.h

@@ -8,7 +8,8 @@
 #include <stdint.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/pending_associated_remote.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
 
@@ -20,7 +21,7 @@ class MockMojoIndexedDBDatabaseCallbacks
   MockMojoIndexedDBDatabaseCallbacks();
   ~MockMojoIndexedDBDatabaseCallbacks() override;
 
-  blink::mojom::IDBDatabaseCallbacksAssociatedPtrInfo
+  mojo::PendingAssociatedRemote<blink::mojom::IDBDatabaseCallbacks>
   CreateInterfacePtrAndBind();
 
   MOCK_METHOD0(ForcedClose, void());
@@ -38,7 +39,7 @@ class MockMojoIndexedDBDatabaseCallbacks
   }
 
  private:
-  mojo::AssociatedBinding<blink::mojom::IDBDatabaseCallbacks> binding_;
+  mojo::AssociatedReceiver<blink::mojom::IDBDatabaseCallbacks> receiver_{this};
 
   DISALLOW_COPY_AND_ASSIGN(MockMojoIndexedDBDatabaseCallbacks);
 };

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

@@ -321,7 +321,7 @@ union IDBDatabaseGetAllResult {
 };
 
 struct IDBDatabaseOpenCursorValue {
-  pending_associated_remote<IDBCursor> pending_cursor;
+  pending_associated_remote<IDBCursor> cursor;
   IDBKey key;
   IDBKey primary_key;
   IDBValue? value;
@@ -417,7 +417,7 @@ interface IDBFactory {
   GetDatabaseInfo(associated IDBCallbacks callbacks);
   GetDatabaseNames(associated IDBCallbacks callbacks);
   Open(associated IDBCallbacks callbacks,
-       associated IDBDatabaseCallbacks database_callbacks,
+       pending_associated_remote<IDBDatabaseCallbacks> pending_database_callbacks,
        mojo_base.mojom.String16 name,
        int64 version,
        pending_associated_receiver<IDBTransaction> version_change_transaction_receiver,

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

@@ -135,7 +135,7 @@ class WebIDBGetDBNamesCallbacksImpl : public WebIDBCallbacks {
   void SuccessStringList(const Vector<String>&) override { NOTREACHED(); }
 
   void SuccessCursor(
-      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor_info,
       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/mock_web_idb_callbacks.cc

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

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

@@ -43,14 +43,14 @@ class MockWebIDBCallbacks : public WebIDBCallbacks {
   MOCK_METHOD1(SuccessStringList, void(const Vector<String>&));
 
   void SuccessCursor(
-      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor_info,
       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 mojo::PendingAssociatedRemote<mojom::blink::IDBCursor>&
-               pending_cursor,
+               cursor_info,
            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/web_idb_callbacks.h

@@ -47,7 +47,7 @@ class WebIDBCallbacks : public mojom::blink::IDBCallbacks {
   virtual void SetState(base::WeakPtr<WebIDBCursorImpl> cursor,
                         int64_t transaction_id) = 0;
   virtual void SuccessCursor(
-      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor_info,
       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(
-    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
+    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor_info,
     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(pending_cursor), transaction_id_, task_runner_);
+      std::move(cursor_info), 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

@@ -68,7 +68,7 @@ class WebIDBCallbacksImpl final : public WebIDBCallbacks {
       Vector<mojom::blink::IDBNameAndVersionPtr>) override;
   void SuccessStringList(const Vector<String>&) override;
   void SuccessCursor(
-      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor_info,
       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

@@ -18,7 +18,7 @@ using blink::mojom::blink::IDBCallbacksAssociatedPtrInfo;
 namespace blink {
 
 WebIDBCursorImpl::WebIDBCursorImpl(
-    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> pending_cursor,
+    mojo::PendingAssociatedRemote<mojom::blink::IDBCursor> cursor_info,
     int64_t transaction_id,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : transaction_id_(transaction_id),
@@ -27,7 +27,7 @@ WebIDBCursorImpl::WebIDBCursorImpl(
       pending_onsuccess_callbacks_(0),
       prefetch_amount_(kMinPrefetchAmount),
       task_runner_(task_runner) {
-  cursor_.Bind(std::move(pending_cursor), std::move(task_runner));
+  cursor_.Bind(std::move(cursor_info), std::move(task_runner));
   IndexedDBDispatcher::RegisterCursor(this);
 }
 

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

@@ -28,8 +28,8 @@ namespace {
 class MockCursorImpl : public mojom::blink::IDBCursor {
  public:
   explicit MockCursorImpl(
-      mojo::PendingAssociatedReceiver<mojom::blink::IDBCursor> pending_receiver)
-      : receiver_(this, std::move(pending_receiver)) {
+      mojo::PendingAssociatedReceiver<mojom::blink::IDBCursor> receiver)
+      : receiver_(this, std::move(receiver)) {
     receiver_.set_disconnect_handler(base::BindOnce(
         &MockCursorImpl::CursorDestroyed, base::Unretained(this)));
   }

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

@@ -210,7 +210,7 @@ void WebIDBDatabaseImpl::OpenCursorCallback(
   }
 
   CHECK(result->is_value());
-  callbacks->SuccessCursor(std::move(result->get_value()->pending_cursor),
+  callbacks->SuccessCursor(std::move(result->get_value()->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_factory_impl.cc

@@ -5,7 +5,7 @@
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.h"
 
 #include "base/memory/ptr_util.h"
-#include "mojo/public/cpp/bindings/strong_associated_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_associated_receiver.h"
 #include "third_party/blink/renderer/modules/indexeddb/indexed_db_database_callbacks_impl.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks_impl.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
@@ -72,14 +72,16 @@ WebIDBFactoryImpl::GetCallbacksProxy(
   return ptr_info;
 }
 
-mojom::blink::IDBDatabaseCallbacksAssociatedPtrInfo
+mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
 WebIDBFactoryImpl::GetDatabaseCallbacksProxy(
-    std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks) {
-  mojom::blink::IDBDatabaseCallbacksAssociatedPtrInfo ptr_info;
-  auto request = mojo::MakeRequest(&ptr_info);
-  mojo::MakeStrongAssociatedBinding(std::move(callbacks), std::move(request),
-                                    task_runner_);
-  return ptr_info;
+    std::unique_ptr<IndexedDBDatabaseCallbacksImpl> database_callbacks_impl) {
+  mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
+      pending_database_callbacks;
+  mojo::MakeSelfOwnedAssociatedReceiver(
+      std::move(database_callbacks_impl),
+      pending_database_callbacks.InitWithNewEndpointAndPassReceiver(),
+      task_runner_);
+  return pending_database_callbacks;
 }
 
 }  // namespace blink

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

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_WEB_IDB_FACTORY_IMPL_H_
 
 #include "mojo/public/cpp/bindings/pending_associated_receiver.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_key_range.h"
 #include "third_party/blink/renderer/modules/indexeddb/indexed_db_database_callbacks_impl.h"
@@ -44,8 +45,9 @@ class WebIDBFactoryImpl : public WebIDBFactory {
  private:
   mojom::blink::IDBCallbacksAssociatedPtrInfo GetCallbacksProxy(
       std::unique_ptr<WebIDBCallbacks> callbacks);
-  mojom::blink::IDBDatabaseCallbacksAssociatedPtrInfo GetDatabaseCallbacksProxy(
-      std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks);
+  mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
+  GetDatabaseCallbacksProxy(
+      std::unique_ptr<IndexedDBDatabaseCallbacksImpl> database_callbacks_impl);
 
   mojom::blink::IDBFactoryPtr factory_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;