Upload 29 files

19/DEPS

@@ -0,0 +1,5 @@
+include_rules = [
+  "+chromeos/dbus",
+  "+mojo/core/embedder",
+  "+mojo/public",
+]

19/DIR_METADATA

@@ -0,0 +1,3 @@
+monorail {
+  component: "UI>ML>Service"
+}

19/OWNERS

@@ -0,0 +1,4 @@
+[email protected]
+[email protected]
+[email protected]
+[email protected]

19/cpp/ash/handwriting_model_loader.cc

@@ -0,0 +1,154 @@
+// Copyright 2020 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 "chromeos/services/machine_learning/cpp/ash/handwriting_model_loader.h"
+
+#include <string>
+#include <utility>
+
+#include "ash/constants/ash_switches.h"
+#include "base/callback_helpers.h"
+#include "base/command_line.h"
+#include "base/metrics/histogram_macros.h"
+#include "chromeos/services/machine_learning/public/cpp/service_connection.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace ash {
+namespace machine_learning {
+namespace {
+
+using ::chromeos::machine_learning::mojom::HandwritingRecognizerSpecPtr;
+using ::chromeos::machine_learning::mojom::LoadHandwritingModelResult;
+using HandwritingRecognizer = mojo::PendingReceiver<
+    ::chromeos::machine_learning::mojom::HandwritingRecognizer>;
+using LoadHandwritingModelCallback = ::chromeos::machine_learning::mojom::
+    MachineLearningService::LoadHandwritingModelCallback;
+
+// Records CrOSActionRecorder event.
+void RecordLoadHandwritingModelResult(const LoadHandwritingModelResult val) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "MachineLearningService.HandwritingModel.LoadModelResult.Event", val,
+      LoadHandwritingModelResult::LOAD_MODEL_FILES_ERROR);
+}
+
+constexpr char kLibHandwritingDlcId[] = "libhandwriting";
+// A list of supported language code.
+constexpr char kLanguageCodeEn[] = "en";
+constexpr char kLanguageCodeGesture[] = "gesture_in_context";
+
+// Returns whether the `value` is set for command line switch
+// kOndeviceHandwritingSwitch.
+bool HandwritingSwitchHasValue(const std::string& value) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  return command_line->HasSwitch(ash::switches::kOndeviceHandwritingSwitch) &&
+         command_line->GetSwitchValueASCII(
+             ash::switches::kOndeviceHandwritingSwitch) == value;
+}
+
+// Returns true if switch kOndeviceHandwritingSwitch is set to use_rootfs.
+bool IsLibHandwritingRootfsEnabled() {
+  return HandwritingSwitchHasValue("use_rootfs");
+}
+
+// Returns true if switch kOndeviceHandwritingSwitch is set to use_dlc.
+bool IsLibHandwritingDlcEnabled() {
+  return HandwritingSwitchHasValue("use_dlc");
+}
+
+// Called when InstallDlc completes.
+// Returns an error if the `result.error` is not dlcservice::kErrorNone.
+// Calls mlservice to LoadHandwritingModel otherwise.
+void OnInstallDlcComplete(
+    HandwritingRecognizerSpecPtr spec,
+    HandwritingRecognizer receiver,
+    LoadHandwritingModelCallback callback,
+    const chromeos::DlcserviceClient::InstallResult& result) {
+  // Call LoadHandwritingModelWithSpec if no error was found.
+  if (result.error == dlcservice::kErrorNone) {
+    chromeos::machine_learning::ServiceConnection::GetInstance()
+        ->GetMachineLearningService()
+        .LoadHandwritingModel(std::move(spec), std::move(receiver),
+                              std::move(callback));
+    return;
+  }
+
+  RecordLoadHandwritingModelResult(
+      LoadHandwritingModelResult::DLC_INSTALL_ERROR);
+  std::move(callback).Run(LoadHandwritingModelResult::DLC_INSTALL_ERROR);
+}
+
+// Called when the existing-dlc-list is returned.
+// Returns an error if libhandwriting is not in the existing-dlc-list.
+// Calls InstallDlc otherwise.
+void OnGetExistingDlcsComplete(
+    HandwritingRecognizerSpecPtr spec,
+    HandwritingRecognizer receiver,
+    LoadHandwritingModelCallback callback,
+    chromeos::DlcserviceClient* const dlc_client,
+    const std::string& err,
+    const dlcservice::DlcsWithContent& dlcs_with_content) {
+  // Loop over dlcs_with_content, and installs libhandwriting if already exists.
+  // Since we don't want to trigger downloading here, we only install(mount)
+  // the handwriting dlc if it is already on device.
+  for (const auto& dlc_info : dlcs_with_content.dlc_infos()) {
+    if (dlc_info.id() == kLibHandwritingDlcId) {
+      dlc_client->Install(
+          kLibHandwritingDlcId,
+          base::BindOnce(&OnInstallDlcComplete, std::move(spec),
+                         std::move(receiver), std::move(callback)),
+          base::DoNothing());
+      return;
+    }
+  }
+
+  // Returns error if the handwriting dlc is not on the device.
+  RecordLoadHandwritingModelResult(
+      LoadHandwritingModelResult::DLC_DOES_NOT_EXIST);
+  std::move(callback).Run(LoadHandwritingModelResult::DLC_DOES_NOT_EXIST);
+}
+
+}  // namespace
+
+void LoadHandwritingModelFromRootfsOrDlc(
+    HandwritingRecognizerSpecPtr spec,
+    HandwritingRecognizer receiver,
+    LoadHandwritingModelCallback callback,
+    chromeos::DlcserviceClient* const dlc_client) {
+  // Returns FEATURE_NOT_SUPPORTED_ERROR if both rootfs and dlc are not enabled.
+  if (!IsLibHandwritingRootfsEnabled() && !IsLibHandwritingDlcEnabled()) {
+    RecordLoadHandwritingModelResult(
+        LoadHandwritingModelResult::FEATURE_NOT_SUPPORTED_ERROR);
+    std::move(callback).Run(
+        LoadHandwritingModelResult::FEATURE_NOT_SUPPORTED_ERROR);
+    return;
+  }
+
+  // Returns LANGUAGE_NOT_SUPPORTED_ERROR if the language is not supported yet.
+  if (spec->language != kLanguageCodeEn &&
+      spec->language != kLanguageCodeGesture) {
+    RecordLoadHandwritingModelResult(
+        LoadHandwritingModelResult::LANGUAGE_NOT_SUPPORTED_ERROR);
+    std::move(callback).Run(
+        LoadHandwritingModelResult::LANGUAGE_NOT_SUPPORTED_ERROR);
+    return;
+  }
+
+  // Load from rootfs if enabled.
+  if (IsLibHandwritingRootfsEnabled()) {
+    chromeos::machine_learning::ServiceConnection::GetInstance()
+        ->GetMachineLearningService()
+        .LoadHandwritingModel(std::move(spec), std::move(receiver),
+                              std::move(callback));
+    return;
+  }
+
+  // Gets existing dlc list and based on the presence of libhandwriting
+  // either returns an error or installs the libhandwriting dlc.
+  dlc_client->GetExistingDlcs(
+      base::BindOnce(&OnGetExistingDlcsComplete, std::move(spec),
+                     std::move(receiver), std::move(callback), dlc_client));
+}
+
+}  // namespace machine_learning
+}  // namespace ash

19/cpp/ash/handwriting_model_loader.h

@@ -0,0 +1,47 @@
+// Copyright 2020 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 CHROMEOS_SERVICES_MACHINE_LEARNING_CPP_ASH_HANDWRITING_MODEL_LOADER_H_
+#define CHROMEOS_SERVICES_MACHINE_LEARNING_CPP_ASH_HANDWRITING_MODEL_LOADER_H_
+
+#include "chromeos/dbus/dlcservice/dlcservice_client.h"
+#include "chromeos/services/machine_learning/public/mojom/handwriting_recognizer.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/machine_learning_service.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+
+namespace ash {
+namespace machine_learning {
+
+// Helper function decides either to load handwriting model from rootfs or dlc.
+// New Handwriting clients should call this helper instead of calling
+// ServiceConnection::GetInstance()->LoadHandwritingModel.
+// Three typical examples of the callstack are:
+// Case 1: handwriting in enabled on rootfs.
+//   client calls LoadHandwritingModelFromRootfsOrDlc("en", receiver, callback)
+//   which calls LoadHandwritingModel -> handwriting model loaded from rootfs.
+// Case 2: handwriting is enabled for dlc and dlc is already on the device.
+//   client calls LoadHandwritingModelFromRootfsOrDlc("en", receiver, callback)
+//   which calls -> GetExistingDlcs -> libhandwriting dlc already exists
+//               -> InstallDlc -> LoadHandwritingModel
+//   The correct handwriting model will be loaded and bond to the receiver.
+// Case 3: handwriting is enabled for dlc and dlc is not on the device yet.
+//   client calls LoadHandwritingModelFromRootfsOrDlc("en", receiver, callback)
+//   which calls -> GetExistingDlcs -> NO libhandwriting dlc exists
+//               -> Return error DLC_NOT_EXISTED.
+//   Then it will be the client's duty to install the dlc and then calls
+//   LoadHandwritingModelFromRootfsOrDlc("en", receiver, callback) again.
+//
+//  `dlc_client` should only be replaced with non-default value in unit tests.
+void LoadHandwritingModelFromRootfsOrDlc(
+    chromeos::machine_learning::mojom::HandwritingRecognizerSpecPtr spec,
+    mojo::PendingReceiver<
+        chromeos::machine_learning::mojom::HandwritingRecognizer> receiver,
+    chromeos::machine_learning::mojom::MachineLearningService::
+        LoadHandwritingModelCallback callback,
+    chromeos::DlcserviceClient* dlc_client = chromeos::DlcserviceClient::Get());
+
+}  // namespace machine_learning
+}  // namespace ash
+
+#endif  // CHROMEOS_SERVICES_MACHINE_LEARNING_CPP_ASH_HANDWRITING_MODEL_LOADER_H_

19/cpp/ash/handwriting_model_loader_unittest.cc

@@ -0,0 +1,154 @@
+// Copyright 2020 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 "chromeos/services/machine_learning/cpp/ash/handwriting_model_loader.h"
+
+#include <string>
+
+#include "ash/constants/ash_switches.h"
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/run_loop.h"
+#include "base/test/scoped_command_line.h"
+#include "base/test/task_environment.h"
+#include "chromeos/dbus/dlcservice/fake_dlcservice_client.h"
+#include "chromeos/services/machine_learning/public/cpp/fake_service_connection.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace ash {
+namespace machine_learning {
+
+using ::base::test::ScopedCommandLine;
+using ::base::test::TaskEnvironment;
+using ::chromeos::machine_learning::mojom::LoadHandwritingModelResult;
+
+constexpr char kLibHandwritingDlcId[] = "libhandwriting";
+
+class HandwritingModelLoaderTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    chromeos::machine_learning::ServiceConnection::
+        UseFakeServiceConnectionForTesting(&fake_service_connection_);
+    chromeos::machine_learning::ServiceConnection::GetInstance()->Initialize();
+    result_ = LoadHandwritingModelResult::DEPRECATED_MODEL_SPEC_ERROR;
+    language_ = "en";
+  }
+
+  // Callback that called when loader_->Load() is over to save the returned
+  // result.
+  void OnHandwritingModelLoaderComplete(
+      const LoadHandwritingModelResult result) {
+    result_ = result;
+  }
+
+  // Runs loader_->Load() and check the returned result as expected.
+  void ExpectLoadHandwritingModelResult(
+      const LoadHandwritingModelResult expected_result) {
+    LoadHandwritingModelFromRootfsOrDlc(
+        chromeos::machine_learning::mojom::HandwritingRecognizerSpec::New(
+            language_),
+        recognizer_.BindNewPipeAndPassReceiver(),
+        base::BindOnce(
+            &HandwritingModelLoaderTest::OnHandwritingModelLoaderComplete,
+            base::Unretained(this)),
+        &fake_client_);
+
+    base::RunLoop().RunUntilIdle();
+    EXPECT_EQ(result_, expected_result);
+  }
+
+  void SetLanguage(const std::string& language) { language_ = language; }
+
+  // Creates a dlc list with one dlc inside.
+  void AddDlcsWithContent(const std::string& dlc_id) {
+    dlcservice::DlcsWithContent dlcs_with_content;
+    dlcs_with_content.add_dlc_infos()->set_id(dlc_id);
+    fake_client_.set_dlcs_with_content(dlcs_with_content);
+  }
+
+  // Sets InstallDlc error.
+  void SetInstallError(const std::string& error) {
+    fake_client_.set_install_error(error);
+    fake_client_.set_install_root_path("/any-path");
+  }
+
+  // Sets "ondevice_handwriting" value.
+  void SetSwitchValue(const std::string& switch_value) {
+    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+        ash::switches::kOndeviceHandwritingSwitch, switch_value);
+  }
+
+ private:
+  TaskEnvironment task_environment_{
+      TaskEnvironment::MainThreadType::DEFAULT,
+      TaskEnvironment::ThreadPoolExecutionMode::QUEUED};
+  ScopedCommandLine scoped_command_line_;
+  chromeos::FakeDlcserviceClient fake_client_;
+  chromeos::machine_learning::FakeServiceConnectionImpl
+      fake_service_connection_;
+  LoadHandwritingModelResult result_;
+  std::string language_;
+  mojo::Remote<chromeos::machine_learning::mojom::HandwritingRecognizer>
+      recognizer_;
+};
+
+TEST_F(HandwritingModelLoaderTest, HandwritingNotEnabled) {
+  SetSwitchValue("random_string");
+
+  // Random switch value should return FEATURE_NOT_SUPPORTED_ERROR.
+  ExpectLoadHandwritingModelResult(
+      LoadHandwritingModelResult::FEATURE_NOT_SUPPORTED_ERROR);
+}
+
+TEST_F(HandwritingModelLoaderTest, LoadingWithInvalidLanguage) {
+  SetSwitchValue("use_rootfs");
+
+  SetLanguage("random string as language");
+
+  // Random language code should return LANGUAGE_NOT_SUPPORTED_ERROR.
+  ExpectLoadHandwritingModelResult(
+      LoadHandwritingModelResult::LANGUAGE_NOT_SUPPORTED_ERROR);
+}
+
+TEST_F(HandwritingModelLoaderTest, LoadingWithUseRootfs) {
+  SetSwitchValue("use_rootfs");
+
+  // Load from rootfs should return success.
+  ExpectLoadHandwritingModelResult(LoadHandwritingModelResult::OK);
+}
+
+TEST_F(HandwritingModelLoaderTest, LoadingWithoutDlcOnDevice) {
+  SetSwitchValue("use_dlc");
+
+  AddDlcsWithContent("random dlc-id");
+
+  // Random dlc id should return DLC_DOES_NOT_EXIST.
+  ExpectLoadHandwritingModelResult(
+      LoadHandwritingModelResult::DLC_DOES_NOT_EXIST);
+}
+
+TEST_F(HandwritingModelLoaderTest, DlcInstalledWithError) {
+  SetSwitchValue("use_dlc");
+
+  AddDlcsWithContent(kLibHandwritingDlcId);
+  SetInstallError("random error");
+
+  // InstallDlc error should return DLC_INSTALL_ERROR.
+  ExpectLoadHandwritingModelResult(
+      LoadHandwritingModelResult::DLC_INSTALL_ERROR);
+}
+
+TEST_F(HandwritingModelLoaderTest, DlcInstalledWithoutError) {
+  SetSwitchValue("use_dlc");
+
+  AddDlcsWithContent(kLibHandwritingDlcId);
+  SetInstallError(dlcservice::kErrorNone);
+
+  // InstallDlc without an error should return success.
+  ExpectLoadHandwritingModelResult(LoadHandwritingModelResult::OK);
+}
+
+}  // namespace machine_learning
+}  // namespace ash

19/cpp/ash/service_connection_ash.cc

