Create PrintServersManager

Refactor print server components from CupsPrintersManager into its own
class.

Bug: b:168650771
Change-Id: If62b27ffde97257e9e0ac5b745ceecdd13721fb6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2521226
Commit-Queue: Matt Menard <mattme@google.com>
Reviewed-by: Sean Kau <skau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#827992}

chrome/browser/chromeos/BUILD.gn

@@ -2523,6 +2523,8 @@ source_set("chromeos") {
     "printing/print_management/printing_manager_factory.h",
     "printing/print_server.cc",
     "printing/print_server.h",
+    "printing/print_servers_manager.cc",
+    "printing/print_servers_manager.h",
     "printing/print_servers_policy_provider.cc",
     "printing/print_servers_policy_provider.h",
     "printing/print_servers_provider.cc",
@@ -3762,6 +3764,7 @@ source_set("unit_tests") {
     "printing/print_management/print_job_info_mojom_conversions_unittest.cc",
     "printing/print_management/printing_manager_factory_unittest.cc",
     "printing/print_management/printing_manager_unittest.cc",
+    "printing/print_servers_manager_unittest.cc",
     "printing/print_servers_provider_unittest.cc",
     "printing/printer_detector_test_util.h",
     "printing/printer_event_tracker_unittest.cc",

chrome/browser/chromeos/printing/cups_printers_manager.cc

@@ -62,6 +62,7 @@ using printing::PrinterQueryResult;
 class CupsPrintersManagerImpl
     : public CupsPrintersManager,
       public EnterprisePrintersProvider::Observer,
+      public PrintServersManager::Observer,
       public SyncedPrintersManager::Observer,
       public chromeos::network_config::mojom::CrosNetworkConfigObserver {
  public:
@@ -77,8 +78,7 @@ class CupsPrintersManagerImpl
       std::unique_ptr<PrinterConfigurer> printer_configurer,
       std::unique_ptr<UsbPrinterNotificationController>
           usb_notification_controller,
-      std::unique_ptr<PrintServersPolicyProvider> print_servers_provider,
-      std::unique_ptr<ServerPrintersProvider> server_printers_provider,
+      std::unique_ptr<PrintServersManager> print_servers_manager,
       std::unique_ptr<EnterprisePrintersProvider> enterprise_printers_provider,
       PrinterEventTracker* event_tracker,
       PrefService* pref_service)
@@ -91,8 +91,7 @@ class CupsPrintersManagerImpl
         auto_usb_printer_configurer_(std::move(printer_configurer),
                                      this,
                                      usb_notification_controller_.get()),
-        print_servers_provider_(std::move(print_servers_provider)),
-        server_printers_provider_(std::move(server_printers_provider)),
+        print_servers_manager_(std::move(print_servers_manager)),
         enterprise_printers_provider_(std::move(enterprise_printers_provider)),
         enterprise_printers_provider_observer_(this),
         event_tracker_(event_tracker) {
@@ -127,12 +126,7 @@ class CupsPrintersManagerImpl
                             weak_ptr_factory_.GetWeakPtr(), kZeroconfDetector));
     OnPrintersFound(kZeroconfDetector, zeroconf_detector_->GetPrinters());
 
-    print_servers_provider_->SetListener(
-        base::BindRepeating(&CupsPrintersManagerImpl::OnPrintServersUpdated,
-                            weak_ptr_factory_.GetWeakPtr()));
-    server_printers_provider_->RegisterPrintersFoundCallback(
-        base::BindRepeating(&CupsPrintersManagerImpl::OnPrintersUpdated,
-                            weak_ptr_factory_.GetWeakPtr()));
+    print_servers_manager_->AddObserver(this);
 
     user_printers_allowed_.Init(prefs::kUserPrintersAllowed, pref_service);
     send_username_and_filename_.Init(
@@ -313,14 +307,9 @@ class CupsPrintersManagerImpl
     RebuildDetectedLists();
   }
 
-  // Callback for ServerPrintersProvider.
-  void OnPrintersUpdated(bool complete) {
-    const std::vector<PrinterDetector::DetectedPrinter> printers =
-        server_printers_provider_->GetPrinters();
-    if (complete) {
-      PRINTER_LOG(EVENT) << "The list of server printers has been completed. "
-                         << "Number of server printers: " << printers.size();
-    }
+  // Callback for PrintServersManager.
+  void OnServerPrintersChanged(
+      const std::vector<PrinterDetector::DetectedPrinter>& printers) override {
     OnPrintersFound(kPrintServerDetector, printers);
   }
 
@@ -468,68 +457,6 @@ class CupsPrintersManagerImpl
     }
   }
 
