Remove MockLorgnetteManagerClient.

Instead, fake implementation is added into FakeLorgnetteManagerClient,
and it replaces MockLorgnetteManagerClient in unittests.

BUG=223061
TEST=Ran trybot.

Change-Id: I6d9cde402dda453e5b5bdc59c26c384dea6bfd90
Reviewed-on: https://chromium-review.googlesource.com/726039Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Toni Barzic <tbarzic@chromium.org>
Commit-Queue: Hidehiko Abe <hidehiko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#510026}

chromeos/BUILD.gn

@@ -554,8 +554,6 @@ static_library("test_support") {
     "cryptohome/mock_homedir_methods.h",
     "dbus/biod/test_utils.cc",
     "dbus/biod/test_utils.h",
-    "dbus/mock_lorgnette_manager_client.cc",
-    "dbus/mock_lorgnette_manager_client.h",
     "dbus/mock_shill_manager_client.cc",
     "dbus/mock_shill_manager_client.h",
     "dbus/mock_shill_profile_client.cc",

chromeos/dbus/fake_lorgnette_manager_client.cc

@@ -4,8 +4,7 @@
 
 #include "chromeos/dbus/fake_lorgnette_manager_client.h"
 
-#include <map>
-#include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ -23,17 +22,34 @@ void FakeLorgnetteManagerClient::Init(dbus::Bus* bus) {}
 
 void FakeLorgnetteManagerClient::ListScanners(
     const ListScannersCallback& callback) {
-  std::map<std::string, ScannerTableEntry> scanners;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(callback, false, scanners));
+      FROM_HERE,
+      base::BindOnce(callback, !scanner_table_.empty(), scanner_table_));
 }
 
 void FakeLorgnetteManagerClient::ScanImageToString(
     std::string device_name,
     const ScanProperties& properties,
     const ScanImageToStringCallback& callback) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(callback, false, std::string()));
+  auto it = scan_data_.find(
+      std::make_tuple(device_name, properties.mode, properties.resolution_dpi));
+  auto task = it != scan_data_.end()
+                  ? base::BindOnce(callback, true, it->second)
+                  : base::BindOnce(callback, false, std::string());
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, std::move(task));
+}
+
+void FakeLorgnetteManagerClient::AddScannerTableEntry(
+    const std::string device_name,
+    const ScannerTableEntry& entry) {
+  scanner_table_[device_name] = entry;
+}
+
+void FakeLorgnetteManagerClient::AddScanData(const std::string& device_name,
+                                             const ScanProperties& properties,
+                                             const std::string data) {
+  scan_data_[std::make_tuple(device_name, properties.mode,
+                             properties.resolution_dpi)] = data;
 }
 
 }  // namespace chromeos

chromeos/dbus/fake_lorgnette_manager_client.h

@@ -5,7 +5,9 @@
 #ifndef CHROMEOS_DBUS_FAKE_LORGNETTE_MANAGER_CLIENT_H_
 #define CHROMEOS_DBUS_FAKE_LORGNETTE_MANAGER_CLIENT_H_
 
+#include <map>
 #include <string>
+#include <tuple>
 
 #include "base/macros.h"
 #include "chromeos/dbus/lorgnette_manager_client.h"
@@ -28,7 +30,25 @@ class CHROMEOS_EXPORT FakeLorgnetteManagerClient
       const ScanProperties& properties,
       const ScanImageToStringCallback& callback) override;
 
+  // Adds a fake scanner table entry, which will be returned by ListScanners().
+  void AddScannerTableEntry(const std::string device_name,
+                            const ScannerTableEntry& entry);
+
+  // Adds a fake scan data, which will be returned by ScanImageToString(),
+  // if |device_name| and |properties| are matched.
+  void AddScanData(const std::string& device_name,
+                   const ScanProperties& properties,
+                   const std::string data);
+
  private:
+  ScannerTable scanner_table_;
+
+  // Use tuple for a map below, which has pre-defined "less", for convenience.
+  using ScanDataKey = std::tuple<std::string /* device_name */,
+                                 std::string /* ScanProperties.mode */,
+                                 int /* Scanproperties.resolution_dpi */>;
+  std::map<ScanDataKey, std::string /* data */> scan_data_;
+
   DISALLOW_COPY_AND_ASSIGN(FakeLorgnetteManagerClient);
 };
 