@@ -0,0 +1,169 @@
+// Copyright 2021 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 "chromeos/services/machine_learning/public/cpp/service_connection.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/component_export.h"
+#include "base/no_destructor.h"
+#include "base/sequence_checker.h"
+#include "base/task/sequenced_task_runner.h"
+#include "chromeos/dbus/machine_learning/machine_learning_client.h"
+#include "chromeos/services/machine_learning/public/mojom/machine_learning_service.mojom.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "mojo/public/cpp/platform/platform_channel.h"
+#include "mojo/public/cpp/system/invitation.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace ash {
+namespace machine_learning {
+
+namespace {
+
+// Real Impl of ServiceConnection
+class COMPONENT_EXPORT(CHROMEOS_MLSERVICE) ServiceConnectionAsh
+    : public chromeos::machine_learning::ServiceConnection {
+ public:
+  ServiceConnectionAsh();
+  ServiceConnectionAsh(const ServiceConnectionAsh&) = delete;
+  ServiceConnectionAsh& operator=(const ServiceConnectionAsh&) = delete;
+
+  ~ServiceConnectionAsh() override;
+
+  chromeos::machine_learning::mojom::MachineLearningService&
+  GetMachineLearningService() override;
+
+  void BindMachineLearningService(
+      mojo::PendingReceiver<
+          chromeos::machine_learning::mojom::MachineLearningService> receiver)
+      override;
+
+  void Initialize() override;
+
+ private:
+  // Binds the primordial, top-level interface |machine_learning_service_| to an
+  // implementation in the ML Service daemon, if it is not already bound. The
+  // binding is accomplished via D-Bus bootstrap.
+  void BindPrimordialMachineLearningServiceIfNeeded();
+
+  // Mojo disconnect handler. Resets |machine_learning_service_|, which
+  // will be reconnected upon next use.
+  void OnMojoDisconnect();
+
+  // Response callback for MlClient::BootstrapMojoConnection.
+  void OnBootstrapMojoConnectionResponse(bool success);
+
+  mojo::Remote<chromeos::machine_learning::mojom::MachineLearningService>
+      machine_learning_service_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+};
+
+ServiceConnectionAsh::ServiceConnectionAsh() {
+  DETACH_FROM_SEQUENCE(sequence_checker_);
+}
+
+ServiceConnectionAsh::~ServiceConnectionAsh() = default;
+
+chromeos::machine_learning::mojom::MachineLearningService&
+ServiceConnectionAsh::GetMachineLearningService() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(task_runner_)
+      << "Call Initialize before first use of ServiceConnection.";
+  BindPrimordialMachineLearningServiceIfNeeded();
+  return *machine_learning_service_.get();
+}
+
+void ServiceConnectionAsh::BindMachineLearningService(
+    mojo::PendingReceiver<
+        chromeos::machine_learning::mojom::MachineLearningService> receiver) {
+  DCHECK(task_runner_)
+      << "Call Initialize before first use of ServiceConnection.";
+  if (!task_runner_->RunsTasksInCurrentSequence()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&ServiceConnectionAsh::BindMachineLearningService,
+                       base::Unretained(this), std::move(receiver)));
+    return;
+  }
+
+  GetMachineLearningService().Clone(std::move(receiver));
+}
+
+void ServiceConnectionAsh::Initialize() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(!task_runner_) << "Initialize must be called only once.";
+
+  task_runner_ = base::SequencedTaskRunnerHandle::Get();
+}
+
+void ServiceConnectionAsh::BindPrimordialMachineLearningServiceIfNeeded() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (machine_learning_service_) {
+    return;
+  }
+
+  mojo::PlatformChannel platform_channel;
+
+  // Prepare a Mojo invitation to send through |platform_channel|.
+  mojo::OutgoingInvitation invitation;
+  // Include an initial Mojo pipe in the invitation.
+  mojo::ScopedMessagePipeHandle pipe =
+      invitation.AttachMessagePipe(ml::kBootstrapMojoConnectionChannelToken);
+  mojo::OutgoingInvitation::Send(std::move(invitation),
+                                 base::kNullProcessHandle,
+                                 platform_channel.TakeLocalEndpoint());
+
+  // Bind our end of |pipe| to our mojo::Remote<MachineLearningService>. The
+  // daemon should bind its end to a MachineLearningService implementation.
+  machine_learning_service_.Bind(
+      mojo::PendingRemote<
+          chromeos::machine_learning::mojom::MachineLearningService>(
+          std::move(pipe), 0u /* version */));
+  machine_learning_service_.set_disconnect_handler(base::BindOnce(
+      &ServiceConnectionAsh::OnMojoDisconnect, base::Unretained(this)));
+
+  // Send the file descriptor for the other end of |platform_channel| to the
+  // ML service daemon over D-Bus.
+  chromeos::MachineLearningClient::Get()->BootstrapMojoConnection(
+      platform_channel.TakeRemoteEndpoint().TakePlatformHandle().TakeFD(),
+      base::BindOnce(&ServiceConnectionAsh::OnBootstrapMojoConnectionResponse,
+                     base::Unretained(this)));
+}
+
+void ServiceConnectionAsh::OnMojoDisconnect() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  // Connection errors are not expected so log a warning.
+  LOG(WARNING) << "ML Service Mojo connection closed";
+  machine_learning_service_.reset();
+}
+
+void ServiceConnectionAsh::OnBootstrapMojoConnectionResponse(
+    const bool success) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (!success) {
+    LOG(WARNING) << "BootstrapMojoConnection D-Bus call failed";
+    machine_learning_service_.reset();
+  }
+}
+
+}  // namespace
+
+}  // namespace machine_learning
+}  // namespace ash
+
+namespace chromeos {
+namespace machine_learning {
+
+ServiceConnection* ServiceConnection::CreateRealInstance() {
+  static base::NoDestructor<ash::machine_learning::ServiceConnectionAsh>
+      service_connection;
+  return service_connection.get();
+}
+
+}  // namespace machine_learning
+}  // namespace chromeos

19/cpp/lacros/service_connection_lacros.cc

@@ -0,0 +1,78 @@
+// Copyright 2021 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 "chromeos/services/machine_learning/public/cpp/service_connection.h"
+
+#include <utility>
+
+#include "base/component_export.h"
+#include "base/no_destructor.h"
+#include "chromeos/lacros/lacros_service.h"
+#include "chromeos/services/machine_learning/public/mojom/machine_learning_service.mojom.h"
+#include "mojo/public/cpp/bindings/remote.h"
+
+namespace lacros {
+namespace machine_learning {
+namespace {
+
+// Real Impl of ServiceConnection
+class COMPONENT_EXPORT(CHROMEOS_MLSERVICE) ServiceConnectionLacros
+    : public chromeos::machine_learning::ServiceConnection {
+ public:
+  ServiceConnectionLacros();
+  ServiceConnectionLacros(const ServiceConnectionLacros&) = delete;
+  ServiceConnectionLacros& operator=(const ServiceConnectionLacros&) = delete;
+
+  ~ServiceConnectionLacros() override;
+
+  chromeos::machine_learning::mojom::MachineLearningService&
+  GetMachineLearningService() override;
+
+  void BindMachineLearningService(
+      mojo::PendingReceiver<
+          chromeos::machine_learning::mojom::MachineLearningService> receiver)
+      override;
+
+  void Initialize() override;
+};
+
+ServiceConnectionLacros::ServiceConnectionLacros() = default;
+
+ServiceConnectionLacros::~ServiceConnectionLacros() = default;
+
+chromeos::machine_learning::mojom::MachineLearningService&
+ServiceConnectionLacros::GetMachineLearningService() {
+  mojo::Remote<chromeos::machine_learning::mojom::MachineLearningService>&
+      machine_learning_service_remote =
+          chromeos::LacrosService::Get()
+              ->GetRemote<
+                  chromeos::machine_learning::mojom::MachineLearningService>();
+  return *machine_learning_service_remote.get();
+}
+
+void ServiceConnectionLacros::BindMachineLearningService(
+    mojo::PendingReceiver<
+        chromeos::machine_learning::mojom::MachineLearningService> receiver) {
+  chromeos::LacrosService::Get()->BindMachineLearningService(
+      std::move(receiver));
+}
+
+void ServiceConnectionLacros::Initialize() {}
+
+}  // namespace
+
+}  // namespace machine_learning
+}  // namespace lacros
+
+namespace chromeos {
+namespace machine_learning {
+
+ServiceConnection* ServiceConnection::CreateRealInstance() {
+  static base::NoDestructor<lacros::machine_learning::ServiceConnectionLacros>
+      service_connection;
+  return service_connection.get();
+}
+
+}  // namespace machine_learning
+}  // namespace chromeos

19/public/cpp/BUILD.gn

@@ -0,0 +1,84 @@
+# 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.
+
+import("//build/config/chromeos/ui_mode.gni")
+
+assert(is_chromeos, "Non-ChromeOS builds cannot depend on //chromeos")
+
+source_set("cpp") {
+  sources = [
+    "service_connection.cc",
+    "service_connection.h",
+  ]
+  defines = [ "IS_CHROMEOS_MLSERVICE_IMPL" ]
+  deps = [
+    "//base",
+    "//chromeos/services/machine_learning/public/mojom",
+  ]
+
+  if (is_chromeos_ash) {
+    sources += [
+      "../../cpp/ash/handwriting_model_loader.cc",
+      "../../cpp/ash/handwriting_model_loader.h",
+      "../../cpp/ash/service_connection_ash.cc",
+    ]
+    deps += [
+      "//ash/constants:constants",
+      "//chromeos/dbus/dlcservice",
+      "//chromeos/dbus/dlcservice:dlcservice_proto",
+      "//chromeos/dbus/machine_learning",
+    ]
+  } else if (is_chromeos_lacros) {
+    sources += [ "../../cpp/lacros/service_connection_lacros.cc" ]
+    deps += [
+      "//chromeos/lacros",
+      "//mojo/public/cpp/bindings",
+      "//skia",
+    ]
+  }
+}
+
+component("stub") {
+  sources = [
+    "fake_service_connection.cc",
+    "fake_service_connection.h",
+  ]
+  defines = [ "IS_CHROMEOS_MLSERVICE_IMPL" ]
+  deps = [
+    "//base",
+    "//chromeos/services/machine_learning/public/mojom",
+    "//mojo/public/cpp/bindings",
+  ]
+  public_deps = [ ":cpp" ]
+}
+
+source_set("unit_tests") {
+  testonly = true
+  sources = [ "service_connection_unittest.cc" ]
+  deps = [
+    ":cpp",
+    ":stub",
+    "//base/test:test_support",
+    "//chromeos/dbus/machine_learning",
+    "//chromeos/services/machine_learning/public/mojom",
+    "//mojo/core/embedder",
+    "//mojo/public/cpp/bindings",
+    "//testing/gtest",
+  ]
+}
+
+if (is_chromeos_ash) {
+  source_set("ash_unit_tests") {
+    sources = [ "../../cpp/ash/handwriting_model_loader_unittest.cc" ]
+    testonly = true
+    deps = [
+      ":cpp",
+      "//ash/constants:constants",
+      "//base/test:test_support",
+      "//chromeos/dbus/dlcservice",
+      "//chromeos/services/machine_learning/public/cpp:stub",
+      "//testing/gtest",
+    ]
+  }
+}

19/public/cpp/fake_service_connection.cc