-  void OnPrintServersUpdated(bool is_complete,
-                             std::map<GURL, PrintServer> print_servers,
-                             ServerPrintersFetchingMode fetching_mode) {
-    fetching_mode_ = fetching_mode;
-    if (!is_complete) {
-      return;
-    }
-
-    print_servers_ = std::map<std::string, PrintServer>();
-    for (const auto& server_pair : print_servers) {
-      const PrintServer& server = server_pair.second;
-      print_servers_.value().emplace(server.GetId(), server);
-    }
-
-    if (fetching_mode_ == ServerPrintersFetchingMode::kSingleServerOnly) {
-      // If the previously selected print server is unavailable, set to the
-      // first print server in the list, or set to none if there are no print
-      // servers.
-      auto& servers = print_servers_.value();
-      if (!selected_print_server_id_.has_value() ||
-          !ChoosePrintServer(selected_print_server_id_)) {
-        auto first_id =
-            servers.empty()
-                ? base::nullopt
-                : base::make_optional(servers.begin()->second.GetId());
-        ChoosePrintServer(first_id);
-      }
-    } else {
-      selected_print_server_id_ = base::nullopt;
-      server_printers_provider_->OnServersChanged(true, print_servers);
-    }
-  }
-
-  // Public API function.
-  bool ChoosePrintServer(
-      const base::Optional<std::string>& selected_print_server_id) override {
-    if (fetching_mode_ != ServerPrintersFetchingMode::kSingleServerOnly ||
-        !print_servers_.has_value()) {
-      return false;
-    }
-
-    std::map<GURL, PrintServer> selected_print_servers;
-    if (selected_print_server_id.has_value()) {
-      auto iter = print_servers_.value().find(selected_print_server_id.value());
-      if (iter != print_servers_.value().end()) {
-        const PrintServer& server = iter->second;
-        selected_print_servers.emplace(server.GetUrl(), server);
-      } else {
-        // A selected value was given that is not available
-        return false;
-      }
-    }
-    selected_print_server_id_ = selected_print_server_id;
-    server_printers_provider_->OnServersChanged(true, selected_print_servers);
-    return true;
-  }
-
-  // Public API function.
-  ServerPrintersFetchingMode GetServerPrintersFetchingMode() const override {
-    return fetching_mode_;
-  }
-
  private:
   base::Optional<Printer> GetEnterprisePrinter(const std::string& id) const {
     return printers_.Get(PrinterClass::kEnterprise, id);
@@ -796,16 +723,7 @@ class CupsPrintersManagerImpl
 
   AutomaticUsbPrinterConfigurer auto_usb_printer_configurer_;
 
-  std::unique_ptr<PrintServersPolicyProvider> print_servers_provider_;
-
-  // The print server ID that is the current selection, if any.
-  base::Optional<std::string> selected_print_server_id_;
-
-  ServerPrintersFetchingMode fetching_mode_;
-
-  base::Optional<std::map<std::string, PrintServer>> print_servers_;
-
-  std::unique_ptr<ServerPrintersProvider> server_printers_provider_;
+  std::unique_ptr<PrintServersManager> print_servers_manager_;
 
   std::unique_ptr<EnterprisePrintersProvider> enterprise_printers_provider_;
   ScopedObserver<EnterprisePrintersProvider,
@@ -856,8 +774,7 @@ std::unique_ptr<CupsPrintersManager> CupsPrintersManager::Create(
       UsbPrinterDetector::Create(), ZeroconfPrinterDetector::Create(),
       CreatePpdProvider(profile), PrinterConfigurer::Create(profile),
       UsbPrinterNotificationController::Create(profile),
-      PrintServersPolicyProvider::Create(profile),
-      ServerPrintersProvider::Create(),
+      PrintServersManager::Create(profile),
       EnterprisePrintersProvider::Create(CrosSettings::Get(), profile),
       PrinterEventTrackerFactory::GetInstance()->GetForBrowserContext(profile),
       profile->GetPrefs());
@@ -872,8 +789,7 @@ std::unique_ptr<CupsPrintersManager> CupsPrintersManager::CreateForTesting(
     std::unique_ptr<PrinterConfigurer> printer_configurer,
     std::unique_ptr<UsbPrinterNotificationController>
         usb_notification_controller,
-    std::unique_ptr<ServerPrintersProvider> server_printers_provider,
-    std::unique_ptr<PrintServersPolicyProvider> print_servers_provider,
+    std::unique_ptr<PrintServersManager> print_servers_manager,
     std::unique_ptr<EnterprisePrintersProvider> enterprise_printers_provider,
     PrinterEventTracker* event_tracker,
     PrefService* pref_service) {
@@ -881,8 +797,8 @@ std::unique_ptr<CupsPrintersManager> CupsPrintersManager::CreateForTesting(
       synced_printers_manager, std::move(usb_detector),
       std::move(zeroconf_detector), std::move(ppd_provider),
       std::move(printer_configurer), std::move(usb_notification_controller),
-      std::move(print_servers_provider), std::move(server_printers_provider),
-      std::move(enterprise_printers_provider), event_tracker, pref_service);
+      std::move(print_servers_manager), std::move(enterprise_printers_provider),
+      event_tracker, pref_service);
 }
 
 // static

