chrome/browser/extensions/api/document_scan/simple_scan_runner.cc - chromium/src - Git at Google

 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "chrome/browser/extensions/api/document_scan/simple_scan_runner.h"

 #include "base/base64.h"
 #include "base/containers/contains.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/ash/scanning/lorgnette_scanner_manager.h"
 #include "chrome/browser/ash/scanning/lorgnette_scanner_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/extensions/extensions_dialogs.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/crosapi/mojom/document_scan.mojom.h"
 #include "components/prefs/pref_service.h"
 #include "extensions/browser/image_loader.h"
 #include "extensions/common/extension.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/native_window_tracker/native_window_tracker.h"

 namespace extensions {

 namespace {

 // Error messages that can be included in a response when scanning fails.
 constexpr char kNoScannersAvailableError[] = "No scanners available";
 constexpr char kScanImageError[] = "Failed to scan image";
 constexpr char kUnsupportedMimeTypesError[] = "Unsupported MIME types";
 constexpr char kVirtualPrinterUnavailableError[] =
     "Virtual USB printer unavailable";

 // Special MIME type that triggers use of virtual-usb-printer for scanning.
 constexpr char kTestingMimeType[] = "testing";

 // The name of the virtual USB printer used for testing.
 constexpr char kVirtualUSBPrinter[] = "DavieV Virtual USB Printer (USB)";

 // The PNG MIME type.
 constexpr char kScannerImageMimeTypePng[] = "image/png";

 // The PNG image data URL prefix of a scanned image.
 constexpr char kPngImageDataUrlPrefix[] = "data:image/png;base64,";

 // The delay between reads from the scanner when data isn't expected to be ready
 // immediately.
 constexpr base::TimeDelta kSlowReadInterval = base::Milliseconds(500);

 // The delay between reads from the scanner when data might be ready.
 constexpr base::TimeDelta kReadInterval = base::Milliseconds(100);

 // The connection type name for Mopria eSCL scanners.
 constexpr char kMopriaProtocolName[] = "Mopria";

 }  // namespace

 SimpleScanRunner::SimpleScanRunner(content::BrowserContext* browser_context,
                                    scoped_refptr<const Extension> extension,
                                    crosapi::mojom::DocumentScan* document_scan)
     : browser_context_(browser_context),
       extension_(std::move(extension)),
       document_scan_(document_scan) {
   CHECK(browser_context_);
   CHECK(extension_);
 }

 SimpleScanRunner::~SimpleScanRunner() = default;

 void SimpleScanRunner::Start(std::vector<std::string> mime_types,
                              SimpleScanCallback callback) {
   CHECK(!callback_) << "scan call already in progress";
   callback_ = std::move(callback);
   mime_types_ = std::move(mime_types);

   // Clear any leftover state from a previous scan.
   scanner_ids_.clear();
   scanner_handle_ = "";
   job_handle_ = "";
   scan_data_.clear();
   scan_result_ = crosapi::mojom::ScanFailureMode::kUnknown;

   bool should_use_virtual_usb_printer = false;
   if (base::Contains(mime_types_, kTestingMimeType)) {
     should_use_virtual_usb_printer = true;
   } else if (!base::Contains(mime_types_, kScannerImageMimeTypePng)) {
     std::move(callback_).Run(std::nullopt, kUnsupportedMimeTypesError);
     return;
   }

   ash::LorgnetteScannerManagerFactory::GetForBrowserContext(browser_context_)
       ->GetScannerInfoList(
           extension_id(),
           ash::LorgnetteScannerManager::LocalScannerFilter::
               kIncludeNetworkScanners,
           ash::LorgnetteScannerManager::SecureScannerFilter::
               kIncludeUnsecureScanners,
           base::BindOnce(&SimpleScanRunner::OnSimpleScanListReceived,
                          weak_ptr_factory_.GetWeakPtr(),
                          should_use_virtual_usb_printer));
 }

 const ExtensionId& SimpleScanRunner::extension_id() const {
   return extension_->id();
 }

 void SimpleScanRunner::OnSimpleScanListReceived(
     bool force_virtual_usb_printer,
     const std::optional<lorgnette::ListScannersResponse>& response) {
   if (!response.has_value() || response->scanners().empty()) {
     std::move(callback_).Run(std::nullopt, kNoScannersAvailableError);
     return;
   }

   std::vector<const lorgnette::ScannerInfo*> scanners;
   scanners.reserve(response->scanners().size());
   for (const auto& scanner : response->scanners()) {
     scanners.push_back(&scanner);
   }

   // A scanner source needs to be chosen.  Since the choice is unspecified, sort
   // the list with these heuristics and take the first one that can be
   // successfully opened:
   //   1.  If force_virtual_usb_printer is true, always pick the virtual USB
   //       printer.
   //   2.  USB scanners come first, since they are both local and secure.
   //   3.  Secure network scanners come next.
   //   4.  Insecure network scanners come last.
   // Within each grouping, prefer Mopria eSCL to legacy protocols, since the
   // backend is known to work consistently.
   std::ranges::stable_sort(
       scanners, std::less<>{}, [](const lorgnette::ScannerInfo* info) {
         return std::tuple(
             // Virtual USB printer always comes first.
             info->display_name() != kVirtualUSBPrinter,

             // USB devices come first.
             info->connection_type() !=
                 lorgnette::ConnectionType::CONNECTION_USB,

             // Secure devices come before insecure.
             !info->secure(),

             // Mopria/eSCL devices come before legacy devices.
             info->protocol_type() != kMopriaProtocolName,

             // Sort by display name if all else is equal.
             info->display_name());
       });

   if (force_virtual_usb_printer &&
       scanners[0]->display_name() != kVirtualUSBPrinter) {
     std::move(callback_).Run(std::nullopt, kVirtualPrinterUnavailableError);
     return;
   }

   // Store the list of IDs in reverse so it can be processed more efficiently in
   // the callbacks.  The rest of the ScannerInfo fields aren't needed.
   scanner_ids_.reserve(scanners.size());
   for (const lorgnette::ScannerInfo* info : scanners) {
     if (force_virtual_usb_printer &&
         info->display_name() != kVirtualUSBPrinter) {
       continue;
     }
     scanner_ids_.push_back(std::move(info->name()));
   }
   std::ranges::reverse(scanner_ids_);

   OpenFirstScanner();
 }

 void SimpleScanRunner::OpenFirstScanner() {
   if (scanner_ids_.empty()) {
     std::move(callback_).Run(std::nullopt, kNoScannersAvailableError);
     return;
   }

   std::string scanner_id = std::move(scanner_ids_.back());
   scanner_ids_.pop_back();
   document_scan_->OpenScanner(
       extension_id(), std::move(scanner_id),
       base::BindOnce(&SimpleScanRunner::OnOpenScannerResponse,
                      weak_ptr_factory_.GetWeakPtr()));
 }

 void SimpleScanRunner::OnOpenScannerResponse(
     crosapi::mojom::OpenScannerResponsePtr response) {
   if (response->result != crosapi::mojom::ScannerOperationResult::kSuccess ||
       !response->scanner_handle.has_value()) {
     OpenFirstScanner();
     return;
   }
   scanner_handle_ = std::move(response->scanner_handle.value());

   auto options = crosapi::mojom::StartScanOptions::New();
   options->format = kScannerImageMimeTypePng;

   document_scan_->StartPreparedScan(
       scanner_handle_, std::move(options),
       base::BindOnce(&SimpleScanRunner::OnStartPreparedScanResponse,
                      weak_ptr_factory_.GetWeakPtr()));
 }

 void SimpleScanRunner::OnStartPreparedScanResponse(
     crosapi::mojom::StartPreparedScanResponsePtr response) {
   if (response->result != crosapi::mojom::ScannerOperationResult::kSuccess ||
       !response->job_handle.has_value()) {
     // Closing the scanner will also return the response to the caller.
     document_scan_->CloseScanner(
         scanner_handle_,
         base::BindOnce(&SimpleScanRunner::OnCloseScannerResponse,
                        weak_ptr_factory_.GetWeakPtr()));
     return;
   }

   // Scanners normally don't produce bytes right away, so start the read loop
   // after a delay.
   job_handle_ = std::move(response->job_handle.value());
   base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&SimpleScanRunner::ReadScanData,
                      weak_ptr_factory_.GetWeakPtr()),
       kSlowReadInterval);
 }

 void SimpleScanRunner::ReadScanData() {
   document_scan_->ReadScanData(
       job_handle_, base::BindOnce(&SimpleScanRunner::OnReadScanDataResponse,
                                   weak_ptr_factory_.GetWeakPtr()));
 }

 void SimpleScanRunner::OnReadScanDataResponse(
     crosapi::mojom::ReadScanDataResponsePtr response) {
   // Success means to keep going.  If data was ready, append it to what we got
   // so far.
   if (response->result == crosapi::mojom::ScannerOperationResult::kSuccess) {
     if (response->data.has_value() && response->data->size() > 0) {
       scan_data_.insert(scan_data_.end(), response->data->begin(),
                         response->data->end());
     }

     // Once the first byte after the image headers is received, poll the scanner
     // more quickly because data usually streams consistently.
     base::TimeDelta delay =
         (scan_data_.size() > 100) ? kReadInterval : kSlowReadInterval;
     base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
         FROM_HERE,
         base::BindOnce(&SimpleScanRunner::ReadScanData,
                        weak_ptr_factory_.GetWeakPtr()),
         delay);
     return;
   }

   // EOF means no more data is available.  There might be a final data chunk.
   if (response->result == crosapi::mojom::ScannerOperationResult::kEndOfData) {
     if (response->data.has_value() && response->data->size() > 0) {
       scan_data_.insert(scan_data_.end(), response->data->begin(),
                         response->data->end());
     }

     scan_result_ = crosapi::mojom::ScanFailureMode::kNoFailure;
   }

   document_scan_->CloseScanner(
       scanner_handle_, base::BindOnce(&SimpleScanRunner::OnCloseScannerResponse,
                                       weak_ptr_factory_.GetWeakPtr()));
 }

 void SimpleScanRunner::OnCloseScannerResponse(
     crosapi::mojom::CloseScannerResponsePtr) {
   // Intentionally ignore the response.  The result to return to the caller has
   // already been determined at the end of the read loop.
   OnSimpleScanCompleted(scan_result_);
 }

 void SimpleScanRunner::OnSimpleScanCompleted(
     crosapi::mojom::ScanFailureMode failure_mode) {
   if (!scan_data_.size() ||
       failure_mode != crosapi::mojom::ScanFailureMode::kNoFailure) {
     std::move(callback_).Run(std::nullopt, kScanImageError);
     return;
   }

   std::string image_base64 = base::Base64Encode(scan_data_);
   api::document_scan::ScanResults scan_results;
   scan_results.data_urls.push_back(kPngImageDataUrlPrefix +
                                    std::move(image_base64));
   scan_results.mime_type = kScannerImageMimeTypePng;

   std::move(callback_).Run(std::move(scan_results), std::nullopt);
 }

 }  // namespace extensions
	// Copyright 2025 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	#include "chrome/browser/extensions/api/document_scan/simple_scan_runner.h"

	#include "base/base64.h"
	#include "base/containers/contains.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/time/time.h"
	#include "chrome/browser/ash/scanning/lorgnette_scanner_manager.h"
	#include "chrome/browser/ash/scanning/lorgnette_scanner_manager_factory.h"
	#include "chrome/browser/profiles/profile.h"
	#include "chrome/browser/ui/extensions/extensions_dialogs.h"
	#include "chrome/common/pref_names.h"
	#include "chromeos/crosapi/mojom/document_scan.mojom.h"
	#include "components/prefs/pref_service.h"
	#include "extensions/browser/image_loader.h"
	#include "extensions/common/extension.h"
	#include "ui/gfx/image/image.h"
	#include "ui/gfx/image/image_skia.h"
	#include "ui/native_window_tracker/native_window_tracker.h"

	namespace extensions {

	namespace {

	// Error messages that can be included in a response when scanning fails.
	constexpr char kNoScannersAvailableError[] = "No scanners available";
	constexpr char kScanImageError[] = "Failed to scan image";
	constexpr char kUnsupportedMimeTypesError[] = "Unsupported MIME types";
	constexpr char kVirtualPrinterUnavailableError[] =
	"Virtual USB printer unavailable";

	// Special MIME type that triggers use of virtual-usb-printer for scanning.
	constexpr char kTestingMimeType[] = "testing";

	// The name of the virtual USB printer used for testing.
	constexpr char kVirtualUSBPrinter[] = "DavieV Virtual USB Printer (USB)";

	// The PNG MIME type.
	constexpr char kScannerImageMimeTypePng[] = "image/png";

	// The PNG image data URL prefix of a scanned image.
	constexpr char kPngImageDataUrlPrefix[] = "data:image/png;base64,";

	// The delay between reads from the scanner when data isn't expected to be ready
	// immediately.
	constexpr base::TimeDelta kSlowReadInterval = base::Milliseconds(500);

	// The delay between reads from the scanner when data might be ready.
	constexpr base::TimeDelta kReadInterval = base::Milliseconds(100);

	// The connection type name for Mopria eSCL scanners.
	constexpr char kMopriaProtocolName[] = "Mopria";

	} // namespace

	SimpleScanRunner::SimpleScanRunner(content::BrowserContext* browser_context,
	scoped_refptr<const Extension> extension,
	crosapi::mojom::DocumentScan* document_scan)
	: browser_context_(browser_context),
	extension_(std::move(extension)),
	document_scan_(document_scan) {
	CHECK(browser_context_);
	CHECK(extension_);
	}

	SimpleScanRunner::~SimpleScanRunner() = default;

	void SimpleScanRunner::Start(std::vector<std::string> mime_types,
	SimpleScanCallback callback) {
	CHECK(!callback_) << "scan call already in progress";
	callback_ = std::move(callback);
	mime_types_ = std::move(mime_types);

	// Clear any leftover state from a previous scan.
	scanner_ids_.clear();
	scanner_handle_ = "";
	job_handle_ = "";
	scan_data_.clear();
	scan_result_ = crosapi::mojom::ScanFailureMode::kUnknown;

	bool should_use_virtual_usb_printer = false;
	if (base::Contains(mime_types_, kTestingMimeType)) {
	should_use_virtual_usb_printer = true;
	} else if (!base::Contains(mime_types_, kScannerImageMimeTypePng)) {
	std::move(callback_).Run(std::nullopt, kUnsupportedMimeTypesError);
	return;
	}

	ash::LorgnetteScannerManagerFactory::GetForBrowserContext(browser_context_)
	->GetScannerInfoList(
	extension_id(),
	ash::LorgnetteScannerManager::LocalScannerFilter::
	kIncludeNetworkScanners,
	ash::LorgnetteScannerManager::SecureScannerFilter::
	kIncludeUnsecureScanners,
	base::BindOnce(&SimpleScanRunner::OnSimpleScanListReceived,
	weak_ptr_factory_.GetWeakPtr(),
	should_use_virtual_usb_printer));
	}

	const ExtensionId& SimpleScanRunner::extension_id() const {
	return extension_->id();
	}

	void SimpleScanRunner::OnSimpleScanListReceived(
	bool force_virtual_usb_printer,
	const std::optional<lorgnette::ListScannersResponse>& response) {
	if (!response.has_value() \|\| response->scanners().empty()) {
	std::move(callback_).Run(std::nullopt, kNoScannersAvailableError);
	return;
	}

	std::vector<const lorgnette::ScannerInfo*> scanners;
	scanners.reserve(response->scanners().size());
	for (const auto& scanner : response->scanners()) {
	scanners.push_back(&scanner);
	}

	// A scanner source needs to be chosen. Since the choice is unspecified, sort
	// the list with these heuristics and take the first one that can be
	// successfully opened:
	// 1. If force_virtual_usb_printer is true, always pick the virtual USB
	// printer.
	// 2. USB scanners come first, since they are both local and secure.
	// 3. Secure network scanners come next.
	// 4. Insecure network scanners come last.
	// Within each grouping, prefer Mopria eSCL to legacy protocols, since the
	// backend is known to work consistently.
	std::ranges::stable_sort(
	scanners, std::less<>{}, [](const lorgnette::ScannerInfo* info) {
	return std::tuple(
	// Virtual USB printer always comes first.
	info->display_name() != kVirtualUSBPrinter,

	// USB devices come first.
	info->connection_type() !=
	lorgnette::ConnectionType::CONNECTION_USB,

	// Secure devices come before insecure.
	!info->secure(),

	// Mopria/eSCL devices come before legacy devices.
	info->protocol_type() != kMopriaProtocolName,

	// Sort by display name if all else is equal.
	info->display_name());
	});

	if (force_virtual_usb_printer &&
	scanners[0]->display_name() != kVirtualUSBPrinter) {
	std::move(callback_).Run(std::nullopt, kVirtualPrinterUnavailableError);
	return;
	}

	// Store the list of IDs in reverse so it can be processed more efficiently in
	// the callbacks. The rest of the ScannerInfo fields aren't needed.
	scanner_ids_.reserve(scanners.size());
	for (const lorgnette::ScannerInfo* info : scanners) {
	if (force_virtual_usb_printer &&
	info->display_name() != kVirtualUSBPrinter) {
	continue;
	}
	scanner_ids_.push_back(std::move(info->name()));
	}
	std::ranges::reverse(scanner_ids_);

	OpenFirstScanner();
	}

	void SimpleScanRunner::OpenFirstScanner() {
	if (scanner_ids_.empty()) {
	std::move(callback_).Run(std::nullopt, kNoScannersAvailableError);
	return;
	}

	std::string scanner_id = std::move(scanner_ids_.back());
	scanner_ids_.pop_back();
	document_scan_->OpenScanner(
	extension_id(), std::move(scanner_id),
	base::BindOnce(&SimpleScanRunner::OnOpenScannerResponse,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SimpleScanRunner::OnOpenScannerResponse(
	crosapi::mojom::OpenScannerResponsePtr response) {
	if (response->result != crosapi::mojom::ScannerOperationResult::kSuccess \|\|
	!response->scanner_handle.has_value()) {
	OpenFirstScanner();
	return;
	}
	scanner_handle_ = std::move(response->scanner_handle.value());

	auto options = crosapi::mojom::StartScanOptions::New();
	options->format = kScannerImageMimeTypePng;

	document_scan_->StartPreparedScan(
	scanner_handle_, std::move(options),
	base::BindOnce(&SimpleScanRunner::OnStartPreparedScanResponse,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SimpleScanRunner::OnStartPreparedScanResponse(
	crosapi::mojom::StartPreparedScanResponsePtr response) {
	if (response->result != crosapi::mojom::ScannerOperationResult::kSuccess \|\|
	!response->job_handle.has_value()) {
	// Closing the scanner will also return the response to the caller.
	document_scan_->CloseScanner(
	scanner_handle_,
	base::BindOnce(&SimpleScanRunner::OnCloseScannerResponse,
	weak_ptr_factory_.GetWeakPtr()));
	return;
	}

	// Scanners normally don't produce bytes right away, so start the read loop
	// after a delay.
	job_handle_ = std::move(response->job_handle.value());
	base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
	FROM_HERE,
	base::BindOnce(&SimpleScanRunner::ReadScanData,
	weak_ptr_factory_.GetWeakPtr()),
	kSlowReadInterval);
	}

	void SimpleScanRunner::ReadScanData() {
	document_scan_->ReadScanData(
	job_handle_, base::BindOnce(&SimpleScanRunner::OnReadScanDataResponse,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SimpleScanRunner::OnReadScanDataResponse(
	crosapi::mojom::ReadScanDataResponsePtr response) {
	// Success means to keep going. If data was ready, append it to what we got
	// so far.
	if (response->result == crosapi::mojom::ScannerOperationResult::kSuccess) {
	if (response->data.has_value() && response->data->size() > 0) {
	scan_data_.insert(scan_data_.end(), response->data->begin(),
	response->data->end());
	}

	// Once the first byte after the image headers is received, poll the scanner
	// more quickly because data usually streams consistently.
	base::TimeDelta delay =
	(scan_data_.size() > 100) ? kReadInterval : kSlowReadInterval;
	base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
	FROM_HERE,
	base::BindOnce(&SimpleScanRunner::ReadScanData,
	weak_ptr_factory_.GetWeakPtr()),
	delay);
	return;
	}

	// EOF means no more data is available. There might be a final data chunk.
	if (response->result == crosapi::mojom::ScannerOperationResult::kEndOfData) {
	if (response->data.has_value() && response->data->size() > 0) {
	scan_data_.insert(scan_data_.end(), response->data->begin(),
	response->data->end());
	}

	scan_result_ = crosapi::mojom::ScanFailureMode::kNoFailure;
	}

	document_scan_->CloseScanner(
	scanner_handle_, base::BindOnce(&SimpleScanRunner::OnCloseScannerResponse,
	weak_ptr_factory_.GetWeakPtr()));
	}

	void SimpleScanRunner::OnCloseScannerResponse(
	crosapi::mojom::CloseScannerResponsePtr) {
	// Intentionally ignore the response. The result to return to the caller has
	// already been determined at the end of the read loop.
	OnSimpleScanCompleted(scan_result_);
	}

	void SimpleScanRunner::OnSimpleScanCompleted(
	crosapi::mojom::ScanFailureMode failure_mode) {
	if (!scan_data_.size() \|\|
	failure_mode != crosapi::mojom::ScanFailureMode::kNoFailure) {
	std::move(callback_).Run(std::nullopt, kScanImageError);
	return;
	}

	std::string image_base64 = base::Base64Encode(scan_data_);
	api::document_scan::ScanResults scan_results;
	scan_results.data_urls.push_back(kPngImageDataUrlPrefix +
	std::move(image_base64));
	scan_results.mime_type = kScannerImageMimeTypePng;

	std::move(callback_).Run(std::move(scan_results), std::nullopt);
	}

	} // namespace extensions