@@ -0,0 +1,574 @@
+// Copyright 2019 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 "chromeos/services/machine_learning/public/cpp/fake_service_connection.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/notreached.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+
+namespace chromeos {
+namespace machine_learning {
+
+FakeServiceConnectionImpl::FakeServiceConnectionImpl()
+    : output_tensor_(mojom::Tensor::New()),
+      load_handwriting_model_result_(mojom::LoadHandwritingModelResult::OK),
+      load_web_platform_handwriting_model_result_(
+          mojom::LoadHandwritingModelResult::OK),
+      load_model_result_(mojom::LoadModelResult::OK),
+      load_text_classifier_result_(mojom::LoadModelResult::OK),
+      load_soda_result_(mojom::LoadModelResult::OK),
+      create_graph_executor_result_(mojom::CreateGraphExecutorResult::OK),
+      execute_result_(mojom::ExecuteResult::OK),
+      async_mode_(false) {}
+
+FakeServiceConnectionImpl::~FakeServiceConnectionImpl() {}
+
+mojom::MachineLearningService&
+FakeServiceConnectionImpl::GetMachineLearningService() {
+  DCHECK(machine_learning_service_)
+      << "Call Initialize() before GetMachineLearningService()";
+  return *machine_learning_service_.get();
+}
+
+void FakeServiceConnectionImpl::BindMachineLearningService(
+    mojo::PendingReceiver<mojom::MachineLearningService> receiver) {
+  DCHECK(machine_learning_service_)
+      << "Call Initialize() before BindMachineLearningService()";
+  machine_learning_service_->Clone(std::move(receiver));
+}
+
+void FakeServiceConnectionImpl::Clone(
+    mojo::PendingReceiver<mojom::MachineLearningService> receiver) {
+  clone_ml_service_receivers_.Add(this, std::move(receiver));
+}
+
+void FakeServiceConnectionImpl::Initialize() {
+  clone_ml_service_receivers_.Add(
+      this, machine_learning_service_.BindNewPipeAndPassReceiver());
+}
+
+void FakeServiceConnectionImpl::LoadBuiltinModel(
+    mojom::BuiltinModelSpecPtr spec,
+    mojo::PendingReceiver<mojom::Model> receiver,
+    mojom::MachineLearningService::LoadBuiltinModelCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadBuiltinModelCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadFlatBufferModel(
+    mojom::FlatBufferModelSpecPtr spec,
+    mojo::PendingReceiver<mojom::Model> receiver,
+    mojom::MachineLearningService::LoadFlatBufferModelCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadFlatBufferModelCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::REMOVED_0(
+    mojo::PendingReceiver<mojom::GraphExecutor> receiver,
+    mojom::Model::REMOVED_0Callback callback) {
+  NOTIMPLEMENTED();
+}
+
+void FakeServiceConnectionImpl::REMOVED_4(
+    mojom::HandwritingRecognizerSpecPtr spec,
+    mojo::PendingReceiver<mojom::HandwritingRecognizer> receiver,
+    mojom::MachineLearningService::REMOVED_4Callback callback) {
+  NOTIMPLEMENTED();
+}
+
+void FakeServiceConnectionImpl::CreateGraphExecutor(
+    mojom::GraphExecutorOptionsPtr options,
+    mojo::PendingReceiver<mojom::GraphExecutor> receiver,
+    mojom::Model::CreateGraphExecutorCallback callback) {
+  ScheduleCall(
+      base::BindOnce(&FakeServiceConnectionImpl::HandleCreateGraphExecutorCall,
+                     base::Unretained(this), std::move(options),
+                     std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadTextClassifier(
+    mojo::PendingReceiver<mojom::TextClassifier> receiver,
+    mojom::MachineLearningService::LoadTextClassifierCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadTextClassifierCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadHandwritingModel(
+    mojom::HandwritingRecognizerSpecPtr spec,
+    mojo::PendingReceiver<mojom::HandwritingRecognizer> receiver,
+    mojom::MachineLearningService::LoadHandwritingModelCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadHandwritingModelCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::HandleLoadWebPlatformHandwritingModelCall(
+    mojo::PendingReceiver<web_platform::mojom::HandwritingRecognizer> receiver,
+    mojom::MachineLearningService::LoadHandwritingModelCallback callback) {
+  if (load_handwriting_model_result_ == mojom::LoadHandwritingModelResult::OK)
+    web_platform_handwriting_receivers_.Add(this, std::move(receiver));
+  std::move(callback).Run(load_web_platform_handwriting_model_result_);
+}
+
+void FakeServiceConnectionImpl::LoadWebPlatformHandwritingModel(
+    web_platform::mojom::HandwritingModelConstraintPtr constraint,
+    mojo::PendingReceiver<web_platform::mojom::HandwritingRecognizer> receiver,
+    mojom::MachineLearningService::LoadWebPlatformHandwritingModelCallback
+        callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadWebPlatformHandwritingModelCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadGrammarChecker(
+    mojo::PendingReceiver<mojom::GrammarChecker> receiver,
+    mojom::MachineLearningService::LoadGrammarCheckerCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadGrammarCheckerCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadSpeechRecognizer(
+    mojom::SodaConfigPtr soda_config,
+    mojo::PendingRemote<mojom::SodaClient> soda_client,
+    mojo::PendingReceiver<mojom::SodaRecognizer> soda_recognizer,
+    mojom::MachineLearningService::LoadSpeechRecognizerCallback callback) {
+  ScheduleCall(
+      base::BindOnce(&FakeServiceConnectionImpl::HandleLoadSpeechRecognizerCall,
+                     base::Unretained(this), std::move(soda_client),
+                     std::move(soda_recognizer), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadTextSuggester(
+    mojo::PendingReceiver<mojom::TextSuggester> receiver,
+    mojom::TextSuggesterSpecPtr spec,
+    mojom::MachineLearningService::LoadTextSuggesterCallback callback) {
+  ScheduleCall(
+      base::BindOnce(&FakeServiceConnectionImpl::HandleLoadTextSuggesterCall,
+                     base::Unretained(this), std::move(receiver),
+                     std::move(spec), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::LoadDocumentScanner(
+    mojo::PendingReceiver<mojom::DocumentScanner> receiver,
+    mojom::MachineLearningService::LoadDocumentScannerCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleLoadDocumentScannerCall,
+      base::Unretained(this), std::move(receiver), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::Execute(
+    base::flat_map<std::string, mojom::TensorPtr> inputs,
+    const std::vector<std::string>& output_names,
+    mojom::GraphExecutor::ExecuteCallback callback) {
+  ScheduleCall(base::BindOnce(&FakeServiceConnectionImpl::HandleExecuteCall,
+                              base::Unretained(this), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::SetLoadModelFailure() {
+  load_model_result_ = mojom::LoadModelResult::LOAD_MODEL_ERROR;
+}
+
+void FakeServiceConnectionImpl::SetCreateGraphExecutorFailure() {
+  load_model_result_ = mojom::LoadModelResult::OK;
+  create_graph_executor_result_ =
+      mojom::CreateGraphExecutorResult::MODEL_INTERPRETATION_ERROR;
+}
+
+void FakeServiceConnectionImpl::SetExecuteFailure() {
+  load_model_result_ = mojom::LoadModelResult::OK;
+  create_graph_executor_result_ = mojom::CreateGraphExecutorResult::OK;
+  execute_result_ = mojom::ExecuteResult::EXECUTION_ERROR;
+}
+
+void FakeServiceConnectionImpl::SetExecuteSuccess() {
+  load_model_result_ = mojom::LoadModelResult::OK;
+  create_graph_executor_result_ = mojom::CreateGraphExecutorResult::OK;
+  execute_result_ = mojom::ExecuteResult::OK;
+}
+
+void FakeServiceConnectionImpl::SetTextClassifierSuccess() {
+  load_text_classifier_result_ = mojom::LoadModelResult::OK;
+}
+
+void FakeServiceConnectionImpl::SetLoadTextClassifierFailure() {
+  load_text_classifier_result_ = mojom::LoadModelResult::LOAD_MODEL_ERROR;
+}
+
+void FakeServiceConnectionImpl::SetOutputValue(
+    const std::vector<int64_t>& shape,
+    const std::vector<double>& value) {
+  output_tensor_->shape = mojom::Int64List::New();
+  output_tensor_->shape->value = shape;
+  output_tensor_->data = mojom::ValueList::New();
+  output_tensor_->data->set_float_list(mojom::FloatList::New());
+  output_tensor_->data->get_float_list()->value = value;
+}
+
+void FakeServiceConnectionImpl::SetAsyncMode(bool async_mode) {
+  async_mode_ = async_mode;
+}
+
+void FakeServiceConnectionImpl::RunPendingCalls() {
+  for (auto& call : pending_calls_) {
+    std::move(call).Run();
+  }
+
+  pending_calls_.clear();
+}
+
+void FakeServiceConnectionImpl::FlushForTesting() {
+  clone_ml_service_receivers_.FlushForTesting();
+  machine_learning_service_.FlushForTesting();
+  model_receivers_.FlushForTesting();
+  graph_receivers_.FlushForTesting();
+  text_classifier_receivers_.FlushForTesting();
+  handwriting_receivers_.FlushForTesting();
+  web_platform_handwriting_receivers_.FlushForTesting();
+  grammar_checker_receivers_.FlushForTesting();
+  soda_recognizer_receivers_.FlushForTesting();
+  text_suggester_receivers_.FlushForTesting();
+  document_scanner_receivers_.FlushForTesting();
+  soda_client_remotes_.FlushForTesting();
+}
+
+void FakeServiceConnectionImpl::HandleLoadBuiltinModelCall(
+    mojo::PendingReceiver<mojom::Model> receiver,
+    mojom::MachineLearningService::LoadBuiltinModelCallback callback) {
+  if (load_model_result_ == mojom::LoadModelResult::OK)
+    model_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(load_model_result_);
+}
+
+void FakeServiceConnectionImpl::HandleLoadTextClassifierCall(
+    mojo::PendingReceiver<mojom::TextClassifier> receiver,
+    mojom::MachineLearningService::LoadTextClassifierCallback callback) {
+  if (load_text_classifier_result_ == mojom::LoadModelResult::OK)
+    text_classifier_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(load_text_classifier_result_);
+}
+
+void FakeServiceConnectionImpl::ScheduleCall(base::OnceClosure call) {
+  if (async_mode_)
+    pending_calls_.push_back(std::move(call));
+  else
+    std::move(call).Run();
+}
+
+void FakeServiceConnectionImpl::HandleLoadFlatBufferModelCall(
+    mojo::PendingReceiver<mojom::Model> receiver,
+    mojom::MachineLearningService::LoadFlatBufferModelCallback callback) {
+  if (load_model_result_ == mojom::LoadModelResult::OK)
+    model_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(load_model_result_);
+}
+
+void FakeServiceConnectionImpl::HandleCreateGraphExecutorCall(
+    mojom::GraphExecutorOptionsPtr options,
+    mojo::PendingReceiver<mojom::GraphExecutor> receiver,
+    mojom::Model::CreateGraphExecutorCallback callback) {
+  if (create_graph_executor_result_ == mojom::CreateGraphExecutorResult::OK)
+    graph_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(create_graph_executor_result_);
+}
+
+void FakeServiceConnectionImpl::HandleExecuteCall(
+    mojom::GraphExecutor::ExecuteCallback callback) {
+  if (execute_result_ != mojom::ExecuteResult::OK) {
+    std::move(callback).Run(execute_result_, absl::nullopt);
+    return;
+  }
+
+  std::vector<mojom::TensorPtr> output_tensors;
+  output_tensors.push_back(output_tensor_.Clone());
+  std::move(callback).Run(execute_result_, std::move(output_tensors));
+}
+
+void FakeServiceConnectionImpl::HandleAnnotateCall(
+    mojom::TextAnnotationRequestPtr request,
+    mojom::TextClassifier::AnnotateCallback callback) {
+  std::vector<mojom::TextAnnotationPtr> annotations;
+  for (auto const& annotate : annotate_result_) {
+    annotations.emplace_back(annotate.Clone());
+  }
+  std::move(callback).Run(std::move(annotations));
+}
+
+void FakeServiceConnectionImpl::HandleFindLanguagesCall(
+    std::string request,
+    mojom::TextClassifier::FindLanguagesCallback callback) {
+  std::vector<mojom::TextLanguagePtr> languages;
+  for (auto const& language : find_languages_result_) {
+    languages.emplace_back(language.Clone());
+  }
+  std::move(callback).Run(std::move(languages));
+}
+
+void FakeServiceConnectionImpl::SetOutputAnnotation(
+    const std::vector<mojom::TextAnnotationPtr>& annotations) {
+  annotate_result_.clear();
+  for (auto const& annotate : annotations) {
+    annotate_result_.emplace_back(annotate.Clone());
+  }
+}
+
+void FakeServiceConnectionImpl::SetOutputLanguages(
+    const std::vector<mojom::TextLanguagePtr>& languages) {
+  find_languages_result_.clear();
+  for (auto const& language : languages) {
+    find_languages_result_.emplace_back(language.Clone());
+  }
+}
+
+void FakeServiceConnectionImpl::SetOutputHandwritingRecognizerResult(
+    const mojom::HandwritingRecognizerResultPtr& result) {
+  handwriting_result_ = result.Clone();
+}
+
+void FakeServiceConnectionImpl::SetOutputWebPlatformHandwritingRecognizerResult(
+    const std::vector<web_platform::mojom::HandwritingPredictionPtr>&
+        predictions) {
+  web_platform_handwriting_result_.clear();
+  for (auto const& prediction : predictions) {
+    web_platform_handwriting_result_.emplace_back(prediction.Clone());
+  }
+}
+
+void FakeServiceConnectionImpl::SetOutputGrammarCheckerResult(
+    const mojom::GrammarCheckerResultPtr& result) {
+  grammar_checker_result_ = result.Clone();
+}
+
+void FakeServiceConnectionImpl::SetOutputTextSuggesterResult(
+    const mojom::TextSuggesterResultPtr& result) {
+  text_suggester_result_ = result.Clone();
+}
+
+void FakeServiceConnectionImpl::SetOutputDetectCornersResult(
+    const mojom::DetectCornersResultPtr& result) {
+  detect_corners_result_ = result.Clone();
+}
+
+void FakeServiceConnectionImpl::SetOutputDoPostProcessingResult(
+    const mojom::DoPostProcessingResultPtr& result) {
+  do_post_processing_result_ = result.Clone();
+}
+
+void FakeServiceConnectionImpl::Annotate(
+    mojom::TextAnnotationRequestPtr request,
+    mojom::TextClassifier::AnnotateCallback callback) {
+  ScheduleCall(base::BindOnce(&FakeServiceConnectionImpl::HandleAnnotateCall,
+                              base::Unretained(this), std::move(request),
+                              std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::FindLanguages(
+    const std::string& text,
+    mojom::TextClassifier::FindLanguagesCallback callback) {
+  ScheduleCall(
+      base::BindOnce(&FakeServiceConnectionImpl::HandleFindLanguagesCall,
+                     base::Unretained(this), text, std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::REMOVED_1(
+    mojom::REMOVED_TextSuggestSelectionRequestPtr request,
+    mojom::TextClassifier::REMOVED_1Callback callback) {
+  NOTIMPLEMENTED();
+}
+
+void FakeServiceConnectionImpl::Recognize(
+    mojom::HandwritingRecognitionQueryPtr query,
+    mojom::HandwritingRecognizer::RecognizeCallback callback) {
+  ScheduleCall(base::BindOnce(&FakeServiceConnectionImpl::HandleRecognizeCall,
+                              base::Unretained(this), std::move(query),
+                              std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::GetPrediction(
+    std::vector<web_platform::mojom::HandwritingStrokePtr> strokes,
+    web_platform::mojom::HandwritingHintsPtr hints,
+    web_platform::mojom::HandwritingRecognizer::GetPredictionCallback
+        callback) {
+  ScheduleCall(
+      base::BindOnce(&FakeServiceConnectionImpl::HandleGetPredictionCall,
+                     base::Unretained(this), std::move(strokes),
+                     std::move(hints), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::Check(
+    mojom::GrammarCheckerQueryPtr query,
+    mojom::GrammarChecker::CheckCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleGrammarCheckerQueryCall,
+      base::Unretained(this), std::move(query), std::move(callback)));
+}
+void FakeServiceConnectionImpl::HandleStopCall() {
+  // Do something on the client
+}
+
+void FakeServiceConnectionImpl::HandleStartCall() {
+  // Do something on the client.
+}
+
+void FakeServiceConnectionImpl::HandleMarkDoneCall() {
+  HandleStopCall();
+}
+
+void FakeServiceConnectionImpl::AddAudio(const std::vector<uint8_t>& audio) {}
+void FakeServiceConnectionImpl::Stop() {
+  ScheduleCall(base::BindOnce(&FakeServiceConnectionImpl::HandleStopCall,
+                              base::Unretained(this)));
+}
+void FakeServiceConnectionImpl::Start() {
+  ScheduleCall(base::BindOnce(&FakeServiceConnectionImpl::HandleStartCall,
+                              base::Unretained(this)));
+}
+void FakeServiceConnectionImpl::MarkDone() {
+  ScheduleCall(base::BindOnce(&FakeServiceConnectionImpl::HandleMarkDoneCall,
+                              base::Unretained(this)));
+}
+
+void FakeServiceConnectionImpl::Suggest(
+    mojom::TextSuggesterQueryPtr query,
+    mojom::TextSuggester::SuggestCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleTextSuggesterSuggestCall,
+      base::Unretained(this), std::move(query), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::DetectCornersFromNV12Image(
+    base::ReadOnlySharedMemoryRegion nv12_image,
+    mojom::DocumentScanner::DetectCornersFromNV12ImageCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleDocumentScannerDetectNV12Call,
+      base::Unretained(this), std::move(nv12_image), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::DetectCornersFromJPEGImage(
+    base::ReadOnlySharedMemoryRegion jpeg_image,
+    mojom::DocumentScanner::DetectCornersFromJPEGImageCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleDocumentScannerDetectJPEGCall,
+      base::Unretained(this), std::move(jpeg_image), std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::DoPostProcessing(
+    base::ReadOnlySharedMemoryRegion jpeg_image,
+    const std::vector<gfx::PointF>& corners,
+    chromeos::machine_learning::mojom::Rotation rotation,
+    mojom::DocumentScanner::DoPostProcessingCallback callback) {
+  ScheduleCall(base::BindOnce(
+      &FakeServiceConnectionImpl::HandleDocumentScannerPostProcessingCall,
+      base::Unretained(this), std::move(jpeg_image), std::move(corners),
+      std::move(callback)));
+}
+
+void FakeServiceConnectionImpl::HandleLoadHandwritingModelCall(
+    mojo::PendingReceiver<mojom::HandwritingRecognizer> receiver,
+    mojom::MachineLearningService::LoadHandwritingModelCallback callback) {
+  if (load_handwriting_model_result_ == mojom::LoadHandwritingModelResult::OK)
+    handwriting_receivers_.Add(this, std::move(receiver));
+  std::move(callback).Run(load_handwriting_model_result_);
+}
+
+void FakeServiceConnectionImpl::HandleRecognizeCall(
+    mojom::HandwritingRecognitionQueryPtr query,
+    mojom::HandwritingRecognizer::RecognizeCallback callback) {
+  std::move(callback).Run(handwriting_result_.Clone());
+}
+
+void FakeServiceConnectionImpl::HandleGetPredictionCall(
+    std::vector<web_platform::mojom::HandwritingStrokePtr> strokes,
+    web_platform::mojom::HandwritingHintsPtr hints,
+    web_platform::mojom::HandwritingRecognizer::GetPredictionCallback
+        callback) {
+  std::vector<web_platform::mojom::HandwritingPredictionPtr> predictions;
+  for (auto const& prediction : web_platform_handwriting_result_) {
+    predictions.emplace_back(prediction.Clone());
+  }
+  std::move(callback).Run(std::move(predictions));
+}
+
+void FakeServiceConnectionImpl::HandleLoadGrammarCheckerCall(
+    mojo::PendingReceiver<mojom::GrammarChecker> receiver,
+    mojom::MachineLearningService::LoadGrammarCheckerCallback callback) {
+  if (load_model_result_ == mojom::LoadModelResult::OK)
+    grammar_checker_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(load_model_result_);
+}
+
+void FakeServiceConnectionImpl::HandleLoadSpeechRecognizerCall(
+    mojo::PendingRemote<mojom::SodaClient> soda_client,
+    mojo::PendingReceiver<mojom::SodaRecognizer> soda_recognizer,
+    mojom::MachineLearningService::LoadSpeechRecognizerCallback callback) {
+  if (load_soda_result_ == mojom::LoadModelResult::OK) {
+    soda_recognizer_receivers_.Add(this, std::move(soda_recognizer));
+    soda_client_remotes_.Add(std::move(soda_client));
+  }
+  std::move(callback).Run(load_soda_result_);
+}
+
+void FakeServiceConnectionImpl::HandleGrammarCheckerQueryCall(
+    mojom::GrammarCheckerQueryPtr query,
+    mojom::GrammarChecker::CheckCallback callback) {
+  std::move(callback).Run(grammar_checker_result_.Clone());
+}
+
+void FakeServiceConnectionImpl::HandleLoadTextSuggesterCall(
+    mojo::PendingReceiver<mojom::TextSuggester> receiver,
+    mojom::TextSuggesterSpecPtr spec,
+    mojom::MachineLearningService::LoadTextSuggesterCallback callback) {
+  if (load_model_result_ == mojom::LoadModelResult::OK)
+    text_suggester_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(load_model_result_);
+}
+
+void FakeServiceConnectionImpl::HandleTextSuggesterSuggestCall(
+    mojom::TextSuggesterQueryPtr query,
+    mojom::TextSuggester::SuggestCallback callback) {
+  std::move(callback).Run(text_suggester_result_.Clone());
+}
+
+void FakeServiceConnectionImpl::HandleLoadDocumentScannerCall(
+    mojo::PendingReceiver<mojom::DocumentScanner> receiver,
+    mojom::MachineLearningService::LoadDocumentScannerCallback callback) {
+  if (load_model_result_ == mojom::LoadModelResult::OK)
+    document_scanner_receivers_.Add(this, std::move(receiver));
+
+  std::move(callback).Run(load_model_result_);
+}
+
+void FakeServiceConnectionImpl::HandleDocumentScannerDetectNV12Call(
+    base::ReadOnlySharedMemoryRegion nv12_image,
+    mojom::DocumentScanner::DetectCornersFromNV12ImageCallback callback) {
+  std::move(callback).Run(detect_corners_result_.Clone());
+}
+
+void FakeServiceConnectionImpl::HandleDocumentScannerDetectJPEGCall(
+    base::ReadOnlySharedMemoryRegion jpeg_image,
+    mojom::DocumentScanner::DetectCornersFromJPEGImageCallback callback) {
+  std::move(callback).Run(detect_corners_result_.Clone());
+}
+
+void FakeServiceConnectionImpl::HandleDocumentScannerPostProcessingCall(
+    base::ReadOnlySharedMemoryRegion jpeg_image,
+    const std::vector<gfx::PointF>& corners,
+    mojom::DocumentScanner::DoPostProcessingCallback callback) {
+  std::move(callback).Run(do_post_processing_result_.Clone());
+}
+
+}  // namespace machine_learning
+}  // namespace chromeos

19/public/cpp/fake_service_connection.h

@@ -0,0 +1,383 @@
+// Copyright 2019 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 CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_CPP_FAKE_SERVICE_CONNECTION_H_
+#define CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_CPP_FAKE_SERVICE_CONNECTION_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/component_export.h"
+#include "chromeos/services/machine_learning/public/cpp/service_connection.h"
+#include "chromeos/services/machine_learning/public/mojom/document_scanner.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/grammar_checker.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/graph_executor.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/handwriting_recognizer.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/machine_learning_service.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/model.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/soda.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/tensor.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/text_classifier.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/text_suggester.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/web_platform_handwriting.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/remote_set.h"
+
+namespace chromeos {
+namespace machine_learning {
+
+// Fake implementation of chromeos::machine_learning::ServiceConnection.
+// Handles LoadModel (and Model::CreateGraphExecutor) by binding to itself.
+// Handles GraphExecutor::Execute by always returning the value specified by
+// a previous call to SetOutputValue.
+// Handles TextClassifier::Annotate by always returning the value specified by
+// a previous call to SetOutputAnnotation.
+// For use with ServiceConnection::UseFakeServiceConnectionForTesting().
+class COMPONENT_EXPORT(CHROMEOS_MLSERVICE) FakeServiceConnectionImpl
+    : public ServiceConnection,
+      public mojom::MachineLearningService,
+      public mojom::Model,
+      public mojom::TextClassifier,
+      public mojom::HandwritingRecognizer,
+      public mojom::GrammarChecker,
+      public mojom::GraphExecutor,
+      public mojom::SodaRecognizer,
+      public mojom::TextSuggester,
+      public mojom::DocumentScanner,
+      public web_platform::mojom::HandwritingRecognizer {
+ public:
+  FakeServiceConnectionImpl();
+
+  FakeServiceConnectionImpl(const FakeServiceConnectionImpl&) = delete;
+  FakeServiceConnectionImpl& operator=(const FakeServiceConnectionImpl&) =
+      delete;
+
+  ~FakeServiceConnectionImpl() override;
+
+  // ServiceConnection:
+  mojom::MachineLearningService& GetMachineLearningService() override;
+  void BindMachineLearningService(
+      mojo::PendingReceiver<mojom::MachineLearningService> receiver) override;
+  void Initialize() override;
+
+  // mojom::MachineLearningService:
+  void Clone(
+      mojo::PendingReceiver<mojom::MachineLearningService> receiver) override;
+
+  // It's safe to execute LoadBuiltinModel, LoadFlatBufferModel and
+  // LoadTextClassifier for multi times, but all the receivers will be bound to
+  // the same instance.
+  void LoadBuiltinModel(mojom::BuiltinModelSpecPtr spec,
+                        mojo::PendingReceiver<mojom::Model> receiver,
+                        mojom::MachineLearningService::LoadBuiltinModelCallback
+                            callback) override;
+  void LoadFlatBufferModel(
+      mojom::FlatBufferModelSpecPtr spec,
+      mojo::PendingReceiver<mojom::Model> receiver,
+      mojom::MachineLearningService::LoadFlatBufferModelCallback callback)
+      override;
+
+  void LoadTextClassifier(
+      mojo::PendingReceiver<mojom::TextClassifier> receiver,
+      mojom::MachineLearningService::LoadTextClassifierCallback callback)
+      override;
+
+  void LoadHandwritingModel(
+      mojom::HandwritingRecognizerSpecPtr spec,
+      mojo::PendingReceiver<mojom::HandwritingRecognizer> receiver,
+      mojom::MachineLearningService::LoadHandwritingModelCallback
+          result_callback) override;
+
+  // Dedicated HWR API for Web Platform.
+  void LoadWebPlatformHandwritingModel(
+      web_platform::mojom::HandwritingModelConstraintPtr constraint,
+      mojo::PendingReceiver<web_platform::mojom::HandwritingRecognizer>
+          receiver,
+      LoadWebPlatformHandwritingModelCallback callback) override;
+
+  void LoadGrammarChecker(
+      mojo::PendingReceiver<mojom::GrammarChecker> receiver,
+      mojom::MachineLearningService::LoadGrammarCheckerCallback callback)
+      override;
+
+  void LoadSpeechRecognizer(
+      mojom::SodaConfigPtr soda_config,
+      mojo::PendingRemote<mojom::SodaClient> soda_client,
+      mojo::PendingReceiver<mojom::SodaRecognizer> soda_recognizer,
+      mojom::MachineLearningService::LoadSpeechRecognizerCallback callback)
+      override;
+
+  void LoadTextSuggester(
+      mojo::PendingReceiver<mojom::TextSuggester> receiver,
+      mojom::TextSuggesterSpecPtr spec,
+      mojom::MachineLearningService::LoadTextSuggesterCallback callback)
+      override;
+
+  void LoadDocumentScanner(
+      mojo::PendingReceiver<mojom::DocumentScanner> receiver,
+      mojom::MachineLearningService::LoadDocumentScannerCallback callback)
+      override;
+
+  // mojom::Model:
+  void REMOVED_0(mojo::PendingReceiver<mojom::GraphExecutor> receiver,
+                 mojom::Model::REMOVED_0Callback callback) override;
+
+  // mojom::Model:
+  void REMOVED_4(mojom::HandwritingRecognizerSpecPtr spec,
+                 mojo::PendingReceiver<mojom::HandwritingRecognizer> receiver,
+                 mojom::MachineLearningService::REMOVED_4Callback
+                     result_callback) override;
+
+  // mojom::Model:
+  void CreateGraphExecutor(
+      mojom::GraphExecutorOptionsPtr options,
+      mojo::PendingReceiver<mojom::GraphExecutor> receiver,
+      mojom::Model::CreateGraphExecutorCallback callback) override;
+
+  // mojom::GraphExecutor:
+  // Execute() will return the tensor set by SetOutputValue() as the output.
+  void Execute(base::flat_map<std::string, mojom::TensorPtr> inputs,
+               const std::vector<std::string>& output_names,
+               mojom::GraphExecutor::ExecuteCallback callback) override;
+
+  // Useful for simulating a failure at different stage.
+  // There are different error codes at each stage, we just randomly pick one.
+  void SetLoadModelFailure();
+  void SetCreateGraphExecutorFailure();
+  void SetExecuteFailure();
+  void SetLoadTextClassifierFailure();
+  // Reset all the Model related failures and make Execute succeed.
+  void SetExecuteSuccess();
+  // Reset all the TextClassifier related failures and make LoadTextClassifier
+  // succeed.
+  // Currently, there are two interfaces related to TextClassifier
+  // (|LoadTextClassifier|, |Annotate|) but only
+  // |LoadTextClassifier| can fail.
+  void SetTextClassifierSuccess();
+
+  // Call SetOutputValue() before Execute() to set the output tensor.
+  void SetOutputValue(const std::vector<int64_t>& shape,
+                      const std::vector<double>& value);
+
+  // In async mode, FakeServiceConnectionImpl adds requests like
+  // LoadBuiltinModel, CreateGraphExecutor to |pending_calls_| instead of
+  // responding immediately. Calls in |pending_calls_| will run when
+  // RunPendingCalls() is called.
+  // It's useful when an unit test wants to test the async behaviour of real
+  // ml-service.
+  void SetAsyncMode(bool async_mode);
+  void RunPendingCalls();
+
+  // Call SetOutputAnnotation() before Annotate() to set the output annotation.
+  void SetOutputAnnotation(
+      const std::vector<mojom::TextAnnotationPtr>& annotation);
+
+  // Call SetOutputLanguages() before FindLanguages() to set the output
+  // languages.
+  void SetOutputLanguages(const std::vector<mojom::TextLanguagePtr>& languages);
+
+  // Call SetOutputGrammarCheckerResult() before Check() to set the output of
+  // grammar checker.
+  void SetOutputGrammarCheckerResult(
+      const mojom::GrammarCheckerResultPtr& result);
+
+  // Call SetOutputHandwritingRecognizerResult() before Recognize() to set the
+  // output of handwriting.
+  void SetOutputHandwritingRecognizerResult(
+      const mojom::HandwritingRecognizerResultPtr& result);
+
+  // Call SetOutputWebPlatformHandwritingRecognizerResult() before
+  // GetPrediction() to set the output of handwriting.
+  void SetOutputWebPlatformHandwritingRecognizerResult(
+      const std::vector<web_platform::mojom::HandwritingPredictionPtr>&
+          predictions);
+
+  // Call SetOutputTextSuggesterResult() before Suggest() to set the
+  // output of a text suggestion query.
+  void SetOutputTextSuggesterResult(
+      const mojom::TextSuggesterResultPtr& result);
+
+  // Call SetOutputDetectCornersResult() before
+  // DetectCornersFrom{NV12/JPEG}Image() to set the output of corners detection.
+  void SetOutputDetectCornersResult(
+      const mojom::DetectCornersResultPtr& result);
+
+  // Call SetOutputDoPostProcessingResult() before DoPostProcessing() to set the
+  // output of document post processing.
+  void SetOutputDoPostProcessingResult(
+      const mojom::DoPostProcessingResultPtr& result);
+
+  // mojom::TextClassifier:
+  void Annotate(mojom::TextAnnotationRequestPtr request,
+                mojom::TextClassifier::AnnotateCallback callback) override;
+
+  // mojom::TextClassifier:
+  void FindLanguages(
+      const std::string& text,
+      mojom::TextClassifier::FindLanguagesCallback callback) override;
+
+  // mojom::TextClassifier:
+  void REMOVED_1(
+      mojom::REMOVED_TextSuggestSelectionRequestPtr request,
+      mojom::TextClassifier::REMOVED_1Callback callback) override;
+
+  // mojom::HandwritingRecognizer:
+  void Recognize(
+      mojom::HandwritingRecognitionQueryPtr query,
+      mojom::HandwritingRecognizer::RecognizeCallback callback) override;
+
+  // web_platform::mojom::HandwritingRecognizer
+  void GetPrediction(
+      std::vector<web_platform::mojom::HandwritingStrokePtr> strokes,
+      web_platform::mojom::HandwritingHintsPtr hints,
+      web_platform::mojom::HandwritingRecognizer::GetPredictionCallback
+          callback) override;
+
+  // mojom::GrammarChecker:
+  void Check(mojom::GrammarCheckerQueryPtr query,
+             mojom::GrammarChecker::CheckCallback callback) override;
+
+  // mojom::SpeechRecognizer
+  void AddAudio(const std::vector<uint8_t>& audio) override;
+  void Stop() override;
+  void Start() override;
+  void MarkDone() override;
+
+  // mojom::TextSuggester:
+  void Suggest(mojom::TextSuggesterQueryPtr query,
+               mojom::TextSuggester::SuggestCallback callback) override;
+
+  // mojom::DocumentScanner:
+  void DetectCornersFromNV12Image(
+      base::ReadOnlySharedMemoryRegion nv12_image,
+      mojom::DocumentScanner::DetectCornersFromNV12ImageCallback callback)
+      override;
+  void DetectCornersFromJPEGImage(
+      base::ReadOnlySharedMemoryRegion jpeg_image,
+      mojom::DocumentScanner::DetectCornersFromJPEGImageCallback callback)
+      override;
+  void DoPostProcessing(
+      base::ReadOnlySharedMemoryRegion jpeg_image,
+      const std::vector<gfx::PointF>& corners,
+      chromeos::machine_learning::mojom::Rotation rotation,
+      mojom::DocumentScanner::DoPostProcessingCallback callback) override;
+
+  // Flush all relevant Mojo pipes.
+  void FlushForTesting();
+
+ private:
+  void ScheduleCall(base::OnceClosure call);
+  void HandleLoadBuiltinModelCall(
+      mojo::PendingReceiver<mojom::Model> receiver,
+      mojom::MachineLearningService::LoadBuiltinModelCallback callback);
+  void HandleLoadFlatBufferModelCall(
+      mojo::PendingReceiver<mojom::Model> receiver,
+      mojom::MachineLearningService::LoadFlatBufferModelCallback callback);
+  void HandleCreateGraphExecutorCall(
+      mojom::GraphExecutorOptionsPtr options,
+      mojo::PendingReceiver<mojom::GraphExecutor> receiver,
+      mojom::Model::CreateGraphExecutorCallback callback);
+  void HandleExecuteCall(mojom::GraphExecutor::ExecuteCallback callback);
+  void HandleLoadTextClassifierCall(
+      mojo::PendingReceiver<mojom::TextClassifier> receiver,
+      mojom::MachineLearningService::LoadTextClassifierCallback callback);
+  void HandleAnnotateCall(mojom::TextAnnotationRequestPtr request,
+                          mojom::TextClassifier::AnnotateCallback callback);
+  void HandleFindLanguagesCall(
+      std::string text,
+      mojom::TextClassifier::FindLanguagesCallback callback);
+  void HandleLoadHandwritingModelCall(
+      mojo::PendingReceiver<mojom::HandwritingRecognizer> receiver,
+      mojom::MachineLearningService::LoadHandwritingModelCallback callback);
+  void HandleLoadWebPlatformHandwritingModelCall(
+      mojo::PendingReceiver<web_platform::mojom::HandwritingRecognizer>
+          receiver,
+      mojom::MachineLearningService::LoadHandwritingModelCallback callback);
+  void HandleRecognizeCall(
+      mojom::HandwritingRecognitionQueryPtr query,
+      mojom::HandwritingRecognizer::RecognizeCallback callback);
+  void HandleGetPredictionCall(
+      std::vector<web_platform::mojom::HandwritingStrokePtr> strokes,
+      web_platform::mojom::HandwritingHintsPtr hints,
+      web_platform::mojom::HandwritingRecognizer::GetPredictionCallback
+          callback);
+  void HandleLoadGrammarCheckerCall(
+      mojo::PendingReceiver<mojom::GrammarChecker> receiver,
+      mojom::MachineLearningService::LoadGrammarCheckerCallback callback);
+  void HandleGrammarCheckerQueryCall(
+      mojom::GrammarCheckerQueryPtr query,
+      mojom::GrammarChecker::CheckCallback callback);
+  void HandleLoadSpeechRecognizerCall(
+      mojo::PendingRemote<mojom::SodaClient> soda_client,
+      mojo::PendingReceiver<mojom::SodaRecognizer> soda_recognizer,
+      mojom::MachineLearningService::LoadSpeechRecognizerCallback callback);
+  void HandleLoadTextSuggesterCall(
+      mojo::PendingReceiver<mojom::TextSuggester> receiver,
+      mojom::TextSuggesterSpecPtr spec,
+      mojom::MachineLearningService::LoadTextSuggesterCallback callback);
+  void HandleTextSuggesterSuggestCall(
+      mojom::TextSuggesterQueryPtr query,
+      mojom::TextSuggester::SuggestCallback callback);
+  void HandleLoadDocumentScannerCall(
+      mojo::PendingReceiver<mojom::DocumentScanner> receiver,
+      mojom::MachineLearningService::LoadDocumentScannerCallback callback);
+  void HandleDocumentScannerDetectNV12Call(
+      base::ReadOnlySharedMemoryRegion nv12_image,
+      mojom::DocumentScanner::DetectCornersFromNV12ImageCallback callback);
+  void HandleDocumentScannerDetectJPEGCall(
+      base::ReadOnlySharedMemoryRegion jpeg_image,
+      mojom::DocumentScanner::DetectCornersFromJPEGImageCallback callback);
+  void HandleDocumentScannerPostProcessingCall(
+      base::ReadOnlySharedMemoryRegion jpeg_image,
+      const std::vector<gfx::PointF>& corners,
+      mojom::DocumentScanner::DoPostProcessingCallback callback);
+
+  void HandleStopCall();
+  void HandleStartCall();
+  void HandleMarkDoneCall();
+
+  // Additional receivers bound via `Clone`.
+  mojo::ReceiverSet<mojom::MachineLearningService> clone_ml_service_receivers_;
+
+  mojo::Remote<mojom::MachineLearningService> machine_learning_service_;
+  mojo::ReceiverSet<mojom::Model> model_receivers_;
+  mojo::ReceiverSet<mojom::GraphExecutor> graph_receivers_;
+  mojo::ReceiverSet<mojom::TextClassifier> text_classifier_receivers_;
+  mojo::ReceiverSet<mojom::HandwritingRecognizer> handwriting_receivers_;
+  mojo::ReceiverSet<web_platform::mojom::HandwritingRecognizer>
+      web_platform_handwriting_receivers_;
+  mojo::ReceiverSet<mojom::GrammarChecker> grammar_checker_receivers_;
+  mojo::ReceiverSet<mojom::SodaRecognizer> soda_recognizer_receivers_;
+  mojo::ReceiverSet<mojom::TextSuggester> text_suggester_receivers_;
+  mojo::ReceiverSet<mojom::DocumentScanner> document_scanner_receivers_;
+  mojo::RemoteSet<mojom::SodaClient> soda_client_remotes_;
+  mojom::TensorPtr output_tensor_;
+  mojom::LoadHandwritingModelResult load_handwriting_model_result_;
+  mojom::LoadHandwritingModelResult load_web_platform_handwriting_model_result_;
+  mojom::LoadModelResult load_model_result_;
+  mojom::LoadModelResult load_text_classifier_result_;
+  mojom::LoadModelResult load_soda_result_;
+  mojom::CreateGraphExecutorResult create_graph_executor_result_;
+  mojom::ExecuteResult execute_result_;
+  std::vector<mojom::TextAnnotationPtr> annotate_result_;
+  mojom::CodepointSpanPtr suggest_selection_result_;
+  std::vector<mojom::TextLanguagePtr> find_languages_result_;
+  mojom::HandwritingRecognizerResultPtr handwriting_result_;
+  std::vector<web_platform::mojom::HandwritingPredictionPtr>
+      web_platform_handwriting_result_;
+  mojom::GrammarCheckerResultPtr grammar_checker_result_;
+  mojom::TextSuggesterResultPtr text_suggester_result_;
+  mojom::DetectCornersResultPtr detect_corners_result_;
+  mojom::DoPostProcessingResultPtr do_post_processing_result_;
+
+  bool async_mode_;
+  std::vector<base::OnceClosure> pending_calls_;
+};
+
+}  // namespace machine_learning
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_CPP_FAKE_SERVICE_CONNECTION_H_

19/public/cpp/service_connection.cc

@@ -0,0 +1,30 @@
+// 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 "chromeos/services/machine_learning/public/cpp/service_connection.h"
+
+namespace chromeos {
+namespace machine_learning {
+
+namespace {
+static ServiceConnection* g_fake_service_connection_for_testing = nullptr;
+}  // namespace
+
+ServiceConnection* ServiceConnection::GetInstance() {
+  if (g_fake_service_connection_for_testing) {
+    return g_fake_service_connection_for_testing;
+  }
+
+  // The real impl lies in service_connection_ash.cc and
+  // service_connection_lacros.cc.
+  return CreateRealInstance();
+}
+
+void ServiceConnection::UseFakeServiceConnectionForTesting(
+    ServiceConnection* const fake_service_connection) {
+  g_fake_service_connection_for_testing = fake_service_connection;
+}
+
+}  // namespace machine_learning
+}  // namespace chromeos

19/public/cpp/service_connection.h

@@ -0,0 +1,77 @@
+// 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 CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_CPP_SERVICE_CONNECTION_H_
+#define CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_CPP_SERVICE_CONNECTION_H_
+
+#include "base/component_export.h"
+#include "chromeos/services/machine_learning/public/mojom/machine_learning_service.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+
+namespace chromeos {
+namespace machine_learning {
+
+// Encapsulates a connection to the Chrome OS ML Service daemon via its Mojo
+// interface.
+//
+// Usage for BindMachineLearningService:
+//   mojo::Remote<mojom::MachineLearningService> ml_service;
+//   chromeos::machine_learning::ServiceConnection::GetInstance()
+//       ->BindMachineLearningService(
+//             ml_service.BindNewPipeAndPassReceiver());
+//   // Use ml_service to LoadBuiltinModel(), LoadFlatBufferModel() etc. e.g
+//   ml_service->LoadBuiltinModel(...);
+//
+// Usage for GetMachineLearningService:
+//   chromeos::machine_learning::ServiceConnection::GetInstance()
+//       ->GetMachineLearningService()
+//       .LoadBuiltinModel(...);
+//
+// Sequencing: BindMachineLearningService can be called from any sequence, while
+// GetMachineLearningService must be called from the sequence that the instance
+// is created on.
+class COMPONENT_EXPORT(CHROMEOS_MLSERVICE) ServiceConnection {
+ public:
+  // Gets the ServiceConnection singleton, or a test fake if one has been
+  // specified.
+  static ServiceConnection* GetInstance();
+  // Overrides the result of GetInstance() for use in tests.
+  // Does not take ownership of |fake_service_connection|.
+  // Note: Caller is responsible for calling Initialize() on
+  // `fake_service_connection`.
+  static void UseFakeServiceConnectionForTesting(
+      ServiceConnection* fake_service_connection);
+
+  // Gets the primordial top-level machine learning service interface.
+  // Must be called from the sequence that the instance is created on.
+  virtual mojom::MachineLearningService& GetMachineLearningService() = 0;
+
+  // Binds the receiver to a Clone of the primordial top-level interface.
+  // May be called from any sequence.
+  // Note: A mojo::Remote<mojom::MachineLearningService> bound using this method
+  // does not control the lifetime of the underlying ML Service daemon. It is
+  // safe to release the mojo::Remote<mojom::MachineLearningService> as soon as
+  // you are finished called methods on it and processing callbacks. The ML
+  // Service daemon (and any other mojo remotes subsequently bound to it) will
+  // continue.
+  virtual void BindMachineLearningService(
+      mojo::PendingReceiver<mojom::MachineLearningService> receiver) = 0;
+
+  // Call this once at startup (e.g. PostBrowserStart) on the sequence that
+  // should own the Mojo connection to MachineLearningService (e.g. UI thread).
+  virtual void Initialize() = 0;
+
+ protected:
+  ServiceConnection() = default;
+  virtual ~ServiceConnection() {}
+
+ private:
+  // Creates the ServiceConnection singleton.
+  static ServiceConnection* CreateRealInstance();
+};
+
+}  // namespace machine_learning
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SERVICES_MACHINE_LEARNING_PUBLIC_CPP_SERVICE_CONNECTION_H_

19/public/cpp/service_connection_unittest.cc

@@ -0,0 +1,800 @@
+// 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 "chromeos/services/machine_learning/public/cpp/service_connection.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/memory/read_only_shared_memory_region.h"
+#include "base/message_loop/message_pump_type.h"
+#include "base/run_loop.h"
+#include "base/test/bind.h"
+#include "base/test/task_environment.h"
+#include "base/threading/thread.h"
+#include "chromeos/dbus/machine_learning/machine_learning_client.h"
+#include "chromeos/services/machine_learning/public/cpp/fake_service_connection.h"
+#include "chromeos/services/machine_learning/public/mojom/graph_executor.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/handwriting_recognizer.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/machine_learning_service.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/model.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/tensor.mojom.h"
+#include "chromeos/services/machine_learning/public/mojom/text_suggester.mojom.h"
+#include "mojo/core/embedder/embedder.h"
+#include "mojo/core/embedder/scoped_ipc_support.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace machine_learning {
+namespace {
+
+class ServiceConnectionTest : public testing::Test {
+ public:
+  ServiceConnectionTest() = default;
+
+  ServiceConnectionTest(const ServiceConnectionTest&) = delete;
+  ServiceConnectionTest& operator=(const ServiceConnectionTest&) = delete;
+
+  void SetUp() override { MachineLearningClient::InitializeFake(); }
+
+  void TearDown() override { MachineLearningClient::Shutdown(); }
+
+ protected:
+  static void SetUpTestCase() {
+    task_environment_ = new base::test::TaskEnvironment();
+    static base::Thread ipc_thread("ipc");
+    ipc_thread.StartWithOptions(
+        base::Thread::Options(base::MessagePumpType::IO, 0));
+    static mojo::core::ScopedIPCSupport ipc_support(
+        ipc_thread.task_runner(),
+        mojo::core::ScopedIPCSupport::ShutdownPolicy::CLEAN);
+    ServiceConnection::GetInstance()->Initialize();
+  }
+
+  static void TearDownTestCase() {
+    if (task_environment_) {
+      delete task_environment_;
+      task_environment_ = nullptr;
+    }
+  }
+
+ private:
+  static base::test::TaskEnvironment* task_environment_;
+};
+
+base::test::TaskEnvironment* ServiceConnectionTest::task_environment_;
+
+// Tests that LoadBuiltinModel runs OK (no crash) in a basic Mojo
+// environment.
+TEST_F(ServiceConnectionTest, LoadBuiltinModel) {
+  mojo::Remote<mojom::Model> model;
+
+  mojo::Remote<mojom::MachineLearningService> ml_service;
+  ServiceConnection::GetInstance()->BindMachineLearningService(
+      ml_service.BindNewPipeAndPassReceiver());
+
+  ml_service->LoadBuiltinModel(
+      mojom::BuiltinModelSpec::New(mojom::BuiltinModelId::TEST_MODEL),
+      model.BindNewPipeAndPassReceiver(),
+      base::BindOnce([](mojom::LoadModelResult result) {}));
+
+  // Also tests GetMachineLearningService runs OK.
+  model.reset();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadBuiltinModel(
+          mojom::BuiltinModelSpec::New(mojom::BuiltinModelId::TEST_MODEL),
+          model.BindNewPipeAndPassReceiver(),
+          base::BindOnce([](mojom::LoadModelResult result) {}));
+}
+
+// Tests that LoadFlatBufferModel runs OK (no crash) in a basic Mojo
+// environment.
+TEST_F(ServiceConnectionTest, LoadFlatBufferModel) {
+  mojo::Remote<mojom::MachineLearningService> ml_service;
+  ServiceConnection::GetInstance()->BindMachineLearningService(
+      ml_service.BindNewPipeAndPassReceiver());
+
+  mojo::Remote<mojom::Model> model;
+  ml_service->LoadFlatBufferModel(
+      mojom::FlatBufferModelSpec::New(), model.BindNewPipeAndPassReceiver(),
+      base::BindOnce([](mojom::LoadModelResult result) {}));
+
+  model.reset();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadFlatBufferModel(
+          mojom::FlatBufferModelSpec::New(), model.BindNewPipeAndPassReceiver(),
+          base::BindOnce([](mojom::LoadModelResult result) {}));
+}
+
+// Tests that LoadTextClassifier runs OK (no crash) in a basic Mojo
+// environment.
+TEST_F(ServiceConnectionTest, LoadTextClassifier) {
+  mojo::Remote<mojom::MachineLearningService> ml_service;
+  ServiceConnection::GetInstance()->BindMachineLearningService(
+      ml_service.BindNewPipeAndPassReceiver());
+
+  mojo::Remote<mojom::TextClassifier> text_classifier;
+  ml_service->LoadTextClassifier(
+      text_classifier.BindNewPipeAndPassReceiver(),
+      base::BindOnce([](mojom::LoadModelResult result) {}));
+
+  text_classifier.reset();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadTextClassifier(text_classifier.BindNewPipeAndPassReceiver(),
+                          base::BindOnce([](mojom::LoadModelResult result) {}));
+}
+
+// Tests that LoadHandwritingModel runs OK (no crash) in a basic Mojo
+// environment.
+TEST_F(ServiceConnectionTest, LoadHandwritingModel) {
+  mojo::Remote<mojom::MachineLearningService> ml_service;
+  ServiceConnection::GetInstance()->BindMachineLearningService(
+      ml_service.BindNewPipeAndPassReceiver());
+
+  mojo::Remote<mojom::HandwritingRecognizer> handwriting_recognizer;
+  ml_service->LoadHandwritingModel(
+      mojom::HandwritingRecognizerSpec::New("en"),
+      handwriting_recognizer.BindNewPipeAndPassReceiver(),
+      base::BindOnce([](mojom::LoadHandwritingModelResult result) {}));
+
+  handwriting_recognizer.reset();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadHandwritingModel(
+          mojom::HandwritingRecognizerSpec::New("en"),
+          handwriting_recognizer.BindNewPipeAndPassReceiver(),
+          base::BindOnce([](mojom::LoadHandwritingModelResult result) {}));
+}
+
+// Tests that LoadGrammarChecker runs OK (no crash) in a basic Mojo environment.
+TEST_F(ServiceConnectionTest, LoadGrammarModel) {
+  mojo::Remote<mojom::MachineLearningService> ml_service;
+  ServiceConnection::GetInstance()->BindMachineLearningService(
+      ml_service.BindNewPipeAndPassReceiver());
+
+  mojo::Remote<mojom::GrammarChecker> grammar_checker;
+  ml_service->LoadGrammarChecker(
+      grammar_checker.BindNewPipeAndPassReceiver(),
+      base::BindOnce([](mojom::LoadModelResult result) {}));
+
+  grammar_checker.reset();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadGrammarChecker(grammar_checker.BindNewPipeAndPassReceiver(),
+                          base::BindOnce([](mojom::LoadModelResult result) {}));
+}
+
+// Tests the fake ML service for binding ml_service receiver.
+TEST_F(ServiceConnectionTest, BindMachineLearningService) {
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  mojo::Remote<mojom::MachineLearningService> ml_service;
+  base::OnceClosure callback =
+      base::BindOnce(&ServiceConnection::BindMachineLearningService,
+                     base::Unretained(ServiceConnection::GetInstance()),
+                     ml_service.BindNewPipeAndPassReceiver())
+          .Then(run_loop->QuitClosure());
+  std::move(callback).Run();
+  run_loop->Run();
+  ASSERT_TRUE(ml_service.is_bound());
+
+  // Check the bound ml_service remote can be used to call
+  // MachineLearningService methods.
+  mojo::Remote<mojom::Model> model;
+  bool callback_done = false;
+
+  run_loop.reset(new base::RunLoop);
+  ml_service->LoadBuiltinModel(
+      mojom::BuiltinModelSpec::New(mojom::BuiltinModelId::TEST_MODEL),
+      model.BindNewPipeAndPassReceiver(),
+      base::BindOnce(
+          [](bool* callback_done, mojom::LoadModelResult result) {
+            EXPECT_EQ(result, mojom::LoadModelResult::OK);
+            *callback_done = true;
+          },
+          &callback_done)
+          .Then(run_loop->QuitClosure()));
+
+  run_loop->Run();
+  EXPECT_TRUE(callback_done);
+  EXPECT_TRUE(model.is_bound());
+}
+
+class TestSodaClient : public mojom::SodaClient {
+  void OnStop() override {}
+  void OnStart() override {}
+  void OnSpeechRecognizerEvent(mojom::SpeechRecognizerEventPtr event) override {
+  }
+};
+
+// Tests that LoadSpeechRecognizer runs OK without a crash in a basic Mojo
+// Environment.
+TEST_F(ServiceConnectionTest, LoadSpeechRecognizerAndCallback) {
+  mojo::Remote<mojom::SodaRecognizer> soda_recognizer;
+  TestSodaClient test_client;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  mojo::Receiver<mojom::SodaClient> soda_client{&test_client};
+  bool callback_done = false;
+  auto config = mojom::SodaConfig::New();
+  base::RunLoop run_loop;
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadSpeechRecognizer(
+          std::move(config), soda_client.BindNewPipeAndPassRemote(),
+          soda_recognizer.BindNewPipeAndPassReceiver(),
+          base::BindLambdaForTesting([&](mojom::LoadModelResult result) {
+            callback_done = true;
+            EXPECT_EQ(result, mojom::LoadModelResult::OK);
+            run_loop.Quit();
+          }));
+  run_loop.Run();
+  ASSERT_TRUE(callback_done);
+}
+
+// Tests the fake ML service for builtin model.
+TEST_F(ServiceConnectionTest, FakeServiceConnectionForBuiltinModel) {
+  mojo::Remote<mojom::Model> model;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  const double expected_value = 200.002;
+  fake_service_connection.SetOutputValue(std::vector<int64_t>{1L},
+                                         std::vector<double>{expected_value});
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadBuiltinModel(
+          mojom::BuiltinModelSpec::New(mojom::BuiltinModelId::TEST_MODEL),
+          model.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(model.is_bound());
+
+  callback_done = false;
+  mojo::Remote<mojom::GraphExecutor> graph;
+  run_loop.reset(new base::RunLoop);
+  model->CreateGraphExecutor(
+      mojom::GraphExecutorOptions::New(), graph.BindNewPipeAndPassReceiver(),
+      base::BindOnce(
+          [](bool* callback_done, mojom::CreateGraphExecutorResult result) {
+            EXPECT_EQ(result, mojom::CreateGraphExecutorResult::OK);
+            *callback_done = true;
+          },
+          &callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(graph.is_bound());
+
+  callback_done = false;
+  base::flat_map<std::string, mojom::TensorPtr> inputs;
+  std::vector<std::string> outputs;
+  run_loop.reset(new base::RunLoop);
+  graph->Execute(std::move(inputs), std::move(outputs),
+                 base::BindOnce(
+                     [](bool* callback_done, double expected_value,
+                        const mojom::ExecuteResult result,
+                        absl::optional<std::vector<mojom::TensorPtr>> outputs) {
+                       EXPECT_EQ(result, mojom::ExecuteResult::OK);
+                       ASSERT_TRUE(outputs.has_value());
+                       ASSERT_EQ(outputs->size(), 1LU);
+                       mojom::TensorPtr& tensor = (*outputs)[0];
+                       EXPECT_EQ(tensor->data->get_float_list()->value[0],
+                                 expected_value);
+
+                       *callback_done = true;
+                     },
+                     &callback_done, expected_value)
+                     .Then(run_loop->QuitClosure()));
+
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+}
+
+// Tests the fake ML service for flatbuffer model.
+TEST_F(ServiceConnectionTest, FakeServiceConnectionForFlatBufferModel) {
+  mojo::Remote<mojom::Model> model;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  const double expected_value = 200.002;
+  fake_service_connection.SetOutputValue(std::vector<int64_t>{1L},
+                                         std::vector<double>{expected_value});
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadFlatBufferModel(
+          mojom::FlatBufferModelSpec::New(), model.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(model.is_bound());
+
+  callback_done = false;
+  mojo::Remote<mojom::GraphExecutor> graph;
+  run_loop.reset(new base::RunLoop);
+  model->CreateGraphExecutor(
+      mojom::GraphExecutorOptions::New(), graph.BindNewPipeAndPassReceiver(),
+      base::BindOnce(
+          [](bool* callback_done, mojom::CreateGraphExecutorResult result) {
+            EXPECT_EQ(result, mojom::CreateGraphExecutorResult::OK);
+            *callback_done = true;
+          },
+          &callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(graph.is_bound());
+
+  callback_done = false;
+  base::flat_map<std::string, mojom::TensorPtr> inputs;
+  std::vector<std::string> outputs;
+  run_loop.reset(new base::RunLoop);
+  graph->Execute(std::move(inputs), std::move(outputs),
+                 base::BindOnce(
+                     [](bool* callback_done, double expected_value,
+                        const mojom::ExecuteResult result,
+                        absl::optional<std::vector<mojom::TensorPtr>> outputs) {
+                       EXPECT_EQ(result, mojom::ExecuteResult::OK);
+                       ASSERT_TRUE(outputs.has_value());
+                       ASSERT_EQ(outputs->size(), 1LU);
+                       mojom::TensorPtr& tensor = (*outputs)[0];
+                       EXPECT_EQ(tensor->data->get_float_list()->value[0],
+                                 expected_value);
+
+                       *callback_done = true;
+                     },
+                     &callback_done, expected_value)
+                     .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+}
+
+// Tests the fake ML service for text classifier annotation.
+TEST_F(ServiceConnectionTest,
+       FakeServiceConnectionForTextClassifierAnnotation) {
+  mojo::Remote<mojom::TextClassifier> text_classifier;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  auto dummy_data = mojom::TextEntityData::New();
+  dummy_data->set_numeric_value(123456789.);
+  std::vector<mojom::TextEntityPtr> entities;
+  entities.emplace_back(
+      mojom::TextEntity::New("dummy",                      // Entity name.
+                             1.0,                          // Confidence score.
+                             std::move(dummy_data)));      // Data extracted.
+  auto dummy_annotation = mojom::TextAnnotation::New(123,  // Start offset.
+                                                     321,  // End offset.
+                                                     std::move(entities));
+  std::vector<mojom::TextAnnotationPtr> annotations;
+  annotations.emplace_back(std::move(dummy_annotation));
+  fake_service_connection.SetOutputAnnotation(annotations);
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadTextClassifier(
+          text_classifier.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(text_classifier.is_bound());
+
+  auto request = mojom::TextAnnotationRequest::New();
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  text_classifier->Annotate(
+      std::move(request),
+      base::BindOnce(
+          [](bool* infer_callback_done,
+             std::vector<mojom::TextAnnotationPtr> annotations) {
+            *infer_callback_done = true;
+            // Check if the annotation is correct.
+            EXPECT_EQ(annotations[0]->start_offset, 123u);
+            EXPECT_EQ(annotations[0]->end_offset, 321u);
+            EXPECT_EQ(annotations[0]->entities[0]->name, "dummy");
+            EXPECT_EQ(annotations[0]->entities[0]->confidence_score, 1.0);
+            EXPECT_EQ(annotations[0]->entities[0]->data->get_numeric_value(),
+                      123456789.);
+          },
+          &infer_callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+// Tests the fake ML service for text classifier language identification.
+TEST_F(ServiceConnectionTest,
+       FakeServiceConnectionForTextClassifierFindLanguages) {
+  mojo::Remote<mojom::TextClassifier> text_classifier;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  std::vector<mojom::TextLanguagePtr> languages;
+  languages.emplace_back(mojom::TextLanguage::New("en", 0.9));
+  languages.emplace_back(mojom::TextLanguage::New("fr", 0.1));
+  fake_service_connection.SetOutputLanguages(languages);
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadTextClassifier(
+          text_classifier.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(text_classifier.is_bound());
+
+  std::string input_text = "dummy input text";
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  text_classifier->FindLanguages(
+      input_text, base::BindOnce(
+                      [](bool* infer_callback_done,
+                         std::vector<mojom::TextLanguagePtr> languages) {
+                        *infer_callback_done = true;
+                        // Check if the suggestion is correct.
+                        ASSERT_EQ(languages.size(), 2ul);
+                        EXPECT_EQ(languages[0]->locale, "en");
+                        EXPECT_EQ(languages[0]->confidence, 0.9f);
+                        EXPECT_EQ(languages[1]->locale, "fr");
+                        EXPECT_EQ(languages[1]->confidence, 0.1f);
+                      },
+                      &infer_callback_done)
+                      .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+// Tests the fake ML service for handwriting.
+TEST_F(ServiceConnectionTest, FakeHandWritingRecognizer) {
+  mojo::Remote<mojom::HandwritingRecognizer> recognizer;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadHandwritingModel(
+          mojom::HandwritingRecognizerSpec::New("en"),
+          recognizer.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done,
+                 mojom::LoadHandwritingModelResult result) {
+                EXPECT_EQ(result, mojom::LoadHandwritingModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(recognizer.is_bound());
+
+  // Construct fake output.
+  mojom::HandwritingRecognizerResultPtr result =
+      mojom::HandwritingRecognizerResult::New();
+  result->status = mojom::HandwritingRecognizerResult::Status::OK;
+  mojom::HandwritingRecognizerCandidatePtr candidate =
+      mojom::HandwritingRecognizerCandidate::New();
+  candidate->text = "cat";
+  candidate->score = 0.5f;
+  result->candidates.emplace_back(std::move(candidate));
+  fake_service_connection.SetOutputHandwritingRecognizerResult(result);
+
+  auto query = mojom::HandwritingRecognitionQuery::New();
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  recognizer->Recognize(
+      std::move(query),
+      base::BindOnce(
+          [](bool* infer_callback_done,
+             mojom::HandwritingRecognizerResultPtr result) {
+            *infer_callback_done = true;
+            // Check if the annotation is correct.
+            ASSERT_EQ(result->status,
+                      mojom::HandwritingRecognizerResult::Status::OK);
+            EXPECT_EQ(result->candidates.at(0)->text, "cat");
+            EXPECT_EQ(result->candidates.at(0)->score, 0.5f);
+          },
+          &infer_callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+// Tests the fake ML service for web platform handwriting recognizer.
+TEST_F(ServiceConnectionTest, FakeWebPlatformHandWritingRecognizer) {
+  mojo::Remote<web_platform::mojom::HandwritingRecognizer> recognizer;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+  auto constraint = web_platform::mojom::HandwritingModelConstraint::New();
+  constraint->languages.emplace_back("en");
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadWebPlatformHandwritingModel(
+          std::move(constraint), recognizer.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done,
+                 mojom::LoadHandwritingModelResult result) {
+                EXPECT_EQ(result, mojom::LoadHandwritingModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(recognizer.is_bound());
+
+  // Construct fake output.
+  std::vector<web_platform::mojom::HandwritingPredictionPtr> predictions;
+  auto prediction1 = web_platform::mojom::HandwritingPrediction::New();
+  prediction1->text = "recognition1";
+  predictions.emplace_back(std::move(prediction1));
+  fake_service_connection.SetOutputWebPlatformHandwritingRecognizerResult(
+      predictions);
+
+  std::vector<web_platform::mojom::HandwritingStrokePtr> strokes;
+  auto hints = web_platform::mojom::HandwritingHints::New();
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  recognizer->GetPrediction(
+      std::move(strokes), std::move(hints),
+      base::BindOnce(
+          [](bool* infer_callback_done,
+             absl::optional<std::vector<
+                 web_platform::mojom::HandwritingPredictionPtr>> predictions) {
+            *infer_callback_done = true;
+            ASSERT_TRUE(predictions.has_value());
+            ASSERT_EQ(predictions.value().size(), 1u);
+          },
+          &infer_callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+TEST_F(ServiceConnectionTest, FakeGrammarChecker) {
+  mojo::Remote<mojom::GrammarChecker> checker;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadGrammarChecker(
+          checker.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(checker.is_bound());
+
+  // Construct fake output
+  mojom::GrammarCheckerResultPtr result = mojom::GrammarCheckerResult::New();
+  result->status = mojom::GrammarCheckerResult::Status::OK;
+  mojom::GrammarCheckerCandidatePtr candidate =
+      mojom::GrammarCheckerCandidate::New();
+  candidate->text = "cat";
+  candidate->score = 0.5f;
+  mojom::GrammarCorrectionFragmentPtr fragment =
+      mojom::GrammarCorrectionFragment::New();
+  fragment->offset = 3;
+  fragment->length = 5;
+  fragment->replacement = "dog";
+  candidate->fragments.emplace_back(std::move(fragment));
+  result->candidates.emplace_back(std::move(candidate));
+  fake_service_connection.SetOutputGrammarCheckerResult(result);
+
+  auto query = mojom::GrammarCheckerQuery::New();
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  checker->Check(
+      std::move(query),
+      base::BindOnce(
+          [](bool* infer_callback_done, mojom::GrammarCheckerResultPtr result) {
+            *infer_callback_done = true;
+            // Check if the annotation is correct.
+            ASSERT_EQ(result->status, mojom::GrammarCheckerResult::Status::OK);
+            ASSERT_EQ(result->candidates.size(), 1UL);
+            EXPECT_EQ(result->candidates.at(0)->text, "cat");
+            EXPECT_EQ(result->candidates.at(0)->score, 0.5f);
+
+            ASSERT_EQ(result->candidates.at(0)->fragments.size(), 1UL);
+            EXPECT_EQ(result->candidates.at(0)->fragments.at(0)->offset, 3U);
+            EXPECT_EQ(result->candidates.at(0)->fragments.at(0)->length, 5U);
+            EXPECT_EQ(result->candidates.at(0)->fragments.at(0)->replacement,
+                      "dog");
+          },
+          &infer_callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+TEST_F(ServiceConnectionTest, FakeTextSuggester) {
+  mojo::Remote<mojom::TextSuggester> suggester;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadTextSuggester(
+          suggester.BindNewPipeAndPassReceiver(),
+          mojom::TextSuggesterSpec::New(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(suggester.is_bound());
+
+  // Construct fake output
+  mojom::TextSuggesterResultPtr result = mojom::TextSuggesterResult::New();
+  result->status = mojom::TextSuggesterResult::Status::OK;
+
+  mojom::MultiWordSuggestionCandidatePtr multi_word =
+      mojom::MultiWordSuggestionCandidate::New();
+  multi_word->text = "hello";
+  multi_word->normalized_score = 0.5f;
+  mojom::TextSuggestionCandidatePtr candidate =
+      mojom::TextSuggestionCandidate::New();
+  candidate->set_multi_word(std::move(multi_word));
+
+  result->candidates.emplace_back(std::move(candidate));
+  fake_service_connection.SetOutputTextSuggesterResult(result);
+
+  auto query = mojom::TextSuggesterQuery::New();
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  suggester->Suggest(
+      std::move(query),
+      base::BindOnce(
+          [](bool* infer_callback_done, mojom::TextSuggesterResultPtr result) {
+            *infer_callback_done = true;
+            // Check the fake suggestion is returned
+            ASSERT_EQ(result->status, mojom::TextSuggesterResult::Status::OK);
+            ASSERT_EQ(result->candidates.size(), 1UL);
+            ASSERT_TRUE(result->candidates.at(0)->is_multi_word());
+            EXPECT_EQ(result->candidates.at(0)->get_multi_word()->text,
+                      "hello");
+            EXPECT_EQ(
+                result->candidates.at(0)->get_multi_word()->normalized_score,
+                0.5f);
+          },
+          &infer_callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+// Tests the fake ML service for document scanner.
+TEST_F(ServiceConnectionTest, FakeDocumentScanner) {
+  mojo::Remote<mojom::DocumentScanner> scanner;
+  bool callback_done = false;
+  FakeServiceConnectionImpl fake_service_connection;
+  ServiceConnection::UseFakeServiceConnectionForTesting(
+      &fake_service_connection);
+  ServiceConnection::GetInstance()->Initialize();
+
+  std::unique_ptr<base::RunLoop> run_loop = std::make_unique<base::RunLoop>();
+  ServiceConnection::GetInstance()
+      ->GetMachineLearningService()
+      .LoadDocumentScanner(
+          scanner.BindNewPipeAndPassReceiver(),
+          base::BindOnce(
+              [](bool* callback_done, mojom::LoadModelResult result) {
+                EXPECT_EQ(result, mojom::LoadModelResult::OK);
+                *callback_done = true;
+              },
+              &callback_done)
+              .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(callback_done);
+  ASSERT_TRUE(scanner.is_bound());
+
+  constexpr int kNv12ImageSize = 256 * 256;
+  std::vector<uint8_t> fake_nv12_data(kNv12ImageSize, 0);
+  base::MappedReadOnlyRegion memory =
+      base::ReadOnlySharedMemoryRegion::Create(fake_nv12_data.size());
+  memcpy(memory.mapping.memory(), fake_nv12_data.data(), fake_nv12_data.size());
+
+  mojom::DetectCornersResultPtr result = mojom::DetectCornersResult::New();
+  result->status = mojom::DocumentScannerResultStatus::OK;
+  result->corners = {};
+  fake_service_connection.SetOutputDetectCornersResult(std::move(result));
+
+  bool infer_callback_done = false;
+  run_loop.reset(new base::RunLoop);
+  scanner->DetectCornersFromNV12Image(
+      std::move(memory.region),
+      base::BindOnce(
+          [](bool* infer_callback_done, mojom::DetectCornersResultPtr result) {
+            *infer_callback_done = true;
+            ASSERT_EQ(result->status, mojom::DocumentScannerResultStatus::OK);
+            ASSERT_TRUE(result->corners.size() == 0);
+          },
+          &infer_callback_done)
+          .Then(run_loop->QuitClosure()));
+  run_loop->Run();
+  ASSERT_TRUE(infer_callback_done);
+}
+
+}  // namespace
+}  // namespace machine_learning
+}  // namespace chromeos

19/public/mojom/BUILD.gn

@@ -0,0 +1,36 @@
+# 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.
+
+import("//mojo/public/tools/bindings/mojom.gni")
+
+mojom_component("mojom") {
+  sources = [
+    "document_scanner.mojom",
+    "grammar_checker.mojom",
+    "graph_executor.mojom",
+    "handwriting_recognizer.mojom",
+    "machine_learning_service.mojom",
+    "model.mojom",
+    "soda.mojom",
+    "tensor.mojom",
+    "text_classifier.mojom",
+    "text_suggester.mojom",
+    "web_platform_handwriting.mojom",
+  ]
+
+  public_deps = [
+    ":document_scanner_param_types",
+    "//mojo/public/mojom/base",
+  ]
+
+  deps = [ "//ui/gfx/geometry/mojom" ]
+
+  output_prefix = "mlservice_mojom"
+  macro_prefix = "MLSERVICE_MOJOM"
+}
+
+mojom("document_scanner_param_types") {
+  sources = [ "document_scanner_param_types.mojom" ]
+  webui_module_path = "/chromeos/services/machine_learning/public/mojom"
+}

19/public/mojom/OWNERS

@@ -0,0 +1,2 @@
+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS

19/public/mojom/document_scanner.mojom

@@ -0,0 +1,76 @@
+// Copyright 2021 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.
+
+// Next MinVersion: 2
+
+// Datatypes and interfaces of document scanner API.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+import "chromeos/services/machine_learning/public/mojom/document_scanner_param_types.mojom";
+import "ui/gfx/geometry/mojom/geometry.mojom";
+import "mojo/public/mojom/base/shared_memory.mojom";
+
+// Status of the document scanner response.
+[Stable, Extensible]
+enum DocumentScannerResultStatus {
+  OK = 0,
+  ERROR = 1,
+};
+
+// The corner detection response.
+// Next min field ID: 2
+[Stable]
+struct DetectCornersResult {
+  // Status of the result. Even when there is no corners detected, the detection
+  // can still be considered successful if there is no error occurs.
+  DocumentScannerResultStatus status@0;
+
+  // Detected document corners.
+  array<gfx.mojom.PointF> corners@1;
+};
+
+// The post processing response.
+// Next min field ID: 2
+[Stable]
+struct DoPostProcessingResult {
+  // Status of the result.
+  DocumentScannerResultStatus status@0;
+
+  // Image data after processing. Will be in JPG format.
+  array<uint8> processed_jpeg_image@1;
+};
+
+// The mojom interface for performing document scanning.
+// Next ordinal: 3
+[Stable]
+interface DocumentScanner {
+  // Detect document corners for given `nv12_image` which is in 256x256 size.
+  DetectCornersFromNV12Image@0(
+      mojo_base.mojom.ReadOnlySharedMemoryRegion nv12_image)
+      => (DetectCornersResult result);
+
+  // Detect document corners for given `jpeg_image`.
+  DetectCornersFromJPEGImage@1(
+      mojo_base.mojom.ReadOnlySharedMemoryRegion jpeg_image)
+      => (DetectCornersResult result);
+
+  // Do post processing such as rectification for the document region, contrast
+  // enhancement on the given `jpeg_image` according to document `corners`,
+  // clockwise rotation in `rotation` degrees.
+  DoPostProcessing@2(mojo_base.mojom.ReadOnlySharedMemoryRegion jpeg_image,
+                     array<gfx.mojom.PointF> corners,
+                     [MinVersion=1] Rotation rotation)
+      => (DoPostProcessingResult result);
+};

19/public/mojom/document_scanner_param_types.mojom

@@ -0,0 +1,30 @@
+// Copyright 2021 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.
+
+// Common datatypes shared between document scanner API and camera app.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// Image rotation in clockwise direction.
+[Stable, Extensible]
+enum Rotation {
+  // 0 degree rotation (no rotation).
+  ROTATION_0 = 0,
+  // 90 degree rotation.
+  ROTATION_90 = 1,
+  // 180 degree rotation.
+  ROTATION_180 = 2,
+  // 270 degree rotation.
+  ROTATION_270 = 3,
+};

19/public/mojom/grammar_checker.mojom

@@ -0,0 +1,80 @@
+// Copyright 2020 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.
+
+// Datatypes and interfaces of grammar checker API.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// Defines a grammar check query.
+[Stable]
+struct GrammarCheckerQuery {
+  // Required: Text to be checked. This is expected to be a full sentence.
+  string text;
+
+  // Required: Language of the text to be checked, in BCP-47 format.
+  string language;
+};
+
+// A span with suggested corrections.
+[Stable]
+struct GrammarCorrectionFragment {
+  // The start offset in the original text.
+  uint32 offset;
+
+  // The length of the fragment in the original text.
+  uint32 length;
+
+  // The replacement string.
+  string replacement;
+};
+
+// One possible candidate returned from the grammar checker model.
+[Stable]
+struct GrammarCheckerCandidate {
+  // Corrected text.
+  string text;
+
+  // Score of the text. Log of conditional probability.
+  float score;
+
+  // The list of individual corrections.
+  array<GrammarCorrectionFragment> fragments;
+};
+
+// The grammar check response.
+[Stable]
+struct GrammarCheckerResult {
+  // Status of the response.
+  [Stable, Extensible]
+  enum Status {
+    // Grammar check succeeded.
+    OK = 0,
+    // Grammar check failed. In this case, candidates will be empty.
+    ERROR = 1,
+  };
+  Status status;
+
+  // Candidates of corrected text and their scores, sorted by higher score
+  // first.
+  array<GrammarCheckerCandidate> candidates;
+};
+
+// The mojom interface for performing the grammar check.
+// Next ordinal: 1
+[Stable]
+interface GrammarChecker {
+  // Performs grammar check on a piece of text, and returns a set of
+  // candidates of corrected text and their scores.
+  Check@0(GrammarCheckerQuery query) => (GrammarCheckerResult result);
+};

19/public/mojom/graph_executor.mojom

@@ -0,0 +1,47 @@
+// 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.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// NOTE: The base directory for 'import' statements is expected to differ
+//       between Chromium and Chrome OS versions of this file.
+import "chromeos/services/machine_learning/public/mojom/tensor.mojom";
+
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+[Stable, Extensible]
+enum ExecuteResult {
+  OK = 0,
+  INPUT_MISSING_ERROR = 1,
+  UNKNOWN_INPUT_ERROR = 2,
+  INPUT_TYPE_ERROR = 3,
+  INPUT_SHAPE_ERROR = 4,
+  INPUT_FORMAT_ERROR = 5,
+  OUTPUT_MISSING_ERROR = 6,
+  UNKNOWN_OUTPUT_ERROR = 7,
+  DUPLICATE_OUTPUT_ERROR = 8,
+  EXECUTION_ERROR = 9,
+};
+
+// API for performing inference on a TensorFlow graph. A given graph can be
+// executed multiple times with a single instance of GraphExecutor.
+// Next ordinal: 1
+[Stable]
+interface GraphExecutor {
+  // Initializes input node values as specified in `inputs`, then executes the
+  // graph. The returned `outputs` are the values for the nodes specified in
+  // `output_names`.
+  Execute@0(map<string, Tensor> inputs, array<string> output_names)
+       => (ExecuteResult result, array<Tensor>? outputs);
+};

19/public/mojom/handwriting_recognizer.mojom

@@ -0,0 +1,196 @@
+// Copyright 2020 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.
+
+// Next MinVersion: 2
+
+// Datatypes and interfaces of handwriting recognition API.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+import "mojo/public/mojom/base/time.mojom";
+
+// A single point in an ink stroke.
+[Stable]
+struct InkPoint {
+  // (x, y) coordinates of the point. The upper-left corner of the writing area
+  // is (0, 0). The positive x-axis points to the right. The positive y-axis
+  // points down.
+  float x;
+  float y;
+  // Optional TimeDelta from the point was captured relative to the beginning of
+  // the ink. So first point of a request should have t=0.
+  mojo_base.mojom.TimeDelta? t;
+};
+
+// A single ink stroke.
+[Stable]
+struct InkStroke {
+  // The set of points representing the stroke.
+  array<InkPoint> points;
+};
+
+// The writing guide shown to the user during input.
+[Stable]
+struct WritingGuide {
+   // Size of the writing area. The writing area must have (0, 0) at the top
+   // left.
+   // width is the max value of x-axis (to the right) and height is the max
+   // value of y-axis (to the bottom).
+   float width;
+   float height;
+};
+
+// Options that will influence the recognition output.
+[Stable]
+struct RecognitionContext {
+  // The writing guide shown to the user when the ink was captured.
+  WritingGuide? writing_guide;
+  // The context before the written text.
+  string? pre_context;
+};
+
+// Defines a handwriting recognition query.
+[Stable]
+struct HandwritingRecognitionQuery {
+  // The set of ink strokes to be recognized.
+  array<InkStroke> ink;
+  // The optional context in which the ink was generated.
+  RecognitionContext? context;
+  // Maximum number of results to be returned.
+  uint32 max_num_results;
+  // If true, returns the segmentation results. This will make the response
+  // struct much larger.
+  bool return_segmentation;
+};
+
+// Represents a contiguous range of ink. Start and end strokes / points are
+// inclusive.
+[Stable]
+struct HandwritingRecognizerInkRange {
+  // Zero-based start- and end-stroke indices in the ink strokes.
+  uint32 start_stroke;
+  uint32 end_stroke;
+  // Zero-based start- and end-point indices with the start / end strokes.
+  uint32 start_point;
+  uint32 end_point;
+};
+
+// A segment defines the substrokes that are associated with a substring of the
+// recognized text.
+[Stable]
+struct HandwritingRecognizerSegment {
+  // The substring of the recognized text represented by this segment.
+  string sublabel;
+  // The ink ranges represented by this segment.
+  array<HandwritingRecognizerInkRange> ink_ranges;
+};
+
+// The ink segmentation information.
+[Stable]
+struct HandwritingRecognizerSegmentation {
+  // The grouping of the cut strokes into characters.
+  array<HandwritingRecognizerSegment> segments;
+};
+
+// One possible candidate from the handwriting recognition.
+[Stable]
+struct HandwritingRecognizerCandidate {
+  // The recognized text.
+  string text;
+  // Scores will most often correspond to -log(p(c)) or a scaling thereof, so
+  // lower scores represent higher confidence.
+  float score;
+  // The stroke segmentation that was used to generate the result.
+  HandwritingRecognizerSegmentation? segmentation;
+};
+
+// The handwriting recognition response.
+[Stable]
+struct HandwritingRecognizerResult {
+  // Status of the recognition response.
+  [Stable, Extensible]
+  enum Status {
+    OK = 0,
+    ERROR = 1,
+  };
+  Status status;
+
+  // The recognition candidates with additional alternatives, sorted by lower
+  // score first (lower score present higher confidence).
+  array<HandwritingRecognizerCandidate> candidates;
+};
+
+// The specification of a handwriting recognizer.
+[Stable]
+struct HandwritingRecognizerSpec {
+  // The language the recognizer will handle. Only "en" (for english) and
+  // "gesture_in_context" (for gesture) are supported.
+  string language;
+
+  // Path to the language pack to use (downloaded by Chrome via DLC).
+  [MinVersion=1] string? language_pack_path;
+};
+
+// The mojom interface for performing the recognition of handwritten text.
+// Next ordinal: 1
+[Stable]
+interface HandwritingRecognizer {
+  // Performs handwriting recognition on a set of ink strokes, and returns a set
+  // of alternative recognition results.
+  Recognize@0(HandwritingRecognitionQuery query) =>
+      (HandwritingRecognizerResult result);
+};
+
+// Enum indicates the result of LoadHandwritingModel in mlservice.
+[Stable, Extensible]
+enum LoadHandwritingModelResult {
+  OK = 0,
+
+  // Deprecated enum values.
+  DEPRECATED_MODEL_SPEC_ERROR = 1,
+  LOAD_MODEL_ERROR = 2,
+
+  // If both USE.ondevice_handwriting and USE.ondevice_handwriting_dlc
+  // are not defined. (checked in chrome)
+  FEATURE_NOT_SUPPORTED_ERROR = 3,
+
+  // If the required language is not in an allowlist, "en" and
+  // "gesture_in_context" for now. (checked in chrome)
+  LANGUAGE_NOT_SUPPORTED_ERROR = 4,
+
+  // If the user goes to chrome://flag page and manually disable
+  // handwriting or handwriting_dlc. (checked in chrome)
+  FEATURE_DISABLED_BY_USER = 5,
+
+  // if the USE.ondevice_handwriting_dlc is enabled, but dlc is not
+  // on the device. (checked in chrome)
+  DLC_DOES_NOT_EXIST = 6,
+
+  // If the dlc is on the device, but InstallDlc returns an error.
+  // (checked in chrome).
+  DLC_INSTALL_ERROR = 7,
+
+  // If dlc is installed successfully, but GetDlcState returns an error.
+  // (checked inside MachineLearningServiceImpl)
+  DLC_GET_PATH_ERROR = 8,
+
+  // if loading libhandwriting.so fails. (checked inside HandWritingLibrary)
+  LOAD_NATIVE_LIB_ERROR = 9,
+
+  // if getting the function pointers fails. (checked inside HandWritingLibrary)
+  LOAD_FUNC_PTR_ERROR = 10,
+
+  // If loading model files fails. (checked inside HandWritingLibrary)
+  LOAD_MODEL_FILES_ERROR = 11,
+};

19/public/mojom/machine_learning_service.mojom

@@ -0,0 +1,103 @@
+// 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.
+
+// Next MinVersion: 5
+
+// Top-level API of the Machine Learning Service: loading models for inference.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// NOTE: The base directory for 'import' statements is expected to differ
+//       between Chromium and Chrome OS versions of this file.
+import "chromeos/services/machine_learning/public/mojom/document_scanner.mojom";
+import "chromeos/services/machine_learning/public/mojom/grammar_checker.mojom";
+import "chromeos/services/machine_learning/public/mojom/handwriting_recognizer.mojom";
+import "chromeos/services/machine_learning/public/mojom/model.mojom";
+import "chromeos/services/machine_learning/public/mojom/soda.mojom";
+import "chromeos/services/machine_learning/public/mojom/text_classifier.mojom";
+import "chromeos/services/machine_learning/public/mojom/text_suggester.mojom";
+import "chromeos/services/machine_learning/public/mojom/web_platform_handwriting.mojom";
+
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+[Stable, Extensible]
+enum LoadModelResult {
+  OK = 0,
+  MODEL_SPEC_ERROR = 1,
+  LOAD_MODEL_ERROR = 2,
+  FEATURE_NOT_SUPPORTED_ERROR = 3,
+  LANGUAGE_NOT_SUPPORTED_ERROR = 4,
+};
+
+// Top-level interface between Chromium browser process and the ML Service
+// daemon.
+// Next ordinal: 11
+[Stable, Uuid="9e5e4750-40cc-4eda-ac09-3457d06a45ab"]
+interface MachineLearningService {
+  // Binds another pipe to this instance.
+  Clone@5(pending_receiver<MachineLearningService> receiver);
+
+  // The BuiltinModelId inside BuiltinModelSpec is used to specify the model to
+  // be loaded.
+  LoadBuiltinModel@0(BuiltinModelSpec spec, pending_receiver<Model> receiver)
+      => (LoadModelResult result);
+  // The FlatbufferModelSpec contains both of the flatbuffer content and the
+  // metadata.
+  LoadFlatBufferModel@1(FlatBufferModelSpec spec,
+                        pending_receiver<Model> receiver)
+      => (LoadModelResult result);
+  // Create a new TextClassifier.
+  LoadTextClassifier@2(pending_receiver<TextClassifier> receiver)
+      => (LoadModelResult result);
+  // Create and initialize a handwriting recognizer with given `spec`.
+  LoadHandwritingModel@3(
+      HandwritingRecognizerSpec spec,
+      pending_receiver<HandwritingRecognizer> receiver)
+      => (LoadHandwritingModelResult result);
+  // Create and initialize a speech recognizer with given `config`.
+  LoadSpeechRecognizer@6(SodaConfig config,
+      pending_remote<SodaClient> soda_client,
+      pending_receiver<SodaRecognizer> soda_recognizer)
+      => (LoadModelResult result);
+  // Create and initialize a grammar checker.
+  LoadGrammarChecker@7(pending_receiver<GrammarChecker> receiver)
+      => (LoadModelResult result);
+  // Create and initialize a text suggester.
+  [MinVersion=2] LoadTextSuggester@8(
+      pending_receiver<TextSuggester> receiver,
+      [MinVersion=3] TextSuggesterSpec? spec)
+      => (LoadModelResult result);
+  // Create a handwriting recognizer for web platform API.
+  // This API shares the same HWR engine with `LoadHandwritingModel`
+  // but with a different interface. This API is as identical to
+  // the Web Platform HWR API as possible so that we do not
+  // need to convert the input/output in the browser process.
+  // This is required for security reasons.
+  [MinVersion=1] LoadWebPlatformHandwritingModel@9(
+    chromeos.machine_learning.web_platform.mojom.HandwritingModelConstraint
+      constraint,
+    pending_receiver<
+      chromeos.machine_learning.web_platform.mojom.HandwritingRecognizer>
+      receiver)
+      => (LoadHandwritingModelResult result);
+  // Create and initialize a document scanner.
+  [MinVersion=4] LoadDocumentScanner@10(
+            pending_receiver<DocumentScanner> receiver)
+      => (LoadModelResult result);
+  // Deprecated `LoadHandwritingModelWithSpec`
+  REMOVED_4@4(
+      HandwritingRecognizerSpec spec,
+      pending_receiver<HandwritingRecognizer> receiver)
+      => (LoadModelResult result);
+};

19/public/mojom/model.mojom

@@ -0,0 +1,119 @@
+// 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.
+
+// Next MinVersion: 2
+
+// Datatypes and interfaces of models for the Machine Learning API.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// NOTE: The base directory for 'import' statements is expected to differ
+//       between Chromium and Chrome OS versions of this file.
+import "chromeos/services/machine_learning/public/mojom/graph_executor.mojom";
+
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+// ModelIds prefixed with UNSUPPORTED_ are no longer supported. Attempts to load
+// them will produce an error.
+[Stable, Extensible]
+enum BuiltinModelId {
+  // Unknown ML model. It is marked as unsupported.
+  UNSUPPORTED_UNKNOWN = 0,
+  // Test ML model.
+  TEST_MODEL = 1,
+  // The Smart Dim (20181115) ML model.
+  UNSUPPORTED_SMART_DIM_20181115 = 2,
+  // The Smart Dim (20190221) ML model.
+  UNSUPPORTED_SMART_DIM_20190221 = 3,
+  // The Top Cat (20190722) ML model.
+  UNSUPPORTED_TOP_CAT_20190722 = 4,
+  // The Smart Dim (20190521) ML model.
+  SMART_DIM_20190521 = 5,
+  // The Search Ranker (20190923) ML model.
+  SEARCH_RANKER_20190923 = 6,
+  // The Adaptive Charging (20211105) ML model.
+  [MinVersion=1] ADAPTIVE_CHARGING_20211105 = 7,
+};
+
+// Options for creating the executor.  Options are used for testing and
+// development. They are not typically used in normal, production code.
+[Stable]
+struct GraphExecutorOptions {
+  bool use_nnapi = false;
+  [MinVersion=1] bool use_gpu = false;
+};
+
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+[Stable, Extensible]
+enum CreateGraphExecutorResult {
+  OK = 0,
+  MODEL_INTERPRETATION_ERROR = 1,
+  MEMORY_ALLOCATION_ERROR = 2,
+  NNAPI_UNAVAILABLE = 3,
+  NNAPI_USE_ERROR = 4,
+  [MinVersion=1] GPU_UNAVAILABLE = 5,
+  [MinVersion=1] GPU_USE_ERROR = 6,
+  [MinVersion=1] DELEGATE_CONFIG_ERROR = 7,
+  [MinVersion=1] NOT_FULLY_DELEGABLE = 8,
+};
+
+// Model specification for builtin models.
+// Because ml-service can retrieve a builtin model's content and metadata, only
+// an `id` is needed to specify it.
+[Stable]
+struct BuiltinModelSpec {
+  BuiltinModelId id;
+};
+
+// Model specification for downloaded models.
+// For a downloaded model, both of the model content and metadata must be
+// specified.
+[Stable]
+struct FlatBufferModelSpec {
+  // The content of the model's tflite model file.
+  string model_string;
+  // A map from input nodes' names to their indices.
+  map<string, int32> inputs;
+  // A map from output nodes' names to their indices.
+  map<string, int32> outputs;
+  // Used in naming the UMA metric histograms of the model. An example of the
+  // names of the histograms is:
+  //
+  // MachineLearningService.`metrics_model_name`.ExecuteResult.CpuTimeMicrosec
+  //
+  // This variable must NOT be empty.
+  string metrics_model_name;
+};
+
+// The lifetime of the cached model is tied to the lifetime of the Model
+// interface pipe. The Model interface pipe can be used to acquire multiple
+// separate GraphExecutor instances.
+// Next ordinal: 2
+[Stable]
+interface Model {
+  // Deprecated messages:
+  REMOVED_0@0(pending_receiver<GraphExecutor> receiver) =>
+      (CreateGraphExecutorResult result);
+
+  // Creates a new GraphExecutor with the specified `options` and binds it to
+  // `receiver`. The GraphExecutor can be used to repeatedly evaluate this
+  // `Model`.
+  // * A Model can have more than one GraphExecutor.
+  // * Releasing this GraphExecutor frees the associated memory (but
+  //   doesn't free the Model unless its pipe is also closed).
+  CreateGraphExecutor@1(GraphExecutorOptions options,
+                        pending_receiver<GraphExecutor> receiver) =>
+      (CreateGraphExecutorResult result);
+};

19/public/mojom/roll_mojoms.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# Copyright 2019 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.
+
+usage() {
+  echo "Usage: $0 CROS_SRC_DIR"
+  echo ""
+  echo "Rolls (copies) ML Service *.mojom files from Chrome OS to current"
+  echo "directory, with appropriate boilerplate modifications for use in"
+  echo "Chromium."
+  echo ""
+  echo "CROS_SRC_DIR: Path to Chromium OS source, e.g. ~/chromiumos/src."
+}
+
+CROS_SRC_DIR="$1"
+
+if [ -z "$CROS_SRC_DIR" ]; then
+  usage
+  exit 1
+fi
+
+if [ ! -d "$CROS_SRC_DIR" ]; then
+  echo "$CROS_SRC_DIR not a directory"
+  usage
+  exit 1
+fi
+
+if [ "$(basename $CROS_SRC_DIR)" != "src" ]; then
+  echo "$CROS_SRC_DIR should end with /src"
+  usage
+  exit 1
+fi
+
+if ! git diff-index --quiet HEAD -- ; then
+  echo "'git status' not clean. Commit your changes first."
+  exit 1
+fi
+
+readonly EXPECTED_PATH="chromeos/services/machine_learning/public/mojom"
+if [[ "$(pwd)" != *"${EXPECTED_PATH}" ]]; then
+  echo "Please run from within ${EXPECTED_PATH}."
+  exit 1;
+fi
+
+echo "Copying mojoms from Chrome OS side ..."
+cp $1/platform2/ml/mojom/*.mojom . || exit 1
+
+echo "Removing time.mojom ..."
+rm time.mojom || exit 1
+
+echo "Removing shared_memory.mojom ..."
+rm shared_memory.mojom || exit 1
+
+echo "Removing geometry.mojom ..."
+rm geometry.mojom || exit 1
+
+echo "Changing import paths ..."
+sed --in-place --regexp-extended \
+  -e 's~^import "ml/mojom/geometry.mojom~import "ui/gfx/geometry/mojom/geometry.mojom~g' \
+  -e 's~^import "ml/mojom/shared_memory.mojom~import "mojo/public/mojom/base/shared_memory.mojom~g' \
+  -e 's~^import "ml/mojom/time.mojom~import "mojo/public/mojom/base/time.mojom~g' \
+  -e 's~^import "ml~import "chromeos/services/machine_learning/public~g' \
+  *.mojom
+
+echo "OK. Now:"
+echo "1. Examine 'git diff' to double-check the results of this tool."
+echo "2. After submitting, also update any google3 files generated from these "
+echo "   mojoms (e.g. javascript bindings)."

19/public/mojom/soda.mojom

@@ -0,0 +1,214 @@
+// Copyright 2020 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.
+
+// Datatypes and interfaces of speech recognition API.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+// Versions list:
+// Version 0: Initial
+// Version 1: Include HypothesisPart Info in Final result.
+// Version 2: Include enable formatting in request config.
+// Version 3: Include recognition mode in request config.
+module chromeos.machine_learning.mojom;
+
+import "mojo/public/mojom/base/time.mojom";
+
+// Augments a bool to include an 'unknown' value.
+[Stable, Extensible]
+enum OptionalBool {
+  [Default] kUnknown = 0,
+  kFalse,
+  kTrue,
+};
+
+[Stable, Extensible]
+enum SodaRecognitionMode {
+  [Default] kCaption,
+  kIme,
+};
+
+// The configuration used to load Soda recognizer.
+[Stable]
+struct SodaConfig {
+  // Number of channels of the audio that will be sent to Soda recognizer.
+  uint32 channel_count;
+  // Sample rate of the audio that will be sent to Soda recognizer.
+  uint32 sample_rate;
+  // The api key for Soda library.
+  string api_key;
+  // Path to already-installed SODA library.
+  string library_dlc_path;
+  // Path to already-installed SODA language pack to use.
+  string language_dlc_path;
+  // Whether to enable automated punctuation. Defaults to true as this
+  // is the default in the underlying protocol buffer.
+  [MinVersion=2] OptionalBool enable_formatting = kTrue;
+  // Which mode to execute in: IME or CAPTION. Default CAPTION.
+  [MinVersion=3] SodaRecognitionMode recognition_mode = kCaption;
+};
+
+// From the endpointer, What kind of endpointer event to record.
+[Stable, Extensible]
+enum EndpointerType {
+  // Speech detected.
+  START_OF_SPEECH,
+  // End of speech detected, but audio continues.
+  END_OF_SPEECH,
+  // Audio is terminated.
+  END_OF_AUDIO,
+  // Query is terminated.
+  END_OF_UTTERANCE
+};
+
+// Common information about the timing of reported SODA events.
+[Stable]
+struct TimingInfo {
+  // Epoch time of the first audio buffer of the main query that is fed into
+  // ASR. This is the wall time read from the system clock when the first audio
+  // buffer is received by the terse processor.
+  mojo_base.mojom.Time audio_start_epoch;
+
+  // Start time in audio time from the start of the SODA session.
+  // This time measures the amount of audio input into SODA.
+  mojo_base.mojom.TimeDelta audio_start_time;
+
+  // Elapsed wall time usec since the first frame.
+  mojo_base.mojom.TimeDelta elapsed_wall_time;
+
+  // Elapsed processed audio usec from first frame after preamble.
+  mojo_base.mojom.TimeDelta event_end_time;
+
+  // On device benchmark latency as defined in go/asr-latency-metrics.
+  mojo_base.mojom.TimeDelta latency;
+
+  // On device counter part of E2E normalized latency as defined in
+  // go/asr-latency-metrics. This metric is mainly for non-continuous
+  // conversation.
+  float normalized_latency;
+
+  // Timing for each word as an offset from audio_start_time_usec.
+  array<mojo_base.mojom.TimeDelta> word_alignments;
+};
+
+// Start/end events.
+[Stable]
+struct EndpointerEvent {
+  EndpointerType endpointer_type;
+  TimingInfo? timing_event;
+};
+
+// A result _during_ a recognition. Could change at any time with the
+// next partial or the final recognition for this chunk.
+[Stable]
+struct PartialResult {
+  // Most likely hypothesis so far. First is the most likely, followed by others.
+  // Note: the relationship from first to other hypothess is not guaranteed in
+  // any way.
+  array<string> partial_text;
+  TimingInfo? timing_event;
+};
+
+[Stable, Extensible]
+enum EndpointReason {
+  // Default value, unknown reason.
+  ENDPOINT_UNKNOWN,
+  // Due to end_of_speech detection by endpointer.
+  ENDPOINT_END_OF_SPEECH,
+  // Due to end_of_utterance detection by endpointer.
+  ENDPOINT_END_OF_UTTERANCE,
+  // Due to the end of mics audio. This could be due to a mic event or SODA
+  // being stopped.
+  ENDPOINT_END_OF_AUDIO,
+};
+
+
+// Detail about a part of a hypothesis in a result. Only makes sense
+// in context of an array of them for a hypothesis.
+[Stable]
+struct HypothesisPartInResult {
+  // Typically 1 item for a a word/piece of text. If formatting is
+  // enabled, the raw text is the second item.
+  array<string> text;
+
+  // Offset from the beginning of this part of the hypothesis from
+  // audio_start_time in TimingInfo.
+  mojo_base.mojom.TimeDelta alignment;
+};
+
+[Stable]
+struct FinalResult {
+  // Sorted in decreasing order of probability.
+  array<string> final_hypotheses;
+  EndpointReason endpoint_reason;
+  TimingInfo? timing_event;
+
+  // If populated, this array contains the hypothesis parts for the
+  // first final hypothesis in the array of final_hypotheses.
+  [MinVersion=1] array<HypothesisPartInResult>? hypothesis_part;
+};
+
+// Frequent event from recognizer, almost from every frame. Gives an indication
+// of speechiness and audio level.
+[Stable]
+struct AudioLevelEvent {
+  // RMS audio level, from PowerEvaluator . Score is [0, 1)
+  float rms;
+  // Speech likelihood score, from TerseProcessor. Score is [0, 1)
+  float audio_level;
+};
+
+// This essentially mirrors the subset of SODA's SodaEvent proto we will
+// support.
+[Stable]
+union SpeechRecognizerEvent {
+  AudioLevelEvent audio_event;
+  PartialResult partial_result;
+  EndpointerEvent endpointer_event;
+  FinalResult final_result;
+};
+
+// This interface is called upon by the SodaRecognizer. Implemented by
+// the client, SODA then calls these as 'events' with appropriate details
+// when recognition occurs.
+// Next ordinal: 3
+[Stable]
+interface SodaClient {
+  // After SODA successfully starts / warms up / stops, in case the client
+  // cares:
+  OnStart@0();
+  OnStop@1();
+
+  // This is how the client receives actual recognized text as well as other
+  // conclusions from the SODA model like "speech ended".
+  OnSpeechRecognizerEvent@2(SpeechRecognizerEvent event);
+};
+
+// The mojom interface for performing the recognition of handwritten text.
+// Next ordinal: 4
+[Stable]
+interface SodaRecognizer {
+  // Add Audio for speech recognition.
+  AddAudio@0(array<uint8> audio);
+
+  // Instruct SODA to stop processing immediately. Stopping is
+  // confirmed when SodaClient::OnStop is called back.
+  Stop@1();
+
+  // Instruct SODA to start processing. Noop if already
+  // processing. When Stopped, causes a SodAclient::OnStart callback.
+  Start@2();
+
+  // Instruct SODA to stop processing after all queued audio is
+  // processed.  Will eventually result in a SodaClient::OnStop, but only
+  // after all audio currently in queue is decoded.
+  MarkDone@3();
+};

19/public/mojom/tensor.mojom

@@ -0,0 +1,64 @@
+// 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.
+
+// Datatypes used in the Machine Learning API.
+// This module is derived from the Feature proto definition of TensorFlow.
+// See /tensorflow/core/example/feature.proto in the TensorFlow code.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+[Stable]
+struct StringList {
+  array<string> value;
+};
+
+[Stable]
+struct FloatList {
+  array<double> value;
+};
+
+[Stable]
+struct Int64List {
+  array<int64> value;
+};
+
+// The union of all supported tensor types. Supporting a new type comprises the
+// following:
+//  - Adding a new struct above (e.g. BoolList),
+//  - Adding this new struct to the union below,
+//  - Adding template specializations for the new type to
+//    platform2/ml/tensor_view.{h,cc}.
+//  - Updating platform2/ml/graph_executor_impl.cc to use a TensorView of the
+//    new type.
+//
+// TODO(chromium:836098): add new types (e.g. uint8, bool) as they become
+//                        useful.
+[Stable]
+union ValueList {
+  StringList string_list;
+  FloatList float_list;
+  Int64List int64_list;
+};
+
+// A Tensor is a multi-dimensional array with dimensions `shape`, flattened into
+// the one-dimensional array `data`.
+// It is used for both the inputs (in the form of a map<string, Tensor>) and
+// outputs (in the form of an array<Tensor>) of ML inference.
+[Stable]
+struct Tensor {
+  ValueList data;
+
+  // Each integer is the size of that dimension.
+  Int64List shape;
+};

19/public/mojom/text_classifier.mojom

@@ -0,0 +1,160 @@
+// Copyright 2020 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.
+
+// API of the text classifier (libtextclassifier).
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// NOTE: The base directory for 'import' statements is expected to differ
+//       between Chromium and Chrome OS versions of this file.
+//       And for "time.mojom", on the chromium side, we have to use the version
+//       under mojo folder, that is, "mojo/public/mojom/base/time.mojom".
+import "mojo/public/mojom/base/time.mojom";
+
+// Enum for specifying the annotation usecase.
+// Must be consistent with `AnnotationUsecase` in model.fb in libtextclassifier.
+[Stable, Extensible]
+enum AnnotationUsecase {
+  // Results are optimized for Smart{Select,Share,Linkify}
+  ANNOTATION_USECASE_SMART = 0,
+  // Results are optimized for using TextClassifier as an infrastructure that
+  // annotates as much as possible.
+  ANNOTATION_USECASE_RAW = 1,
+};
+
+// Stores data extracted from each text entity.
+// Currently, only for "number" type, the real number value is stored in
+// `numeric_value`. For the other types, the substring annotated is stored
+// in `string_value`.
+// The values come from the class `ClassificationResult` of tclib. (See
+// "tclib/annotator/types.h").
+// TODO(honglinyu): add data extraction for more types when needed and
+// available. For example, when "date" data is needed, probably we should add
+// a new struct "Date" and add a new member "Data date_value" to the following
+// union.
+[Stable]
+union TextEntityData {
+  // A numeric value.
+  //  - For "number", it is the value.
+  //    e.g. it is "34.3" for input string "34.3".
+  double numeric_value@0;
+  // Could be "url", "address" etc.
+  string string_value@1;
+};
+
+// Types of text (can be phone numbers, addresses, emails and urls etc.).
+// This struct is a distillation of the `ClassificationResult` of tclib. (See
+// "tclib/annotator/types.h").
+[Stable]
+struct TextEntity {
+  // The name of the type (e.g. "phone", "address", "email" and "url" etc.).
+  string name@0;
+  // The confidence score of the entity annotation, and the range is 0-1.
+  float confidence_score@1;
+  // Additional data extracted from the text.
+  TextEntityData data@2;
+};
+
+// A substring of the annotated text and possible associated entities.
+// This struct is a simplification of the `AnnotatedSpan` class of tclib. (See
+// "tclib/annotator/types.h").
+[Stable]
+struct TextAnnotation {
+  // The offset of the first character of the annotation.
+  uint32 start_offset@0;
+  // The offset of the last character of the annotation.
+  uint32 end_offset@1;
+  // The set of entity types associated with the substring.
+  array<TextEntity> entities@2;
+};
+
+// Contains the input and parameters used to annotate the text.
+// This is a combination of string and `AnnotationOptions` in tclib (see
+// "tclib/annotator/types.h").
+[Stable]
+struct TextAnnotationRequest {
+  // The text to be annotated.
+  string text@0;
+  // Comma-delimited locales (e.g., "en", "en,es").
+  string? default_locales@1;
+  // Comma-separated list of language tags.
+  string? detected_text_language_tags@2;
+  // Tailors the output annotations according to the specified use-case.
+  AnnotationUsecase annotation_usecase@3 = ANNOTATION_USECASE_SMART;
+  // For parsing relative datetimes, the reference now time against which the
+  // relative datetimes get resolved.
+  mojo_base.mojom.Time? reference_time@4;
+  // Timezone in which the input text was written (format as accepted by ICU).
+  // If empty (default), will use the system's timezone.
+  string? reference_timezone@5;
+  // Enabled entities. If empty (default), all types of entities will be
+  // enabled.
+  array<string>? enabled_entities@6;
+};
+
+// Marks a span in a sequence of codepoints.
+// This struct is consistent with the type `CodepointSpan` of tclib. (See
+// "tclib/annotator/types.h").
+[Stable]
+struct CodepointSpan {
+  // The offset of the first character of the span.
+  uint32 start_offset@0;
+  // The offset of the last character of the span.
+  uint32 end_offset@1;
+};
+
+// Represent a language detection result.
+[Stable]
+struct TextLanguage {
+  // The BCP-47 language code like "en", "fr", "zh" etc.
+  string locale;
+  // The confidence score of the language detected (range: 0~1).
+  float confidence;
+};
+
+// Contains the input and parameters used to suggest selection.
+// This is a combination of the inputs of the `SuggestSelection` function
+// of tclib. (See "tclib/annotator/annotate.h").
+[Stable, RenamedFrom="chromeos.machine_learning.mojom.TextSuggestSelectionRequest"]
+struct REMOVED_TextSuggestSelectionRequest {
+  // The candidate text.
+  string text@0;
+  // Where the user selects.
+  CodepointSpan user_selection@1;
+  // Comma-delimited locales (e.g., "en", "en,es").
+  string? default_locales@2;
+  // Comma-separated list of BCP 47 language tags.
+  string? detected_text_language_tags@3;
+  // Tailors the output annotations according to the specified use-case.
+  AnnotationUsecase annotation_usecase@4 = ANNOTATION_USECASE_SMART;
+};
+
+// Used to annotate entities within text strings.
+// Next ordinal: 3
+[Stable]
+interface TextClassifier {
+  // Annotate a text string and returns the detected substrings and possible
+  // entities.
+  Annotate@0(TextAnnotationRequest request) =>
+      (array<TextAnnotation> outputs);
+  // Identify the languages the text is possibly written in.
+  // The returned results are sorted according to the confidence score, from the
+  // highest to the lowest.
+  // The maximum number of results returned is determined internally.
+  // Will return an empty array if the language can not be determined.
+  FindLanguages@2(string text) => (array<TextLanguage> outputs);
+  // Deprecated `SuggestSelection`
+  REMOVED_1@1(REMOVED_TextSuggestSelectionRequest request) =>
+      (CodepointSpan outputs);
+};

19/public/mojom/text_suggester.mojom

@@ -0,0 +1,131 @@
+// Copyright 2021 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.
+
+// Next MinVersion: 3
+
+// Datatypes and interfaces of text suggester API.
+
+// NOTE: This mojom exists in two places and must be kept in sync:
+//       Chromium:  //chromeos/services/machine_learning/public/mojom/
+//       Chrome OS: src/platform2/ml/mojom/
+//       Note: Other repos downstream of Chromium might also use this mojom.
+
+// Example: A backwards-compatible mojom change (and corresponding
+// implementation change) can be made in Chrome OS first, then replicated to the
+// clients (Chromium, other downstream repos) later.
+// Use //chromeos/services/machine_learning/public/mojom/roll_mojoms.sh to help
+// replicate Chrome OS-side changes over to Chromium.
+
+module chromeos.machine_learning.mojom;
+
+// Represents a single completion candidate
+// Next ordinal: 2
+[Stable]
+struct NextWordCompletionCandidate {
+  // The completing text suggested
+  string text@0;
+
+  // The normalized confidence score for the generated candidate
+  float normalized_score@1;
+};
+
+// The mode with which a suggestion should be used by a consumer
+[Stable, Extensible]
+enum TextSuggestionMode {
+   // A prediction suggestion is the text predicted after a word. For example
+   // the preceding text could be "how are", and the suggested text would be
+   // "you".
+   [Default] kPrediction = 1,
+
+   // A completion suggestion is similar to a prediction, however the suggestion
+   // also completes any unfinished words in the preceding text. For example,
+   // the preceding text could be "how ar", and the suggested text would be
+   // "e you".
+   kCompletion = 2,
+};
+
+// Defines a query for text suggestions
+// Next ordinal: 3
+[Stable]
+struct TextSuggesterQuery {
+  // The text used to generate suggestions
+  string text@0;
+
+  // Optional: completion candidates for the final word in the text
+  array<NextWordCompletionCandidate> next_word_candidates@1;
+
+  // The types of suggestions requested
+  [MinVersion=1] TextSuggestionMode suggestion_mode@2;
+};
+
+// Represents a single generated multi word suggestion candidate.
+// Next ordinal: 2
+[Stable]
+struct MultiWordSuggestionCandidate {
+  // The text suggested
+  string text@0;
+
+  // The normalized confidence score for this candidate
+  float normalized_score@1;
+};
+
+// Represents all types of suggestion candidates generated by the service.
+//
+// TODO(crbug/1201949): Note that the Extensible keyword is not supported for
+// union types. We may need to revisit this type in the future.
+//
+// Next ordinal: 1
+[Stable, Extensible]
+union TextSuggestionCandidate {
+  MultiWordSuggestionCandidate multi_word@0;
+};
+
+// The result to text suggestion queries, contains any candidates generated.
+// Next ordinal: 2
+[Stable]
+struct TextSuggesterResult {
+  // Status of the response
+  [Stable, Extensible, Default=ERROR]
+  enum Status {
+    // Text suggestions generated successfully
+    OK = 0,
+    // There was an error while generating candidates, no candidates will be
+    // returned with this result.
+    ERROR = 1,
+  };
+
+  Status status@0;
+
+  // The list of candidates generated by the text suggester service
+  array<TextSuggestionCandidate> candidates@1;
+};
+
+// Experiment groups for multi word suggestions
+// Next value: 5
+[Stable, Extensible]
+enum MultiWordExperimentGroup {
+  [Default] kDefault = 0,
+  kGboard = 1,
+  // Experiment groups used for the relaxed gboard settings finch experiment
+  [MinVersion=2] kGboardRelaxedA = 2,
+  [MinVersion=2] kGboardRelaxedB = 3,
+  [MinVersion=2] kGboardRelaxedC = 4
+};
+
+// Encapsulates any settings details for a TextSuggester
+// Next ordinal: 1
+[Stable]
+struct TextSuggesterSpec {
+  // The experimental group for multi word suggestions
+  MultiWordExperimentGroup multi_word_experiment@0;
+};
+
+// The top level interface for requesting text based suggestions in the Chromium
+// browser process from the sandboxed ML service process.
+// Next ordinal: 1
+[Stable]
+interface TextSuggester {
+  // Generates text suggestions from the given context
+  Suggest@0(TextSuggesterQuery query) => (TextSuggesterResult result);
+};

19/public/mojom/web_platform_handwriting.mojom

@@ -0,0 +1,134 @@
+// Copyright 2021 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.
+
+// Next MinVersion: 2
+
+module chromeos.machine_learning.web_platform.mojom;
+
+// https://github.com/WICG/handwriting-recognition/blob/main/explainer.md
+
+// This mojom file is copied from the file below in chromium repo,
+// "//third_party/blink/public/mojom/handwriting/handwriting.mojom"
+// Notice that some modifications are made,
+//   1. The module is changed to `chromeos.machine_learning.web_platform.mojom`.
+//   2. `[Stable]` tags are added.
+//   3. Interface `HandwritingRecognitionService`
+//      and `CreateHandwritingRecognizerResult` are removed because they not
+//      used here.
+//   4. The paths of imported mojoms are changed.
+//   5. Feature query related structs are removed because they are not being
+//      used for now.
+// For the overlapping definitions, the two files should be kept consistent.
+
+import "mojo/public/mojom/base/time.mojom";
+import "ui/gfx/geometry/mojom/geometry.mojom";
+
+// Represents a single point in a handwriting stroke.
+// Corresponds to handwriting_point.idl.
+[Stable]
+struct HandwritingPoint {
+  // Represent the horizontal (location.x) and vertical (location.y) location
+  // of the point.
+  // The top-left corner coordinate is (location.x=0, location.y=0).
+  gfx.mojom.PointF location;
+  // The time elapsed since the starting time (e.g. when the first ink point
+  // of the drawing is captured).
+  mojo_base.mojom.TimeDelta? t;
+};
+
+// Represents a stroke which is just a series of points.
+// Corresponds to handwriting_stroke.idl.
+[Stable]
+struct HandwritingStroke {
+  array<HandwritingPoint> points;
+};
+
+// Represents a segment of a handwriting stroke in the grapheme detected.
+// One `HandwritingDrawingSegment` can only refer one stroke, denoted by
+// `stroke_index` which is the index of the stroke in the input stroke arrays
+// (i.e., the first parameter of the `HandwritingRecognizer::GetPrediction`
+// function).
+// The reason we need this struct is that different parts of one single stroke
+// can belong to different grapheme detected.
+// Corresponds to handwriting_drawing_segment.idl.
+[Stable]
+struct HandwritingDrawingSegment {
+  // The index of the corresponding stroke in the input stroke array.
+  uint32 stroke_index;
+  // The index of the first point in the stroke that belongs to this drawing
+  // segment.
+  uint32 begin_point_index;
+  // The index of the last point in the stroke that belongs to this drawing
+  // segment.
+  uint32 end_point_index;
+};
+
+// Represents a segment detected.
+// Corresponds to handwriting_segment.idl.
+[Stable]
+struct HandwritingSegment {
+  // The string representation of this grapheme.
+  string grapheme;
+  // HandwritingPrediction.text.slice(begin_index, end_index) === grapheme
+  // If the grapheme spans multiple Unicode code points,
+  // `end_index - begin_index` is greater than 1.
+  uint32 begin_index;
+  uint32 end_index;
+  array<HandwritingDrawingSegment> drawing_segments;
+};
+
+// Represents one single prediction result.
+// The final prediction output is an array of it.
+// Corresponds to handwriting_prediction.idl.
+[Stable]
+struct HandwritingPrediction {
+  string text;
+  array<HandwritingSegment> segmentation_result;
+};
+
+// Represents the hints provided to the recognizer for better performance.
+// Corresponds to handwriting_hints.idl.
+[Stable]
+struct HandwritingHints {
+  // The type of content to be recognized. The recognizer may use these to
+  // better rank the recognition results. (e.g. "text", "email", "number",
+  // "per-character").
+  string recognition_type@0;
+  // Identifies how the strokes are captured. (e.g. "touch", "mouse", "pen")
+  string input_type@1;
+  // Deprecated because we want to change `text_context` to be optional, see
+  // the comment of `text_context` below.
+  string deprecated_text_context@2;
+  // The maximum number of alternative predictions to generate.
+  uint32 alternatives@3;
+  // The text that comes before the handwriting. This can be texts that were
+  // previously recognized, or were given as the writing context (e.g.
+  // "Write your name here:"). This is the linguistic context to help
+  // disambiguate the handwriting (e.g. “Hello world” vs. “Hello word”).
+  [MinVersion=1] string? text_context@4;
+};
+
+// Used in creating recognizer.
+// Corresponds to handwriting_model_constraint.idl.
+[Stable]
+struct HandwritingModelConstraint {
+  // Languages are IETF BCP 47 language tags, e.g., "en", "zh-CN", "zh-Hans".
+  array<string> languages;
+};
+
+// Interface for a renderer to use a specific handwriting recognition backend.
+// The browser handles the requests and forwards them to the appropriate
+// backend.
+[Stable]
+interface HandwritingRecognizer {
+  // Does the recognition and outputs the prediction result.
+  // This is used by IDL API `blink::HandwritingDrawing::getPrediction`.
+  // The input `strokes` and `hints` should both come from
+  // `blink::HandwritingDrawing`.
+  // If the returned `Optional` has no value, it means there is some error in
+  // recognition. If the returned `Optional` has value but the array is empty,
+  // it means the recognizer can not recognize anything from the input.
+  GetPrediction@0(array<HandwritingStroke> strokes, HandwritingHints hints)
+    => (array<HandwritingPrediction>? prediction);
+};