chromeos/dbus/lorgnette_manager_client.h

@@ -37,9 +37,8 @@ class CHROMEOS_EXPORT LorgnetteManagerClient : public DBusClient {
 
   // Attributes provided to a scan request.
   struct ScanProperties {
-    ScanProperties() : resolution_dpi(0) {}
     std::string mode;  // Can be "Color", "Gray", or "Lineart".
-    int resolution_dpi;
+    int resolution_dpi = 0;
   };
 
   ~LorgnetteManagerClient() override;

chromeos/dbus/mock_lorgnette_manager_client.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 "chromeos/dbus/mock_lorgnette_manager_client.h"
-
-namespace chromeos {
-
-MockLorgnetteManagerClient::MockLorgnetteManagerClient() {
-}
-
-MockLorgnetteManagerClient::~MockLorgnetteManagerClient() {
-}
-
-}  // namespace chromeos

chromeos/dbus/mock_lorgnette_manager_client.h

-// 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.
-
-#ifndef CHROMEOS_DBUS_MOCK_LORGNETTE_MANAGER_CLIENT_H_
-#define CHROMEOS_DBUS_MOCK_LORGNETTE_MANAGER_CLIENT_H_
-
-#include <string>
-
-#include "chromeos/dbus/lorgnette_manager_client.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace chromeos {
-
-class MockLorgnetteManagerClient : public LorgnetteManagerClient {
- public:
-  MockLorgnetteManagerClient();
-  ~MockLorgnetteManagerClient() override;
-
-  MOCK_METHOD1(ListScanners, void(const ListScannersCallback& callback));
-  MOCK_METHOD3(ScanImageToString,
-               void(std::string device_name,
-                    const ScanProperties& properties,
-                    const ScanImageToStringCallback& callback));
-  MOCK_METHOD1(Init, void(dbus::Bus* bus));
-};
-
-}  // namespace chromeos
-
-#endif  // CHROMEOS_DBUS_MOCK_LORGNETTE_MANAGER_CLIENT_H_

extensions/browser/api/document_scan/document_scan_interface_chromeos_unittest.cc