chrome/browser/chromeos/printing/cups_printers_manager.h

@@ -10,7 +10,7 @@
 
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
-#include "chrome/browser/chromeos/printing/print_servers_policy_provider.h"
+#include "chrome/browser/chromeos/printing/print_servers_manager.h"
 #include "chrome/browser/chromeos/printing/printer_installation_manager.h"
 #include "chromeos/printing/printer_configuration.h"
 #include "chromeos/printing/uri.h"
@@ -31,7 +31,6 @@ class PpdProvider;
 class PrinterConfigurer;
 class PrinterDetector;
 class PrinterEventTracker;
-class ServerPrintersProvider;
 class SyncedPrintersManager;
 class UsbPrinterNotificationController;
 
@@ -73,8 +72,7 @@ class CupsPrintersManager : public PrinterInstallationManager,
       std::unique_ptr<PrinterConfigurer> printer_configurer,
       std::unique_ptr<UsbPrinterNotificationController>
           usb_notification_controller,
-      std::unique_ptr<ServerPrintersProvider> server_printers_provider,
-      std::unique_ptr<PrintServersPolicyProvider> print_servers_provider,
+      std::unique_ptr<PrintServersManager> print_servers_manager,
       std::unique_ptr<EnterprisePrintersProvider> enterprise_printers_provider,
       PrinterEventTracker* event_tracker,
       PrefService* pref_service);
@@ -131,14 +129,6 @@ class CupsPrintersManager : public PrinterInstallationManager,
   // Records the total number of detected network printers and the
   // number of detected network printers that have not been saved.
   virtual void RecordNearbyNetworkPrinterCounts() const = 0;
-
-  // Selects a print server from all the available print servers. Returns true on
-  // successfully selecting the requested print server.
-  virtual bool ChoosePrintServer(
-      const base::Optional<std::string>& selected_print_server_id) = 0;
-
-  // Returns the current fetching mode strategy for print servers.
-  virtual ServerPrintersFetchingMode GetServerPrintersFetchingMode() const = 0;
 };
 
 }  // namespace chromeos

chrome/browser/chromeos/printing/print_servers_manager.cc

