scanning: Add CancelScan to LorgnetteScannerManager

Calls LorgnetteManagerClient CancelScan API to cancel the currently
running scan job.

Bug: 1059779
Change-Id: I31da3b2a37caa472eac1f7b781cd3d9f6ca9f465
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2532723
Commit-Queue: Gavin Williams <gavinwill@chromium.org>
Reviewed-by: Jesse Schettler <jschettler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#826452}

chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.cc

@@ -55,6 +55,11 @@ void FakeLorgnetteScannerManager::Scan(const std::string& scanner_name,
       base::BindOnce(std::move(completion_callback), scan_data_.has_value()));
 }
 
+void FakeLorgnetteScannerManager::CancelScan(CancelCallback cancel_callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(cancel_callback), true));
+}
+
 void FakeLorgnetteScannerManager::SetGetScannerNamesResponse(
     const std::vector<std::string>& scanner_names) {
   scanner_names_ = scanner_names;

chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.h

@@ -33,6 +33,7 @@ class FakeLorgnetteScannerManager final : public LorgnetteScannerManager {
             ProgressCallback progress_callback,
             PageCallback page_callback,
             CompletionCallback completion_callback) override;
+  void CancelScan(CancelCallback cancel_callback) override;
 
   // Sets the response returned by GetScannerNames().
   void SetGetScannerNamesResponse(

chrome/browser/chromeos/scanning/lorgnette_scanner_manager.cc

@@ -125,6 +125,11 @@ class LorgnetteScannerManagerImpl final : public LorgnetteScannerManager {
         std::move(page_callback), std::move(progress_callback));
   }
 
+  // LorgnetteScannerManager:
+  void CancelScan(CancelCallback cancel_callback) override {
+    GetLorgnetteManagerClient()->CancelScan(std::move(cancel_callback));
+  }
+
  private:
   // Called when scanners are detected by a ScannerDetector.
   void OnScannersDetected(std::vector<Scanner> scanners) {

chrome/browser/chromeos/scanning/lorgnette_scanner_manager.h

@@ -34,6 +34,7 @@ class LorgnetteScannerManager : public KeyedService {
   using PageCallback = base::RepeatingCallback<void(std::string scan_data,
                                                     uint32_t page_number)>;
   using CompletionCallback = base::OnceCallback<void(bool success)>;
+  using CancelCallback = base::OnceCallback<void(bool success)>;
 
   ~LorgnetteScannerManager() override = default;
 
@@ -62,6 +63,10 @@ class LorgnetteScannerManager : public KeyedService {
                     ProgressCallback progress_callback,
                     PageCallback page_callback,
                     CompletionCallback completion_callback) = 0;
+
+  // Request to cancel the currently running scan job. This function makes the
+  // assumption that LorgnetteManagerClient only has one scan running at a time.
+  virtual void CancelScan(CancelCallback cancel_callback) = 0;
 };
 
 }  // namespace chromeos

chrome/browser/chromeos/scanning/lorgnette_scanner_manager_unittest.cc

@@ -179,6 +179,14 @@ class LorgnetteScannerManagerTest : public testing::Test {
                    base::Unretained(this)));
   }
 
+  // Calls LorgnetteScannerManager::CancelScan() and binds a callback to process
+  // the result.
+  void CancelScan() {
+    lorgnette_scanner_manager_->CancelScan(
+        base::Bind(&LorgnetteScannerManagerTest::CancelScanCallback,
+                   base::Unretained(this)));
+  }
+
   // Runs all tasks until the ThreadPool's non-delayed queues are empty.
   void CompleteTasks() { task_environment_.RunUntilIdle(); }
 
@@ -202,6 +210,7 @@ class LorgnetteScannerManagerTest : public testing::Test {
 
   std::vector<std::string> scan_data() const { return scan_data_; }
   bool scan_success() const { return scan_success_; }
+  bool cancel_scan_success() const { return cancel_scan_success_; }
 
  private:
   // Handles the result of calling LorgnetteScannerManager::GetScannerNames().
@@ -228,6 +237,12 @@ class LorgnetteScannerManagerTest : public testing::Test {
     run_loop_->Quit();
   }
 
+  // Handles completion of LorgnetteScannerManager::CancelScan().
+  void CancelScanCallback(bool success) {
+    cancel_scan_success_ = success;
+    run_loop_->Quit();
+  }
+
   base::test::TaskEnvironment task_environment_;
 
   std::unique_ptr<base::RunLoop> run_loop_;
@@ -239,6 +254,7 @@ class LorgnetteScannerManagerTest : public testing::Test {
   std::vector<std::string> scanner_names_;
   base::Optional<lorgnette::ScannerCapabilities> scanner_capabilities_;
   bool scan_success_ = false;
+  bool cancel_scan_success_ = false;
   std::vector<std::string> scan_data_;
 };
 
@@ -495,4 +511,17 @@ TEST_F(LorgnetteScannerManagerTest, ScanMultiplePages) {
   EXPECT_TRUE(scan_success());
 }
 
+// Test that requesting to cancel the current scan job returns the success
+// result.
+TEST_F(LorgnetteScannerManagerTest, CancelScan) {
+  auto scanner = CreateZeroconfScanner();
+  fake_zeroconf_scanner_detector()->AddDetections({scanner});
+  CompleteTasks();
+  GetScannerNames();
+  WaitForResult();
+  CancelScan();
+  WaitForResult();
+  EXPECT_TRUE(cancel_scan_success());
+}
+
 }  // namespace chromeos