document_scan: Use LorgnetteScannerManager

Update the Document Scan API to use the LorgnetteScannerManager to get
available scanners and perform scans.

Bug: b:153541027
Change-Id: I57f70d0959a6a676a34e2956a3908ddb165ed84f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2318311
Commit-Queue: Jesse Schettler <jschettler@chromium.org>
Reviewed-by: David Bertoni <dbertoni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798394}

chrome/browser/chromeos/BUILD.gn

@@ -3477,6 +3477,8 @@ source_set("unit_tests") {
     "release_notes/release_notes_notification_unittest.cc",
     "release_notes/release_notes_storage_unittest.cc",
     "remote_apps/remote_apps_model_unittest.cc",
+    "scanning/fake_lorgnette_scanner_manager.cc",
+    "scanning/fake_lorgnette_scanner_manager.h",
     "scanning/lorgnette_scanner_manager_unittest.cc",
     "scanning/lorgnette_scanner_manager_util_unittest.cc",
     "scanning/zeroconf_scanner_detector_unittest.cc",

chrome/browser/chromeos/extensions/document_scan/document_scan_api.cc

@@ -9,10 +9,9 @@
 
 #include "base/base64.h"
 #include "base/bind.h"
-#include "base/logging.h"
-#include "base/stl_util.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/lorgnette_manager_client.h"
+#include "chrome/browser/chromeos/scanning/lorgnette_scanner_manager.h"
+#include "chrome/browser/chromeos/scanning/lorgnette_scanner_manager_factory.h"
+#include "content/public/browser/browser_context.h"
 #include "third_party/cros_system_api/dbus/lorgnette/dbus-constants.h"
 
 namespace extensions {
@@ -24,7 +23,6 @@ namespace {
 // Error messages that can be included in a response when scanning fails.
 constexpr char kUserGestureRequiredError[] =
     "User gesture required to perform scan";
-constexpr char kListScannersError[] = "Failed to obtain list of scanners";
 constexpr char kNoScannersAvailableError[] = "No scanners available";
 constexpr char kUnsupportedMimeTypesError[] = "Unsupported MIME types";
 constexpr char kScanImageError[] = "Failed to scan image";
@@ -35,11 +33,6 @@ constexpr char kScannerImageMimeTypePng[] = "image/png";
 // The PNG image data URL prefix of a scanned image.
 constexpr char kPngImageDataUrlPrefix[] = "data:image/png;base64,";
 
-chromeos::LorgnetteManagerClient* GetLorgnetteManagerClient() {
-  DCHECK(chromeos::DBusThreadManager::IsInitialized());
-  return chromeos::DBusThreadManager::Get()->GetLorgnetteManagerClient();
-}
-
 }  // namespace
 
 DocumentScanScanFunction::DocumentScanScanFunction() = default;
@@ -53,19 +46,16 @@ ExtensionFunction::ResponseAction DocumentScanScanFunction::Run() {
   if (!user_gesture())
     return RespondNow(Error(kUserGestureRequiredError));
 
-  GetLorgnetteManagerClient()->ListScanners(
-      base::BindOnce(&DocumentScanScanFunction::OnScannerListReceived, this));
+  chromeos::LorgnetteScannerManagerFactory::GetForBrowserContext(
+      browser_context())
+      ->GetScannerNames(
+          base::BindOnce(&DocumentScanScanFunction::OnNamesReceived, this));
   return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
-void DocumentScanScanFunction::OnScannerListReceived(
-    base::Optional<lorgnette::ListScannersResponse> response) {
-  if (!response) {
-    Respond(Error(kListScannersError));
-    return;
-  }
-
-  if (response->scanners_size() == 0) {
+void DocumentScanScanFunction::OnNamesReceived(
+    std::vector<std::string> scanner_names) {
+  if (scanner_names.empty()) {
     Respond(Error(kNoScannersAvailableError));
     return;
   }
@@ -83,13 +73,14 @@ void DocumentScanScanFunction::OnScannerListReceived(
   // The first scanner supporting one of the requested MIME types used to be
   // selected. Since all of the scanners only support PNG, this results in
   // selecting the first scanner in the list.
-  const auto& scanner = response->scanners()[0];
+  const std::string& scanner_name = scanner_names[0];
   chromeos::LorgnetteManagerClient::ScanProperties properties;
   properties.mode = lorgnette::kScanPropertyModeColor;
-  GetLorgnetteManagerClient()->StartScan(
-      scanner.name(), properties,
-      base::BindOnce(&DocumentScanScanFunction::OnResultsReceived, this),
-      base::nullopt);
+  chromeos::LorgnetteScannerManagerFactory::GetForBrowserContext(
+      browser_context())
+      ->Scan(
+          scanner_name, properties,
+          base::BindOnce(&DocumentScanScanFunction::OnResultsReceived, this));
 }
 
 void DocumentScanScanFunction::OnResultsReceived(

chrome/browser/chromeos/extensions/document_scan/document_scan_api.h

@@ -7,10 +7,10 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/optional.h"
 #include "chrome/common/extensions/api/document_scan.h"
-#include "chromeos/dbus/lorgnette/lorgnette_service.pb.h"
 #include "extensions/browser/extension_function.h"
 
 namespace extensions {
@@ -33,8 +33,7 @@ class DocumentScanScanFunction : public ExtensionFunction {
  private:
   friend class DocumentScanScanFunctionTest;
 
-  void OnScannerListReceived(
-      base::Optional<lorgnette::ListScannersResponse> response);
+  void OnNamesReceived(std::vector<std::string> scanner_names);
   void OnResultsReceived(base::Optional<std::string> scanned_image);
 
   std::unique_ptr<document_scan::Scan::Params> params_;

chrome/browser/chromeos/extensions/document_scan/document_scan_api_unittest.cc

@@ -2,18 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <string>
 #include <utility>
 
+#include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/optional.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/extensions/document_scan/document_scan_api.h"
+#include "chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.h"
+#include "chrome/browser/chromeos/scanning/lorgnette_scanner_manager_factory.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_lorgnette_manager_client.h"
-#include "chromeos/dbus/lorgnette/lorgnette_service.pb.h"
+#include "components/keyed_service/core/keyed_service.h"
+#include "content/public/browser/browser_context.h"
 #include "extensions/browser/api_test_utils.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -25,15 +28,13 @@ namespace api {
 
 namespace {
 
-lorgnette::ListScannersResponse CreateListScannersResponse() {
-  lorgnette::ScannerInfo scanner;
-  scanner.set_name("Dank Scanner");
-  scanner.set_manufacturer("Scanners, Inc.");
-  scanner.set_model("TX1000");
-  scanner.set_type("Flatbed");
-  lorgnette::ListScannersResponse response;
-  *response.add_scanners() = std::move(scanner);
-  return response;
+// Scanner name used for tests.
+constexpr char kTestScannerName[] = "Test Scanner";
+
+// Creates a new FakeLorgnetteScannerManager for the given |context|.
+std::unique_ptr<KeyedService> BuildLorgnetteScannerManager(
+    content::BrowserContext* context) {
+  return std::make_unique<chromeos::FakeLorgnetteScannerManager>();
 }
 
 }  // namespace
@@ -46,18 +47,16 @@ class DocumentScanScanFunctionTest : public ExtensionApiUnittest {
 
   void SetUp() override {
     ExtensionApiUnittest::SetUp();
-    chromeos::DBusThreadManager::Initialize();
     function_->set_user_gesture(true);
+    chromeos::LorgnetteScannerManagerFactory::GetInstance()->SetTestingFactory(
+        browser()->profile(),
+        base::BindRepeating(&BuildLorgnetteScannerManager));
   }
 
-  void TearDown() override {
-    chromeos::DBusThreadManager::Shutdown();
-    ExtensionApiUnittest::TearDown();
-  }
-
-  chromeos::FakeLorgnetteManagerClient* GetLorgnetteManagerClient() {
-    return static_cast<chromeos::FakeLorgnetteManagerClient*>(
-        chromeos::DBusThreadManager::Get()->GetLorgnetteManagerClient());
+  chromeos::FakeLorgnetteScannerManager* GetLorgnetteScannerManager() {
+    return static_cast<chromeos::FakeLorgnetteScannerManager*>(
+        chromeos::LorgnetteScannerManagerFactory::GetForBrowserContext(
+            browser()->profile()));
   }
 
  protected:
@@ -78,37 +77,27 @@ TEST_F(DocumentScanScanFunctionTest, UserGestureRequiredError) {
             RunFunctionAndReturnError("[{}]"));
 }
 
-TEST_F(DocumentScanScanFunctionTest, ListScannersError) {
-  GetLorgnetteManagerClient()->SetListScannersResponse(base::nullopt);
-  EXPECT_EQ("Failed to obtain list of scanners",
-            RunFunctionAndReturnError("[{}]"));
-}
-
 TEST_F(DocumentScanScanFunctionTest, NoScannersAvailableError) {
-  lorgnette::ListScannersResponse response;
-  GetLorgnetteManagerClient()->SetListScannersResponse(response);
+  GetLorgnetteScannerManager()->SetGetScannerNamesResponse({});
   EXPECT_EQ("No scanners available", RunFunctionAndReturnError("[{}]"));
 }
 
 TEST_F(DocumentScanScanFunctionTest, UnsupportedMimeTypesError) {
-  GetLorgnetteManagerClient()->SetListScannersResponse(
-      CreateListScannersResponse());
+  GetLorgnetteScannerManager()->SetGetScannerNamesResponse({kTestScannerName});
   EXPECT_EQ("Unsupported MIME types",
             RunFunctionAndReturnError("[{\"mimeTypes\": [\"image/tiff\"]}]"));
 }
 
 TEST_F(DocumentScanScanFunctionTest, ScanImageError) {
-  GetLorgnetteManagerClient()->SetListScannersResponse(
-      CreateListScannersResponse());
-  GetLorgnetteManagerClient()->SetScanResponse(base::nullopt);
+  GetLorgnetteScannerManager()->SetGetScannerNamesResponse({kTestScannerName});
+  GetLorgnetteScannerManager()->SetScanResponse(base::nullopt);
   EXPECT_EQ("Failed to scan image",
             RunFunctionAndReturnError("[{\"mimeTypes\": [\"image/png\"]}]"));
 }
 
 TEST_F(DocumentScanScanFunctionTest, Success) {
-  GetLorgnetteManagerClient()->SetListScannersResponse(
-      CreateListScannersResponse());
-  GetLorgnetteManagerClient()->SetScanResponse("PrettyPicture");
+  GetLorgnetteScannerManager()->SetGetScannerNamesResponse({kTestScannerName});
+  GetLorgnetteScannerManager()->SetScanResponse("PrettyPicture");
   std::unique_ptr<base::DictionaryValue> result(RunFunctionAndReturnDictionary(
       function_.get(), "[{\"mimeTypes\": [\"image/png\"]}]"));
   ASSERT_NE(nullptr, result.get());

chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.cc

+// Copyright 2014 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 "chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+
+namespace chromeos {
+
+FakeLorgnetteScannerManager::FakeLorgnetteScannerManager() = default;
+
+FakeLorgnetteScannerManager::~FakeLorgnetteScannerManager() = default;
+
+void FakeLorgnetteScannerManager::GetScannerNames(
+    GetScannerNamesCallback callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), scanner_names_));
+}
+
+void FakeLorgnetteScannerManager::Scan(
+    const std::string& scanner_name,
+    const LorgnetteManagerClient::ScanProperties& scan_properties,
+    ScanCallback callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), std::move(scan_data_)));
+}
+
+void FakeLorgnetteScannerManager::SetGetScannerNamesResponse(
+    const std::vector<std::string>& scanner_names) {
+  scanner_names_ = scanner_names;
+}
+
+void FakeLorgnetteScannerManager::SetScanResponse(
+    const base::Optional<std::string>& scan_data) {
+  scan_data_ = scan_data;
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.h

+// 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 CHROME_BROWSER_CHROMEOS_SCANNING_FAKE_LORGNETTE_SCANNER_MANAGER_H_
+#define CHROME_BROWSER_CHROMEOS_SCANNING_FAKE_LORGNETTE_SCANNER_MANAGER_H_
+
+#include <string>
+#include <vector>
+
+#include "base/optional.h"
+#include "chrome/browser/chromeos/scanning/lorgnette_scanner_manager.h"
+#include "chromeos/dbus/lorgnette_manager_client.h"
+
+namespace chromeos {
+
+// Fake implementation of LorgnetteScannerManager for tests.
+class FakeLorgnetteScannerManager final : public LorgnetteScannerManager {
+ public:
+  FakeLorgnetteScannerManager();
+  FakeLorgnetteScannerManager(const FakeLorgnetteScannerManager&) = delete;
+  FakeLorgnetteScannerManager& operator=(const FakeLorgnetteScannerManager&) =
+      delete;
+  ~FakeLorgnetteScannerManager() override;
+
+  // LorgnetteScannerManager:
+  void GetScannerNames(GetScannerNamesCallback callback) override;
+  void Scan(const std::string& scanner_name,
+            const LorgnetteManagerClient::ScanProperties& scan_properties,
+            ScanCallback callback) override;
+
+  // Sets the response returned by GetScannerNames().
+  void SetGetScannerNamesResponse(
+      const std::vector<std::string>& scanner_names);
+
+  // Sets the response returned by Scan().
+  void SetScanResponse(const base::Optional<std::string>& scan_data);
+
+ private:
+  std::vector<std::string> scanner_names_;
+  base::Optional<std::string> scan_data_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_SCANNING_FAKE_LORGNETTE_SCANNER_MANAGER_H_