+// Copyright 2017 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/printing/print_servers_manager.h"
+
+#include <map>
+#include <utility>
+
+#include "ash/public/cpp/network_config_service.h"
+#include "base/bind.h"
+#include "base/metrics/histogram_functions.h"
+#include "base/observer_list.h"
+#include "base/optional.h"
+#include "base/scoped_observer.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/browser/chromeos/printing/cups_printer_status_creator.h"
+#include "chrome/browser/chromeos/printing/enterprise_printers_provider.h"
+#include "chrome/browser/chromeos/printing/ppd_provider_factory.h"
+#include "chrome/browser/chromeos/printing/ppd_resolution_tracker.h"
+#include "chrome/browser/chromeos/printing/print_servers_policy_provider.h"
+#include "chrome/browser/chromeos/printing/print_servers_provider.h"
+#include "chrome/browser/chromeos/printing/printer_configurer.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker.h"
+#include "chrome/browser/chromeos/printing/printer_event_tracker_factory.h"
+#include "chrome/browser/chromeos/printing/printer_info.h"
+#include "chrome/browser/chromeos/printing/printers_map.h"
+#include "chrome/browser/chromeos/printing/server_printers_provider.h"
+#include "chrome/browser/chromeos/printing/synced_printers_manager.h"
+#include "chrome/browser/chromeos/printing/synced_printers_manager_factory.h"
+#include "chrome/browser/chromeos/printing/usb_printer_notification_controller.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/pref_names.h"
+#include "chromeos/printing/cups_printer_status.h"
+#include "chromeos/printing/printing_constants.h"
+#include "chromeos/printing/uri.h"
+#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
+#include "components/device_event_log/device_event_log.h"
+#include "components/policy/policy_constants.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "components/prefs/pref_member.h"
+#include "components/prefs/pref_service.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
+#include "printing/printer_query_result.h"
+
+namespace chromeos {
+
+PrintServersConfig::PrintServersConfig() = default;
+PrintServersConfig::~PrintServersConfig() = default;
+PrintServersConfig::PrintServersConfig(const PrintServersConfig&) = default;
+PrintServersConfig& PrintServersConfig::operator=(const PrintServersConfig&) =
+    default;
+
+namespace {
+
+class PrintServersManagerImpl : public PrintServersManager {
+ public:
+  PrintServersManagerImpl(
+      std::unique_ptr<PrintServersPolicyProvider> print_servers_provider,
+      std::unique_ptr<ServerPrintersProvider> server_printers_provider)
+      : print_servers_provider_(std::move(print_servers_provider)),
+        server_printers_provider_(std::move(server_printers_provider)) {
+    print_servers_provider_->SetListener(
+        base::BindRepeating(&PrintServersManagerImpl::OnPrintServersUpdated,
+                            weak_ptr_factory_.GetWeakPtr()));
+    server_printers_provider_->RegisterPrintersFoundCallback(
+        base::BindRepeating(&PrintServersManagerImpl::OnPrintersUpdated,
+                            weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  ~PrintServersManagerImpl() override = default;
+
+  // Public API function.
+  void AddObserver(PrintServersManager::Observer* observer) override {
+    observer_list_.AddObserver(observer);
+  }
+
+  // Public API function.
+  void RemoveObserver(PrintServersManager::Observer* observer) override {
+    observer_list_.RemoveObserver(observer);
+  }
+
+  // Callback for ServerPrintersProvider.
+  void OnPrintersUpdated(bool complete) {
+    const std::vector<PrinterDetector::DetectedPrinter> printers =
+        server_printers_provider_->GetPrinters();
+    if (complete) {
+      PRINTER_LOG(EVENT) << "The list of server printers has been completed. "
+                         << "Number of server printers: " << printers.size();
+    }
+    for (auto& observer : observer_list_) {
+      observer.OnServerPrintersChanged(printers);
+    }
+  }
+
+  void OnPrintServersUpdated(bool is_complete,
+                             std::map<GURL, PrintServer> print_servers,
+                             ServerPrintersFetchingMode fetching_mode) {
+    fetching_mode_ = fetching_mode;
+    if (!is_complete) {
+      return;
+    }
+
+    print_servers_ = std::map<std::string, PrintServer>();
+    std::vector<PrintServer> print_servers_list;
+    for (const auto& server_pair : print_servers) {
+      const PrintServer& server = server_pair.second;
+      print_servers_.value().emplace(server.GetId(), server);
+      print_servers_list.push_back(server);
+    }
+
+    if (fetching_mode_ == ServerPrintersFetchingMode::kSingleServerOnly) {
+      ChoosePrintServer(selected_print_server_ids_);
+    } else {
+      selected_print_server_ids_.clear();
+      server_printers_provider_->OnServersChanged(true, print_servers);
+    }
+
+    config_ = PrintServersConfig();
+    config_.print_servers = print_servers_list;
+    config_.fetching_mode = fetching_mode;
+    for (auto& observer : observer_list_) {
+      observer.OnPrintServersChanged(config_);
+    }
+  }
+
+  // Public API function.
+  void ChoosePrintServer(
+      const std::vector<std::string>& selected_print_server_ids) override {
+    if (fetching_mode_ != ServerPrintersFetchingMode::kSingleServerOnly ||
+        !print_servers_.has_value()) {
+      return;
+    }
+
+    std::map<GURL, PrintServer> selected_print_servers;
+    std::vector<std::string> selected_ids;
+    for (auto selected_print_server_id : selected_print_server_ids) {
+      auto iter = print_servers_.value().find(selected_print_server_id);
+      if (iter != print_servers_.value().end()) {
+        const PrintServer& server = iter->second;
+        selected_ids.push_back(selected_print_server_id);
+        selected_print_servers.emplace(server.GetUrl(), server);
+      }
+    }
+    selected_print_server_ids_ = selected_ids;
+    server_printers_provider_->OnServersChanged(true, selected_print_servers);
+  }
+
+  // Public API function.
+  PrintServersConfig GetPrintServersConfig() const override { return config_; }
+
+ private:
+  std::unique_ptr<PrintServersPolicyProvider> print_servers_provider_;
+
+  // The IDs of the currently selected print servers.
+  std::vector<std::string> selected_print_server_ids_;
+
+  ServerPrintersFetchingMode fetching_mode_;
+
+  base::Optional<std::map<std::string, PrintServer>> print_servers_;
+
+  PrintServersConfig config_;
+
+  std::unique_ptr<ServerPrintersProvider> server_printers_provider_;
+
+  base::ObserverList<PrintServersManager::Observer>::Unchecked observer_list_;
+
+  base::WeakPtrFactory<PrintServersManagerImpl> weak_ptr_factory_{this};
+};
+
+}  // namespace
+
+// static
+std::unique_ptr<PrintServersManager> PrintServersManager::Create(
+    Profile* profile) {
+  return std::make_unique<PrintServersManagerImpl>(
+      PrintServersPolicyProvider::Create(profile),
+      ServerPrintersProvider::Create());
+}
+
+// static
+std::unique_ptr<PrintServersManager> PrintServersManager::CreateForTesting(
+    std::unique_ptr<ServerPrintersProvider> server_printers_provider,
+    std::unique_ptr<PrintServersPolicyProvider> print_servers_provider) {
+  return std::make_unique<PrintServersManagerImpl>(
+      std::move(print_servers_provider), std::move(server_printers_provider));
+}
+
+// static
+void PrintServersManager::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  PrintServersProvider::RegisterProfilePrefs(registry);
+}
+
+// static
+void PrintServersManager::RegisterLocalStatePrefs(
+    PrefRegistrySimple* registry) {
+  PrintServersProvider::RegisterLocalStatePrefs(registry);
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/print_servers_manager.h

+// Copyright 2017 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_PRINTING_PRINT_SERVERS_MANAGER_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_PRINT_SERVERS_MANAGER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/memory/ref_counted.h"
+#include "chrome/browser/chromeos/printing/print_server.h"
+#include "chrome/browser/chromeos/printing/print_servers_manager.h"
+#include "chrome/browser/chromeos/printing/print_servers_policy_provider.h"
+#include "chrome/browser/chromeos/printing/printer_detector.h"
+#include "chrome/browser/chromeos/printing/printer_installation_manager.h"
+#include "chromeos/printing/printer_configuration.h"
+#include "chromeos/printing/uri.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+class PrefRegistrySimple;
+class Profile;
+
+namespace user_prefs {
+class PrefRegistrySyncable;
+}
+
+namespace chromeos {
+
+class PrinterDetector;
+class ServerPrintersProvider;
+
+struct PrintServersConfig {
+  PrintServersConfig();
+  ~PrintServersConfig();
+  PrintServersConfig(const PrintServersConfig&);
+  PrintServersConfig& operator=(const PrintServersConfig&);
+
+  ServerPrintersFetchingMode fetching_mode;
+  std::vector<PrintServer> print_servers;
+};
+
+// Manager of IPP print servers in ChromeOS.
+class PrintServersManager {
+ public:
+  class Observer {
+   public:
+    virtual void OnPrintServersChanged(const PrintServersConfig& config) {}
+    virtual void OnServerPrintersChanged(
+        const std::vector<PrinterDetector::DetectedPrinter>& printers) {}
+
+    virtual ~Observer() = default;
+  };
+
+  // Factory function.
+  static std::unique_ptr<PrintServersManager> Create(Profile* profile);
+
+  // Factory function that allows injected dependencies, for testing.
+  static std::unique_ptr<PrintServersManager> CreateForTesting(
+      std::unique_ptr<ServerPrintersProvider> server_printers_provider,
+      std::unique_ptr<PrintServersPolicyProvider> print_servers_provider);
+
+  // Register the profile printing preferences with the |registry|.
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
+  // Register the printing preferences with the |registry|.
+  static void RegisterLocalStatePrefs(PrefRegistrySimple* registry);
+
+  virtual ~PrintServersManager() = default;
+
+  // Add or remove observers.
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+
+  // Selects print servers from all the available print servers. Returns true
+  // on successfully selecting the requested print server.
+  virtual void ChoosePrintServer(
+      const std::vector<std::string>& selected_print_server_ids) = 0;
+
+  // Gets all the print servers available through device or user policy and the
+  // current fetching mode strategy for print servers.
+  virtual PrintServersConfig GetPrintServersConfig() const = 0;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_PRINT_SERVERS_MANAGER_H_

chrome/browser/chromeos/printing/print_servers_manager_unittest.cc

+// 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.
+
+#include "chrome/browser/chromeos/printing/print_servers_manager.h"
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "base/containers/flat_map.h"
+#include "base/containers/flat_set.h"
+#include "base/sequenced_task_runner.h"
+#include "base/test/task_environment.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "chrome/browser/chromeos/printing/print_servers_provider.h"
+#include "chrome/browser/chromeos/printing/server_printers_provider.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "components/prefs/pref_service.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "content/public/test/browser_task_environment.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace {
+
+class FakeServerPrintersProvider : public ServerPrintersProvider {
+ public:
+  FakeServerPrintersProvider() = default;
+  ~FakeServerPrintersProvider() override = default;
+
+  void RegisterPrintersFoundCallback(OnPrintersUpdateCallback cb) override {}
+
+  void OnServersChanged(bool servers_are_complete,
+                        const std::map<GURL, PrintServer>& servers) override {
+    std::vector<chromeos::PrintServer> print_servers;
+    for (auto& server_pair : servers) {
+      print_servers.push_back(server_pair.second);
+    }
+    print_servers_ = print_servers;
+  }
+
+  std::vector<PrinterDetector::DetectedPrinter> GetPrinters() override {
+    std::vector<PrinterDetector::DetectedPrinter> printers;
+    return printers;
+  }
+
+  std::vector<chromeos::PrintServer> GetPrintServers() {
+    return print_servers_;
+  }
+
+ private:
+  std::vector<chromeos::PrintServer> print_servers_;
+};
+
+class FakePrintServersProvider : public PrintServersProvider {
+ public:
+  FakePrintServersProvider() = default;
+  ~FakePrintServersProvider() override = default;
+
+  void AddObserver(Observer* observer) override { observer_ = observer; }
+  void RemoveObserver(Observer* observer) override {}
+  void SetData(std::unique_ptr<std::string> data) override {}
+  void SetAllowlistPref(PrefService* prefs,
+                        const std::string& allowlist_pref) override {}
+  void ClearData() override {}
+
+  base::Optional<std::vector<PrintServer>> GetPrintServers() override {
+    return print_servers_;
+  }
+
+  void SetPrintServers(base::Optional<std::vector<PrintServer>> print_servers) {
+    print_servers_ = print_servers;
+    if (observer_) {
+      observer_->OnServersChanged(print_servers.has_value(),
+                                  print_servers.value());
+    }
+  }
+
+ private:
+  base::Optional<std::vector<PrintServer>> print_servers_;
+  PrintServersProvider::Observer* observer_;
+};
+
+class PrintServersManagerTest : public testing::Test,
+                                public PrintServersManager::Observer {
+ public:
+  PrintServersManagerTest() {
+    auto server_printers_provider =
+        std::make_unique<FakeServerPrintersProvider>();
+    server_printers_provider_ = server_printers_provider.get();
+    auto print_servers_policy_provider =
+        PrintServersPolicyProvider::CreateForTesting(
+            user_policy_print_servers_provider_.AsWeakPtr(),
+            device_policy_print_servers_provider_.AsWeakPtr());
+
+    PrintServersManager::RegisterProfilePrefs(pref_service_.registry());
+
+    manager_ = PrintServersManager::CreateForTesting(
+        std::move(server_printers_provider),
+        std::move(print_servers_policy_provider));
+    manager_->AddObserver(this);
+  }
+
+  ~PrintServersManagerTest() override {}
+
+  static chromeos::PrintServer CreatePrintServer(std::string id,
+                                                 std::string server_url,
+                                                 std::string name) {
+    GURL url(server_url);
+    chromeos::PrintServer print_server(id, url, name);
+    return print_server;
+  }
+
+ protected:
+  // Everything from PrintServersProvider must be called on Chrome_UIThread
+  content::BrowserTaskEnvironment task_environment_;
+
+  // Captured printer lists from observer callbacks.
+  base::flat_map<PrinterClass, std::vector<Printer>> observed_printers_;
+
+  FakeServerPrintersProvider* server_printers_provider_;
+  FakePrintServersProvider user_policy_print_servers_provider_;
+  FakePrintServersProvider device_policy_print_servers_provider_;
+
+  // PrefService used to register the |UserPrintersAllowed| pref and
+  // change its value for testing.
+  sync_preferences::TestingPrefServiceSyncable pref_service_;
+
+  // The manager being tested.
+  std::unique_ptr<PrintServersManager> manager_;
+};
+
+TEST_F(PrintServersManagerTest, GetServerPrinters_StandardMode) {
+  EXPECT_TRUE(server_printers_provider_->GetPrinters().empty());
+
+  std::vector<chromeos::PrintServer> user_print_servers;
+  auto user_print_server =
+      CreatePrintServer("1", "http://192.168.1.5/user-printer", "LexaPrint");
+  user_print_servers.push_back(user_print_server);
+  user_policy_print_servers_provider_.SetPrintServers(user_print_servers);
+  std::vector<chromeos::PrintServer> device_print_servers;
+  auto device_print_server = CreatePrintServer(
+      "2", "http://192.168.1.5/device-printer", "Color Laser");
+  device_print_servers.push_back(device_print_server);
+  device_policy_print_servers_provider_.SetPrintServers(device_print_servers);
+
+  EXPECT_THAT(
+      server_printers_provider_->GetPrintServers(),
+      testing::UnorderedElementsAre(user_print_server, device_print_server));
+}
+
+TEST_F(PrintServersManagerTest, GetServerPrinters_SingleServerOnly) {
+  EXPECT_TRUE(server_printers_provider_->GetPrinters().empty());
+
+  auto selected_print_server =
+      CreatePrintServer("user-1", "http://user-print-1", "User LexaPrint - 1");
+
+  std::vector<chromeos::PrintServer> user_print_servers;
+  for (int i = 1; i <= 10; ++i) {
+    auto id = base::NumberToString(i);
+    auto print_server = CreatePrintServer(
+        "user-" + id, "http://user-print-" + id, "User LexaPrint - " + id);
+    user_print_servers.push_back(print_server);
+  }
+  user_policy_print_servers_provider_.SetPrintServers(user_print_servers);
+  std::vector<chromeos::PrintServer> device_print_servers;
+  for (int i = 1; i <= 7; ++i) {
+    auto id = base::NumberToString(i);
+    auto print_server =
+        CreatePrintServer("device-" + id, "http://device-print-" + id,
+                          "Device LexaPrint - " + id);
+    device_print_servers.push_back(print_server);
+  }
+  device_policy_print_servers_provider_.SetPrintServers(device_print_servers);
+
+  std::vector<std::string> ids;
+  ids.push_back(selected_print_server.GetId());
+  manager_->ChoosePrintServer(ids);
+
+  EXPECT_THAT(server_printers_provider_->GetPrintServers(),
+              testing::UnorderedElementsAre(selected_print_server));
+}
+
+}  // namespace
+}  // namespace chromeos

chrome/browser/chromeos/printing/printing_stubs.cc

@@ -20,14 +20,4 @@ base::Optional<Printer> StubCupsPrintersManager::GetPrinter(
   return {};
 }
 
-bool StubCupsPrintersManager::ChoosePrintServer(
-    const base::Optional<std::string>& selected_print_server_id) {
-  return true;
-}
-
-ServerPrintersFetchingMode StubCupsPrintersManager::GetServerPrintersFetchingMode()
-    const {
-  return ServerPrintersFetchingMode::kStandard;
-}
-
 }  // namespace chromeos

chrome/browser/chromeos/printing/printing_stubs.h

@@ -33,9 +33,6 @@ class StubCupsPrintersManager : public CupsPrintersManager {
   void FetchPrinterStatus(const std::string& printer_id,
                           PrinterStatusCallback cb) override {}
   void RecordNearbyNetworkPrinterCounts() const override {}
-  bool ChoosePrintServer(
-      const base::Optional<std::string>& selected_print_server_id) override;
-  ServerPrintersFetchingMode GetServerPrintersFetchingMode() const override;
 };
 
 class StubPrinterConfigurer : public PrinterConfigurer {