scanning: Support progress callbacks

Add support for passing in a progress callback to
LorgnetteScannerManager::Scan(). This allows clients to receive progress
updates for in-progress scan jobs.

Bug: 1059779
Change-Id: Ib787c925fbd8033f85e349cb9387168306cd83e8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2503313Reviewed-by: Zentaro Kavanagh <zentaro@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Commit-Queue: Jesse Schettler <jschettler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#821491}

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

@@ -9,6 +9,7 @@
 
 #include "base/base64.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "chrome/browser/chromeos/scanning/lorgnette_scanner_manager.h"
 #include "chrome/browser/chromeos/scanning/lorgnette_scanner_manager_factory.h"
 #include "chromeos/dbus/lorgnette/lorgnette_service.pb.h"
@@ -80,7 +81,7 @@ void DocumentScanScanFunction::OnNamesReceived(
   chromeos::LorgnetteScannerManagerFactory::GetForBrowserContext(
       browser_context())
       ->Scan(
-          scanner_name, settings,
+          scanner_name, settings, base::NullCallback(),
           base::BindRepeating(&DocumentScanScanFunction::OnPageReceived, this),
           base::BindOnce(&DocumentScanScanFunction::OnScanCompleted, this));
 }

chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.cc

@@ -32,16 +32,25 @@ void FakeLorgnetteScannerManager::GetScannerCapabilities(
 
 void FakeLorgnetteScannerManager::Scan(const std::string& scanner_name,
                                        const lorgnette::ScanSettings& settings,
+                                       ProgressCallback progress_callback,
                                        PageCallback page_callback,
-                                       ScanCallback callback) {
+                                       CompletionCallback completion_callback) {
   if (scan_data_.has_value()) {
+    if (progress_callback) {
+      for (int progress : {7, 22, 40, 42, 59, 74, 95}) {
+        base::ThreadTaskRunnerHandle::Get()->PostTask(
+            FROM_HERE, base::BindOnce(progress_callback, progress));
+      }
+    }
+
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(page_callback, scan_data_.value(), /*page_number=*/0));
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(std::move(callback), scan_data_.has_value()));
+      FROM_HERE,
+      base::BindOnce(std::move(completion_callback), scan_data_.has_value()));
 }
 
 void FakeLorgnetteScannerManager::SetGetScannerNamesResponse(

chrome/browser/chromeos/scanning/fake_lorgnette_scanner_manager.h

@@ -30,8 +30,9 @@ class FakeLorgnetteScannerManager final : public LorgnetteScannerManager {
                               GetScannerCapabilitiesCallback callback) override;
   void Scan(const std::string& scanner_name,
             const lorgnette::ScanSettings& settings,
+            ProgressCallback progress_callback,
             PageCallback page_callback,
-            ScanCallback callback) override;
+            CompletionCallback completion_callback) override;
 
   // Sets the response returned by GetScannerNames().
   void SetGetScannerNamesResponse(

chrome/browser/chromeos/scanning/lorgnette_scanner_manager.cc

@@ -11,7 +11,6 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "base/check.h"
 #include "base/containers/flat_map.h"
 #include "base/logging.h"
@@ -111,18 +110,19 @@ class LorgnetteScannerManagerImpl final : public LorgnetteScannerManager {
   // LorgnetteScannerManager:
   void Scan(const std::string& scanner_name,
             const lorgnette::ScanSettings& settings,
+            ProgressCallback progress_callback,
             PageCallback page_callback,
-            ScanCallback callback) override {
+            CompletionCallback completion_callback) override {
     std::string device_name;
     ScanProtocol protocol;  // Unused.
     if (!GetUsableDeviceNameAndProtocol(scanner_name, device_name, protocol)) {
-      std::move(callback).Run(false);
+      std::move(completion_callback).Run(false);
       return;
     }
 
     GetLorgnetteManagerClient()->StartScan(
-        device_name, settings, std::move(callback), std::move(page_callback),
-        base::NullCallback());
+        device_name, settings, std::move(completion_callback),
+        std::move(page_callback), std::move(progress_callback));
   }
 
  private:

chrome/browser/chromeos/scanning/lorgnette_scanner_manager.h

@@ -28,9 +28,10 @@ class LorgnetteScannerManager : public KeyedService {
       base::OnceCallback<void(std::vector<std::string> scanner_names)>;
   using GetScannerCapabilitiesCallback = base::OnceCallback<void(
       const base::Optional<lorgnette::ScannerCapabilities>& capabilities)>;
+  using ProgressCallback = base::RepeatingCallback<void(int progress_percent)>;
   using PageCallback = base::RepeatingCallback<void(std::string scan_data,
                                                     uint32_t page_number)>;
-  using ScanCallback = base::OnceCallback<void(bool success)>;
+  using CompletionCallback = base::OnceCallback<void(bool success)>;
 
   ~LorgnetteScannerManager() override = default;
 
@@ -48,15 +49,17 @@ class LorgnetteScannerManager : public KeyedService {
       GetScannerCapabilitiesCallback callback) = 0;
 
   // Performs a scan with the scanner specified by |scanner_name| using the
-  // given |scan_properties|. As each scanned page is completed,
-  // |page_callback| is called with the image data for that page. If
-  // |scanner_name| does not correspond to a known scanner, false is returned
-  // in |callback|. After the scan has completed, |callback| will be called
-  // with argument success=true.
+  // given |scan_properties|. As each page is scanned, |progress_callback| is
+  // called with the current progress percent from 0 to 100. As each scanned
+  // page is completed, |page_callback| is called with the image data for that
+  // page. If |scanner_name| does not correspond to a known scanner, false is
+  // returned in |completion_callback|. After the scan has completed,
+  // |completion_callback| will be called with argument success=true.
   virtual void Scan(const std::string& scanner_name,
                     const lorgnette::ScanSettings& settings,
+                    ProgressCallback progress_callback,
                     PageCallback page_callback,
-                    ScanCallback callback) = 0;
+                    CompletionCallback completion_callback) = 0;
 };
 
 }  // namespace chromeos

chrome/browser/chromeos/scanning/lorgnette_scanner_manager_unittest.cc

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/containers/flat_map.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
@@ -171,7 +172,7 @@ class LorgnetteScannerManagerTest : public testing::Test {
   void Scan(const std::string& scanner_name,
             const lorgnette::ScanSettings& settings) {
     lorgnette_scanner_manager_->Scan(
-        scanner_name, settings,
+        scanner_name, settings, base::NullCallback(),
         base::BindRepeating(&LorgnetteScannerManagerTest::PageCallback,
                             base::Unretained(this)),
         base::Bind(&LorgnetteScannerManagerTest::ScanCallback,

chrome/browser/chromeos/scanning/scan_service.cc

@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/check.h"
 #include "base/files/file_util.h"
 #include "base/strings/stringprintf.h"
@@ -63,6 +64,7 @@ void ScanService::Scan(const base::UnguessableToken& scanner_id,
   save_failed_ = false;
   lorgnette_scanner_manager_->Scan(
       scanner_name, mojo::ConvertTo<lorgnette::ScanSettings>(settings),
+      base::NullCallback(),
       base::BindRepeating(&ScanService::OnPageReceived,
                           weak_ptr_factory_.GetWeakPtr(), settings->file_type),
       base::BindOnce(&ScanService::OnScanCompleted,