@@ -8,12 +8,12 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "chromeos/dbus/mock_lorgnette_manager_client.h"
+#include "base/test/scoped_task_environment.h"
+#include "chromeos/dbus/fake_lorgnette_manager_client.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-using testing::_;
-
 namespace extensions {
 
 namespace api {
@@ -21,12 +21,11 @@ namespace api {
 // Tests of networking_private_crypto support for Networking Private API.
 class DocumentScanInterfaceChromeosTest : public testing::Test {
  public:
-  DocumentScanInterfaceChromeosTest()
-      : client_(new chromeos::MockLorgnetteManagerClient()) {}
-  ~DocumentScanInterfaceChromeosTest() override {}
+  DocumentScanInterfaceChromeosTest() = default;
+  ~DocumentScanInterfaceChromeosTest() override = default;
 
   void SetUp() override {
-    scan_interface_.lorgnette_manager_client_ = client_.get();
+    scan_interface_.lorgnette_manager_client_ = &client_;
   }
 
   MOCK_METHOD2(OnListScannersResultReceived,
@@ -40,86 +39,69 @@ class DocumentScanInterfaceChromeosTest : public testing::Test {
                     const std::string& error));
 
  protected:
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+  chromeos::FakeLorgnetteManagerClient client_;
   DocumentScanInterfaceChromeos scan_interface_;
-  std::unique_ptr<chromeos::MockLorgnetteManagerClient> client_;
 };
 
-ACTION_P2(InvokeListScannersCallback, scanner_list, error) {
-  ::std::tr1::get<0>(args).Run(scanner_list, error);
-}
-
-ACTION_P2(InvokeScanCallback, succeeded, image_data) {
-  ::std::tr1::get<2>(args).Run(succeeded, image_data);
-}
-
 MATCHER_P5(IsScannerDescription, name, manufacturer, model, type, mime, "") {
   return arg.name == name && arg.manufacturer == manufacturer &&
          arg.model == model && arg.scanner_type == type &&
          arg.image_mime_type == mime;
 }
 
-MATCHER_P2(IsScannerProperties, mode, resolution, "") {
-  return arg.mode == mode && arg.resolution_dpi == resolution;
-}
-
 TEST_F(DocumentScanInterfaceChromeosTest, ListScanners) {
-  chromeos::LorgnetteManagerClient::ScannerTable scanners;
-  const char kScannerName[] = "Monet";
-  chromeos::LorgnetteManagerClient::ScannerTableEntry entry;
-  const char kScannerManufacturer[] = "Jacques-Louis David";
-  entry[lorgnette::kScannerPropertyManufacturer] = kScannerManufacturer;
-  const char kScannerModel[] = "Le Havre";
-  entry[lorgnette::kScannerPropertyModel] = kScannerModel;
-  const char kScannerType[] = "Impressionism";
-  entry[lorgnette::kScannerPropertyType] = kScannerType;
-  scanners[kScannerName] = entry;
-  EXPECT_CALL(*client_, ListScanners(_))
-      .WillOnce(InvokeListScannersCallback(true, scanners));
+  constexpr char kScannerName[] = "Monet";
+  constexpr char kScannerManufacturer[] = "Jacques-Louis David";
+  constexpr char kScannerModel[] = "Le Havre";
+  constexpr char kScannerType[] = "Impressionism";
+  client_.AddScannerTableEntry(
+      kScannerName,
+      {{lorgnette::kScannerPropertyManufacturer, kScannerManufacturer},
+       {lorgnette::kScannerPropertyModel, kScannerModel},
+       {lorgnette::kScannerPropertyType, kScannerType}});
   EXPECT_CALL(*this, OnListScannersResultReceived(
                          testing::ElementsAre(IsScannerDescription(
                              kScannerName, kScannerManufacturer, kScannerModel,
                              kScannerType, "image/png")),
-                         ""));
+                         std::string()));
+
   scan_interface_.ListScanners(base::Bind(
       &DocumentScanInterfaceChromeosTest::OnListScannersResultReceived,
       base::Unretained(this)));
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DocumentScanInterfaceChromeosTest, ScanFailure) {
-  const char kScannerName[] = "Monet";
-  const int kResolution = 4096;
-  EXPECT_CALL(*client_, ScanImageToString(
-                            kScannerName,
-                            IsScannerProperties(
-                                lorgnette::kScanPropertyModeColor, kResolution),
-                            _)).WillOnce(InvokeScanCallback(false, ""));
+  constexpr char kScannerName[] = "Monet";
+  constexpr int kResolution = 4096;
   EXPECT_CALL(*this, OnScanCompleted("data:image/png;base64,", "image/png",
                                      "Image scan failed"));
+
   scan_interface_.Scan(
       kScannerName, DocumentScanInterface::kScanModeColor, kResolution,
       base::Bind(&DocumentScanInterfaceChromeosTest::OnScanCompleted,
                  base::Unretained(this)));
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DocumentScanInterfaceChromeosTest, ScanSuccess) {
-  const char kScannerName[] = "Monet";
-  const int kResolution = 4096;
-  EXPECT_CALL(
-      *client_,
-      ScanImageToString(
-          kScannerName,
-          IsScannerProperties(lorgnette::kScanPropertyModeColor, kResolution),
-          _)).WillOnce(InvokeScanCallback(true, std::string("PrettyPicture")));
-
+  constexpr char kScannerName[] = "Monet";
+  constexpr int kResolution = 4096;
   // Data URL plus base64 representation of "PrettyPicture".
-  const char kExpectedImageData[] =
+  constexpr char kExpectedImageData[] =
       "data:image/png;base64,UHJldHR5UGljdHVyZQ==";
-
+  client_.AddScanData(kScannerName,
+                      chromeos::LorgnetteManagerClient::ScanProperties{
+                          lorgnette::kScanPropertyModeColor, kResolution},
+                      "PrettyPicture");
   EXPECT_CALL(*this, OnScanCompleted(kExpectedImageData, "image/png", ""));
+
   scan_interface_.Scan(
       kScannerName, DocumentScanInterface::kScanModeColor, kResolution,
       base::Bind(&DocumentScanInterfaceChromeosTest::OnScanCompleted,
                  base::Unretained(this)));
+  base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace api