IndexedDB: Remove unnecessary WebIDBFactory layer

Now that Blink can talk directly to Mojo (it's only been what... 3
years?) remove the WebIDBFactory cruft and have blink::IDBFactory make
calls directly to the backend mojom::blink::IDBFactory.

No functional changes.

Bug: 843764,717812
Change-Id: I7f8370570a21fd19c5a98b2b1d5d8e31db702a81
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2363176
Commit-Queue: Joshua Bell <jsbell@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#799900}

third_party/blink/renderer/modules/BUILD.gn

@@ -313,8 +313,6 @@ source_set("unit_tests") {
     "indexeddb/mock_web_idb_callbacks.h",
     "indexeddb/mock_web_idb_database.cc",
     "indexeddb/mock_web_idb_database.h",
-    "indexeddb/mock_web_idb_factory.cc",
-    "indexeddb/mock_web_idb_factory.h",
     "indexeddb/mock_web_idb_transaction.cc",
     "indexeddb/mock_web_idb_transaction.h",
     "indexeddb/web_idb_cursor_impl_unittest.cc",

third_party/blink/renderer/modules/indexeddb/BUILD.gn

@@ -80,9 +80,6 @@ blink_modules_sources("indexeddb") {
     "web_idb_database_callbacks_impl.h",
     "web_idb_database_impl.cc",
     "web_idb_database_impl.h",
-    "web_idb_factory.h",
-    "web_idb_factory_impl.cc",
-    "web_idb_factory_impl.h",
     "web_idb_transaction.h",
     "web_idb_transaction_impl.cc",
     "web_idb_transaction_impl.h",

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

@@ -33,6 +33,7 @@
 
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
 #include "mojo/public/cpp/bindings/pending_associated_remote.h"
+#include "mojo/public/cpp/bindings/self_owned_associated_receiver.h"
 #include "third_party/blink/public/mojom/feature_observer/feature_observer.mojom-blink.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/public/platform/platform.h"
@@ -54,10 +55,10 @@
 #include "third_party/blink/renderer/modules/indexeddb/idb_key.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_name_and_version.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_tracing.h"
+#include "third_party/blink/renderer/modules/indexeddb/indexed_db_database_callbacks_impl.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h"
+#include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks_impl.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_database_callbacks.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_factory.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.h"
 #include "third_party/blink/renderer/modules/indexeddb/web_idb_transaction_impl.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
@@ -212,9 +213,7 @@ static const char kPermissionDeniedErrorMessage[] =
     "The user denied permission to access the database.";
 
 IDBFactory::IDBFactory() = default;
-
-IDBFactory::IDBFactory(std::unique_ptr<WebIDBFactory> web_idb_factory)
-    : web_idb_factory_(std::move(web_idb_factory)) {}
+IDBFactory::~IDBFactory() = default;
 
 static bool IsContextValid(ExecutionContext* context) {
   if (auto* window = DynamicTo<LocalDOMWindow>(context))
@@ -223,21 +222,27 @@ static bool IsContextValid(ExecutionContext* context) {
   return true;
 }
 
-WebIDBFactory* IDBFactory::GetFactory(ExecutionContext* execution_context) {
-  if (!web_idb_factory_) {
-    mojo::PendingRemote<mojom::blink::IDBFactory> web_idb_factory_host_remote;
+void IDBFactory::SetFactoryForTesting(
+    mojo::Remote<mojom::blink::IDBFactory> factory) {
+  factory_ = std::move(factory);
+}
+
+mojo::Remote<mojom::blink::IDBFactory>& IDBFactory::GetFactory(
+    ExecutionContext* execution_context) {
+  if (!factory_) {
+    mojo::PendingRemote<mojom::blink::IDBFactory> factory;
     execution_context->GetBrowserInterfaceBroker().GetInterface(
-        web_idb_factory_host_remote.InitWithNewPipeAndPassReceiver());
+        factory.InitWithNewPipeAndPassReceiver());
 
     mojo::PendingRemote<mojom::blink::FeatureObserver> feature_observer;
     execution_context->GetBrowserInterfaceBroker().GetInterface(
         feature_observer.InitWithNewPipeAndPassReceiver());
 
-    web_idb_factory_ = std::make_unique<WebIDBFactoryImpl>(
-        std::move(web_idb_factory_host_remote), std::move(feature_observer),
-        execution_context->GetTaskRunner(TaskType::kDatabaseAccess));
+    task_runner_ = execution_context->GetTaskRunner(TaskType::kDatabaseAccess);
+    factory_.Bind(std::move(factory), task_runner_);
+    feature_observer_.Bind(std::move(feature_observer), task_runner_);
   }
-  return web_idb_factory_.get();
+  return factory_;
 }
 
 ScriptPromise IDBFactory::GetDatabaseInfo(ScriptState* script_state,
@@ -270,17 +275,11 @@ ScriptPromise IDBFactory::GetDatabaseInfo(ScriptState* script_state,
     return resolver->Promise();
   }
 
-  ExecutionContext* execution_context = ExecutionContext::From(script_state);
-  WebIDBFactory* factory = GetFactory(execution_context);
-  if (!factory) {
-    exception_state.ThrowSecurityError("An internal error occurred.");
-    resolver->Reject();
-    return resolver->Promise();
-  }
-  factory->GetDatabaseInfo(
-      std::make_unique<WebIDBGetDBNamesCallbacksImpl>(resolver));
-  ScriptPromise promise = resolver->Promise();
-  return promise;
+  auto callbacks = std::make_unique<WebIDBGetDBNamesCallbacksImpl>(resolver);
+  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
+  GetFactory(ExecutionContext::From(script_state))
+      ->GetDatabaseInfo(GetCallbacksProxy(std::move(callbacks)));
+  return resolver->Promise();
 }
 
 IDBRequest* IDBFactory::GetDatabaseNames(ScriptState* script_state,
@@ -311,13 +310,10 @@ IDBRequest* IDBFactory::GetDatabaseNames(ScriptState* script_state,
     return request;
   }
 
-  ExecutionContext* execution_context = ExecutionContext::From(script_state);
-  WebIDBFactory* factory = GetFactory(execution_context);
-  if (!factory) {
-    exception_state.ThrowSecurityError("An internal error occurred.");
-    return nullptr;
-  }
-  factory->GetDatabaseNames(request->CreateWebCallbacks());
+  auto callbacks = request->CreateWebCallbacks();
+  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
+  GetFactory(ExecutionContext::From(script_state))
+      ->GetDatabaseNames(GetCallbacksProxy(std::move(callbacks)));
   return request;
 }
 
@@ -357,12 +353,7 @@ IDBOpenDBRequest* IDBFactory::OpenInternal(ScriptState* script_state,
   auto* database_callbacks = MakeGarbageCollected<IDBDatabaseCallbacks>();
   int64_t transaction_id = IDBDatabase::NextTransactionId();
 
-  ExecutionContext* execution_context = ExecutionContext::From(script_state);
-  WebIDBFactory* factory = GetFactory(execution_context);
-  if (!factory) {
-    exception_state.ThrowSecurityError("An internal error occurred.");
-    return nullptr;
-  }
+  auto& factory = GetFactory(ExecutionContext::From(script_state));
 
   auto transaction_backend = std::make_unique<WebIDBTransactionImpl>(
       ExecutionContext::From(script_state)
@@ -372,8 +363,7 @@ IDBOpenDBRequest* IDBFactory::OpenInternal(ScriptState* script_state,
       transaction_receiver = transaction_backend->CreateReceiver();
   auto* request = MakeGarbageCollected<IDBOpenDBRequest>(
       script_state, database_callbacks, std::move(transaction_backend),
-      transaction_id, version, std::move(metrics),
-      factory->GetObservedFeature());
+      transaction_id, version, std::move(metrics), GetObservedFeature());
 
   if (!CachedAllowIndexedDB(script_state)) {
     request->HandleResponse(MakeGarbageCollected<DOMException>(
@@ -381,9 +371,16 @@ IDBOpenDBRequest* IDBFactory::OpenInternal(ScriptState* script_state,
     return request;
   }
 
-  factory->Open(name, version, std::move(transaction_receiver), transaction_id,
-                request->CreateWebCallbacks(),
-                database_callbacks->CreateWebCallbacks());
+  auto callbacks = request->CreateWebCallbacks();
+  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
+
+  auto database_callbacks_impl =
+      std::make_unique<IndexedDBDatabaseCallbacksImpl>(
+          database_callbacks->CreateWebCallbacks());
+
+  factory->Open(GetCallbacksProxy(std::move(callbacks)),
+                GetDatabaseCallbacksProxy(std::move(database_callbacks_impl)),
+                name, version, std::move(transaction_receiver), transaction_id);
   return request;
 }
 
@@ -432,17 +429,12 @@ IDBOpenDBRequest* IDBFactory::DeleteDatabaseInternal(
                       WebFeature::kFileAccessedDatabase);
   }
 
-  ExecutionContext* execution_context = ExecutionContext::From(script_state);
-  WebIDBFactory* factory = GetFactory(execution_context);
-  if (!factory) {
-    exception_state.ThrowSecurityError("An internal error occurred.");
-    return nullptr;
-  }
+  auto& factory = GetFactory(ExecutionContext::From(script_state));
 
   auto* request = MakeGarbageCollected<IDBOpenDBRequest>(
       script_state, nullptr, /*IDBTransactionAssociatedPtr=*/nullptr, 0,
       IDBDatabaseMetadata::kDefaultVersion, std::move(metrics),
-      factory->GetObservedFeature());
+      GetObservedFeature());
 
   if (!CachedAllowIndexedDB(script_state)) {
     request->HandleResponse(MakeGarbageCollected<DOMException>(
@@ -450,7 +442,10 @@ IDBOpenDBRequest* IDBFactory::DeleteDatabaseInternal(
     return request;
   }
 
-  factory->DeleteDatabase(name, request->CreateWebCallbacks(), force_close);
+  auto callbacks = request->CreateWebCallbacks();
+  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
+  factory->DeleteDatabase(GetCallbacksProxy(std::move(callbacks)), name,
+                          force_close);
   return request;
 }
 
@@ -517,4 +512,32 @@ bool IDBFactory::CachedAllowIndexedDB(ScriptState* script_state) {
   return cached_allowed_.value();
 }
 
+mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks>
+IDBFactory::GetCallbacksProxy(std::unique_ptr<WebIDBCallbacks> callbacks_impl) {
+  mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks> pending_callbacks;
+  mojo::MakeSelfOwnedAssociatedReceiver(
+      std::move(callbacks_impl),
+      pending_callbacks.InitWithNewEndpointAndPassReceiver(), task_runner_);
+  return pending_callbacks;
+}
+
+mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
+IDBFactory::GetDatabaseCallbacksProxy(
+    std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks) {
+  mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks> remote;
+  mojo::MakeSelfOwnedAssociatedReceiver(
+      std::move(callbacks), remote.InitWithNewEndpointAndPassReceiver(),
+      task_runner_);
+  return remote;
+}
+
+mojo::PendingRemote<mojom::blink::ObservedFeature>
+IDBFactory::GetObservedFeature() {
+  mojo::PendingRemote<mojom::blink::ObservedFeature> feature;
+  feature_observer_->Register(
+      feature.InitWithNewPipeAndPassReceiver(),
+      mojom::blink::ObservedFeatureType::kIndexedDBConnection);
+  return feature;
+}
+
 }  // namespace blink

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

@@ -29,9 +29,13 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_IDB_FACTORY_H_
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_IDB_FACTORY_H_
 
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "third_party/blink/public/mojom/feature_observer/feature_observer.mojom-blink.h"
+#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink-forward.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_open_db_request.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_factory.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
@@ -41,13 +45,15 @@ namespace blink {
 
 class ExceptionState;
 class ScriptState;
+class IndexedDBDatabaseCallbacksImpl;
+class WebIDBCallbacks;
 
 class MODULES_EXPORT IDBFactory final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   IDBFactory();
-  IDBFactory(std::unique_ptr<WebIDBFactory>);
+  ~IDBFactory() override;
 
   // Implement the IDBFactory IDL
   IDBOpenDBRequest* open(ScriptState*, const String& name, ExceptionState&);
@@ -71,8 +77,12 @@ class MODULES_EXPORT IDBFactory final : public ScriptWrappable {
 
   ScriptPromise GetDatabaseInfo(ScriptState*, ExceptionState&);
 
+  void SetFactoryForTesting(mojo::Remote<mojom::blink::IDBFactory> factory);
+
  private:
-  WebIDBFactory* GetFactory(ExecutionContext* execution_context);
+  // Lazy initialize the mojo pipe to the back end.
+  mojo::Remote<mojom::blink::IDBFactory>& GetFactory(
+      ExecutionContext* execution_context);
 
   IDBOpenDBRequest* OpenInternal(ScriptState*,
                                  const String& name,
@@ -87,7 +97,17 @@ class MODULES_EXPORT IDBFactory final : public ScriptWrappable {
   bool AllowIndexedDB(ScriptState* script_state);
   bool CachedAllowIndexedDB(ScriptState* script_state);
 
-  std::unique_ptr<WebIDBFactory> web_idb_factory_;
+  mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks> GetCallbacksProxy(
+      std::unique_ptr<WebIDBCallbacks> callbacks);
+  mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
+  GetDatabaseCallbacksProxy(
+      std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks);
+  mojo::PendingRemote<mojom::blink::ObservedFeature> GetObservedFeature();
+
+  mojo::Remote<mojom::blink::IDBFactory> factory_;
+  mojo::Remote<mojom::blink::FeatureObserver> feature_observer_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
   base::Optional<bool> cached_allowed_;
 };
 

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

@@ -8,6 +8,9 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_refptr.h"
+#include "mojo/public/cpp/bindings/associated_remote.h"
+#include "mojo/public/cpp/bindings/pending_associated_remote.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink.h"
 #include "third_party/blink/public/platform/web_security_origin.h"
@@ -20,9 +23,9 @@
 #include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_database_error.h"
 #include "third_party/blink/renderer/modules/indexeddb/idb_name_and_version.h"
-#include "third_party/blink/renderer/modules/indexeddb/mock_web_idb_factory.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
+#include "third_party/blink/renderer/platform/testing/testing_platform_support.h"
 
 namespace blink {
 namespace {
@@ -48,23 +51,100 @@ class TestHelperFunction : public ScriptFunction {
   bool* called_flag_;
 };
 
+class BackendFactoryWithMockedDatabaseInfo : public mojom::blink::IDBFactory {
+ public:
+  explicit BackendFactoryWithMockedDatabaseInfo(
+      mojo::PendingReceiver<mojom::blink::IDBFactory> pending_receiver)
+      : receiver_(this, std::move(pending_receiver)) {}
+
+  BackendFactoryWithMockedDatabaseInfo(
+      const BackendFactoryWithMockedDatabaseInfo&) = delete;
+  BackendFactoryWithMockedDatabaseInfo& operator=(
+      const BackendFactoryWithMockedDatabaseInfo&) = delete;
+
+  void Open(mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks>
+                pending_callbacks,
+            mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
+                database_callbacks,
+            const WTF::String& name,
+            int64_t version,
+            mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
+                version_change_transaction_receiver,
+            int64_t transaction_id) override {
+    NOTREACHED();
+  }
+
+  void DeleteDatabase(mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks>
+                          pending_callbacks,
+                      const WTF::String& name,
+                      bool force_close) override {
+    NOTREACHED();
+  }
+
+  void AbortTransactionsAndCompactDatabase(
+      AbortTransactionsAndCompactDatabaseCallback callback) override {
+    NOTREACHED();
+  }
+
+  void AbortTransactionsForDatabase(
+      AbortTransactionsForDatabaseCallback callback) override {
+    NOTREACHED();
+  }
+
+  void GetDatabaseNames(
+      mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks>
+          pending_callbacks) override {
+    NOTREACHED();
+  }
+
+  void GetDatabaseInfo(mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks>
+                           pending_callbacks) override {
+    callbacks_ptr_->Bind(std::move(pending_callbacks));
+  }
+
+  void SetCallbacksPointer(
+      mojo::AssociatedRemote<mojom::blink::IDBCallbacks>* callbacks_ptr) {
+    callbacks_ptr_ = callbacks_ptr;
+  }
+
+ private:
+  mojo::Receiver<mojom::blink::IDBFactory> receiver_;
+  mojo::AssociatedRemote<mojom::blink::IDBCallbacks>* callbacks_ptr_;
+};
+
 class IDBFactoryTest : public testing::Test {
+ public:
+  IDBFactoryTest(const IDBFactoryTest&) = delete;
+  IDBFactoryTest& operator=(const IDBFactoryTest&) = delete;
+
  protected:
-  IDBFactoryTest() {}
+  IDBFactoryTest() = default;
+  ~IDBFactoryTest() override = default;
 
-  ~IDBFactoryTest() override {}
+  ScopedTestingPlatformSupport<TestingPlatformSupport> platform_;
 };
 
 TEST_F(IDBFactoryTest, WebIDBGetDBInfoCallbacksResolvesPromise) {
   V8TestingScope scope(KURL("https://example.com"));
-  auto web_factory = std::make_unique<MockWebIDBFactory>();
-  std::unique_ptr<WebIDBCallbacks> callbacks;
-  web_factory->SetCallbacksPointer(&callbacks);
-  auto* factory = MakeGarbageCollected<IDBFactory>(std::move(web_factory));
+
+  mojo::Remote<mojom::blink::IDBFactory> remote;
+  auto mock_factory = std::make_unique<BackendFactoryWithMockedDatabaseInfo>(
+      remote.BindNewPipeAndPassReceiver(
+          scope.GetExecutionContext()->GetTaskRunner(
+              TaskType::kDatabaseAccess)));
+
+  mojo::AssociatedRemote<mojom::blink::IDBCallbacks> callbacks;
+  mock_factory->SetCallbacksPointer(&callbacks);
+  auto* factory = MakeGarbageCollected<IDBFactory>();
+  factory->SetFactoryForTesting(std::move(remote));
 
   DummyExceptionStateForTesting exception_state;
   ScriptPromise promise =
       factory->GetDatabaseInfo(scope.GetScriptState(), exception_state);
+
+  // Allow the GetDatabaseInfo message to propagate across mojo pipes.
+  platform_->RunUntilIdle();
+
   bool on_fulfilled = false;
   bool on_rejected = false;
   promise.Then(
@@ -80,7 +160,10 @@ TEST_F(IDBFactoryTest, WebIDBGetDBInfoCallbacksResolvesPromise) {
   EXPECT_FALSE(on_fulfilled);
   EXPECT_FALSE(on_rejected);
 
-  v8::MicrotasksScope::PerformCheckpoint(scope.GetIsolate());
+  // Allow the Success message to propagate across mojo pipes. This will also
+  // perform a microtask checkpoint, so an explicit call to do that is not
+  // needed.
+  platform_->RunUntilIdle();
 
   EXPECT_TRUE(on_fulfilled);
   EXPECT_FALSE(on_rejected);
@@ -88,14 +171,25 @@ TEST_F(IDBFactoryTest, WebIDBGetDBInfoCallbacksResolvesPromise) {
 
 TEST_F(IDBFactoryTest, WebIDBGetDBNamesCallbacksRejectsPromise) {
   V8TestingScope scope(KURL("https://example.com"));
-  auto web_factory = std::make_unique<MockWebIDBFactory>();
-  std::unique_ptr<WebIDBCallbacks> callbacks;
-  web_factory->SetCallbacksPointer(&callbacks);
-  auto* factory = MakeGarbageCollected<IDBFactory>(std::move(web_factory));
+
+  mojo::Remote<mojom::blink::IDBFactory> remote;
+  auto mock_factory = std::make_unique<BackendFactoryWithMockedDatabaseInfo>(
+      remote.BindNewPipeAndPassReceiver(
+          scope.GetExecutionContext()->GetTaskRunner(
+              TaskType::kDatabaseAccess)));
+
+  mojo::AssociatedRemote<mojom::blink::IDBCallbacks> callbacks;
+  mock_factory->SetCallbacksPointer(&callbacks);
+  auto* factory = MakeGarbageCollected<IDBFactory>();
+  factory->SetFactoryForTesting(std::move(remote));
 
   DummyExceptionStateForTesting exception_state;
   ScriptPromise promise =
       factory->GetDatabaseInfo(scope.GetScriptState(), exception_state);
+
+  // Allow the GetDatabaseInfo message to propagate across mojo pipes.
+  platform_->RunUntilIdle();
+
   bool on_fulfilled = false;
   bool on_rejected = false;
   promise.Then(
@@ -105,12 +199,15 @@ TEST_F(IDBFactoryTest, WebIDBGetDBNamesCallbacksRejectsPromise) {
   EXPECT_FALSE(on_fulfilled);
   EXPECT_FALSE(on_rejected);
 
-  callbacks->Error(mojom::blink::IDBException::kNoError, String());
+  callbacks->Error(mojom::blink::IDBException::kNoError, "message");
 
   EXPECT_FALSE(on_fulfilled);
   EXPECT_FALSE(on_rejected);
 
-  v8::MicrotasksScope::PerformCheckpoint(scope.GetIsolate());
+  // Allow the Error message to propagate across mojo pipes. This will also
+  // perform a microtask checkpoint, so an explicit call to do that is not
+  // needed.
+  platform_->RunUntilIdle();
 
   EXPECT_FALSE(on_fulfilled);
   EXPECT_TRUE(on_rejected);

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

-// Copyright 2018 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 "third_party/blink/renderer/modules/indexeddb/mock_web_idb_factory.h"
-
-#include <memory>
-
-#include "base/memory/ptr_util.h"
-#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
-
-namespace blink {
-
-MockWebIDBFactory::MockWebIDBFactory() = default;
-
-MockWebIDBFactory::~MockWebIDBFactory() = default;
-
-void MockWebIDBFactory::GetDatabaseInfo(
-    std::unique_ptr<WebIDBCallbacks> callbacks) {
-  *callbacks_ptr_ = std::move(callbacks);
-}
-
-void MockWebIDBFactory::SetCallbacksPointer(
-    std::unique_ptr<WebIDBCallbacks>* callbacks_ptr) {
-  callbacks_ptr_ = callbacks_ptr;
-}
-
-}  // namespace blink

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

-// Copyright 2018 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.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_MOCK_WEB_IDB_FACTORY_H_
-#define THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_MOCK_WEB_IDB_FACTORY_H_
-
-#include <memory>
-
-#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_database_callbacks.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_factory.h"
-#include "third_party/blink/renderer/modules/modules_export.h"
-
-namespace WTF {
-class String;
-}
-
-namespace blink {
-
-class MockWebIDBFactory : public testing::StrictMock<blink::WebIDBFactory> {
- public:
-  MockWebIDBFactory();
-  ~MockWebIDBFactory() override;
-
-  void GetDatabaseInfo(std::unique_ptr<WebIDBCallbacks>);
-  MOCK_METHOD1(GetDatabaseNames, void(std::unique_ptr<WebIDBCallbacks>));
-  MOCK_METHOD6(
-      Open,
-      void(const WTF::String& name,
-           int64_t version,
-           mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-               transaction_receiver,
-           int64_t transaction_id,
-           std::unique_ptr<WebIDBCallbacks>,
-           std::unique_ptr<WebIDBDatabaseCallbacks>));
-  MOCK_METHOD3(DeleteDatabase,
-               void(const WTF::String& name,
-                    std::unique_ptr<WebIDBCallbacks>,
-                    bool force_close));
-  MOCK_METHOD0(GetObservedFeature,
-               mojo::PendingRemote<mojom::blink::ObservedFeature>());
-
-  void SetCallbacksPointer(std::unique_ptr<WebIDBCallbacks>* callbacks);
-
- private:
-  std::unique_ptr<WebIDBCallbacks>* callbacks_ptr_;
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_MOCK_WEB_IDB_FACTORY_H_

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

-/*
- * Copyright (C) 2011 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_WEB_IDB_FACTORY_H_
-#define THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_WEB_IDB_FACTORY_H_
-
-#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
-#include "third_party/blink/public/mojom/feature_observer/feature_observer.mojom-blink.h"
-#include "third_party/blink/renderer/modules/modules_export.h"
-
-namespace WTF {
-class String;
-}
-
-namespace blink {
-
-class WebIDBCallbacks;
-class WebIDBDatabaseCallbacks;
-
-class MODULES_EXPORT WebIDBFactory {
- public:
-  virtual ~WebIDBFactory() = default;
-
-  virtual void GetDatabaseInfo(std::unique_ptr<WebIDBCallbacks>) = 0;
-  virtual void GetDatabaseNames(std::unique_ptr<WebIDBCallbacks>) = 0;
-  virtual void Open(
-      const WTF::String& name,
-      int64_t version,
-      mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-          transaction_receiver,
-      int64_t transaction_id,
-      std::unique_ptr<WebIDBCallbacks>,
-      std::unique_ptr<WebIDBDatabaseCallbacks>) = 0;
-  virtual void DeleteDatabase(const WTF::String& name,
-                              std::unique_ptr<WebIDBCallbacks>,
-                              bool force_close) = 0;
-  virtual mojo::PendingRemote<mojom::blink::ObservedFeature>
-  GetObservedFeature() = 0;
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_WEB_IDB_FACTORY_H_

third_party/blink/renderer/modules/indexeddb/web_idb_factory_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 "third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.h"
-
-#include "base/memory/ptr_util.h"
-#include "mojo/public/cpp/bindings/pending_remote.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"
-
-namespace blink {
-
-WebIDBFactoryImpl::WebIDBFactoryImpl(
-    mojo::PendingRemote<mojom::blink::IDBFactory> pending_factory,
-    mojo::PendingRemote<mojom::blink::FeatureObserver> feature_observer,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : task_runner_(std::move(task_runner)) {
-  factory_.Bind(std::move(pending_factory), task_runner_);
-  feature_observer_.Bind(std::move(feature_observer), task_runner_);
-}
-
-WebIDBFactoryImpl::~WebIDBFactoryImpl() = default;
-
-mojo::PendingRemote<mojom::blink::ObservedFeature>
-WebIDBFactoryImpl::GetObservedFeature() {
-  mojo::PendingRemote<mojom::blink::ObservedFeature> feature;
-  feature_observer_->Register(
-      feature.InitWithNewPipeAndPassReceiver(),
-      mojom::blink::ObservedFeatureType::kIndexedDBConnection);
-  return feature;
-}
-
-void WebIDBFactoryImpl::GetDatabaseInfo(
-    std::unique_ptr<WebIDBCallbacks> callbacks) {
-  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
-  factory_->GetDatabaseInfo(GetCallbacksProxy(std::move(callbacks)));
-}
-
-void WebIDBFactoryImpl::GetDatabaseNames(
-    std::unique_ptr<WebIDBCallbacks> callbacks) {
-  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
-  factory_->GetDatabaseNames(GetCallbacksProxy(std::move(callbacks)));
-}
-
-void WebIDBFactoryImpl::Open(
-    const String& name,
-    int64_t version,
-    mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-        transaction_receiver,
-    int64_t transaction_id,
-    std::unique_ptr<WebIDBCallbacks> callbacks,
-    std::unique_ptr<WebIDBDatabaseCallbacks> database_callbacks) {
-  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
-  auto database_callbacks_impl =
-      std::make_unique<IndexedDBDatabaseCallbacksImpl>(
-          std::move(database_callbacks));
-  DCHECK(!name.IsNull());
-  factory_->Open(GetCallbacksProxy(std::move(callbacks)),
-                 GetDatabaseCallbacksProxy(std::move(database_callbacks_impl)),
-                 name, version, std::move(transaction_receiver),
-                 transaction_id);
-}
-
-void WebIDBFactoryImpl::DeleteDatabase(
-    const String& name,
-    std::unique_ptr<WebIDBCallbacks> callbacks,
-    bool force_close) {
-  callbacks->SetState(nullptr, WebIDBCallbacksImpl::kNoTransaction);
-  DCHECK(!name.IsNull());
-  factory_->DeleteDatabase(GetCallbacksProxy(std::move(callbacks)), name,
-                           force_close);
-}
-
-mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks>
-WebIDBFactoryImpl::GetCallbacksProxy(
-    std::unique_ptr<WebIDBCallbacks> callbacks_impl) {
-  mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks> pending_callbacks;
-  mojo::MakeSelfOwnedAssociatedReceiver(
-      std::move(callbacks_impl),
-      pending_callbacks.InitWithNewEndpointAndPassReceiver(), task_runner_);
-  return pending_callbacks;
-}
-
-mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
-WebIDBFactoryImpl::GetDatabaseCallbacksProxy(
-    std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks) {
-  mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks> remote;
-  mojo::MakeSelfOwnedAssociatedReceiver(
-      std::move(callbacks), remote.InitWithNewEndpointAndPassReceiver(),
-      task_runner_);
-  return remote;
-}
-
-}  // namespace blink

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

-// 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.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_WEB_IDB_FACTORY_IMPL_H_
-#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 "mojo/public/cpp/bindings/pending_remote.h"
-#include "mojo/public/cpp/bindings/remote.h"
-#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom-blink-forward.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"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_callbacks.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_database_callbacks.h"
-#include "third_party/blink/renderer/modules/indexeddb/web_idb_factory.h"
-
-namespace WTF {
-class String;
-}
-
-namespace blink {
-
-class WebIDBFactoryImpl : public WebIDBFactory {
- public:
-  explicit WebIDBFactoryImpl(
-      mojo::PendingRemote<mojom::blink::IDBFactory> pending_factory,
-      mojo::PendingRemote<mojom::blink::FeatureObserver> feature_observer,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
-  ~WebIDBFactoryImpl() override;
-
-  // See web_idb_factory.h for documentation on these functions.
-  void GetDatabaseInfo(std::unique_ptr<WebIDBCallbacks> callbacks) override;
-  void GetDatabaseNames(std::unique_ptr<WebIDBCallbacks> callbacks) override;
-  void Open(
-      const WTF::String& name,
-      int64_t version,
-      mojo::PendingAssociatedReceiver<mojom::blink::IDBTransaction>
-          transaction_receiver,
-      int64_t transaction_id,
-      std::unique_ptr<WebIDBCallbacks> callbacks,
-      std::unique_ptr<WebIDBDatabaseCallbacks> database_callbacks) override;
-  void DeleteDatabase(const WTF::String& name,
-                      std::unique_ptr<WebIDBCallbacks> callbacks,
-                      bool force_close) override;
-  mojo::PendingRemote<mojom::blink::ObservedFeature> GetObservedFeature()
-      override;
-
- private:
-  mojo::PendingAssociatedRemote<mojom::blink::IDBCallbacks> GetCallbacksProxy(
-      std::unique_ptr<WebIDBCallbacks> callbacks);
-  mojo::PendingAssociatedRemote<mojom::blink::IDBDatabaseCallbacks>
-  GetDatabaseCallbacksProxy(
-      std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks);
-
-  mojo::Remote<mojom::blink::IDBFactory> factory_;
-  mojo::Remote<mojom::blink::FeatureObserver> feature_observer_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-};
-
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_INDEXEDDB_WEB_IDB_FACTORY_IMPL_H_