Refactor PrinterDiscoverer and PrinterDetector to use a common interface.

chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc

 // Copyright 2016 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/ui/webui/settings/chromeos/cups_printers_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/printing/combining_printer_detector.h"
 #include "chrome/browser/chromeos/printing/ppd_provider_factory.h"
 #include "chrome/browser/chromeos/printing/printer_configurer.h"
-#include "chrome/browser/chromeos/printing/printer_discoverer.h"
 #include "chrome/browser/chromeos/printing/printer_info.h"
 #include "chrome/browser/chromeos/printing/printers_manager_factory.h"
+#include "chrome/browser/chromeos/printing/usb_printer_detector.h"
+#include "chrome/browser/chromeos/printing/usb_printer_detector_factory.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/chrome_paths.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #include "chromeos/printing/ppd_cache.h"
 #include "chromeos/printing/ppd_provider.h"
@@ skipping 84 matching lines @@
     // empty string if the input is just a backslash.
     queue = queue.substr(1);
   }
 
   return queue;
 }
 
 }  // namespace
 
 CupsPrintersHandler::CupsPrintersHandler(content::WebUI* webui)
-    : printer_discoverer_(nullptr),
+    : printer_detector_(nullptr),
       profile_(Profile::FromWebUI(webui)),
       weak_factory_(this) {
   ppd_provider_ = printing::CreateProvider(profile_);
-  printer_configurer_ = chromeos::PrinterConfigurer::Create(profile_);
+  printer_configurer_ = PrinterConfigurer::Create(profile_);
 }
 
 CupsPrintersHandler::~CupsPrintersHandler() {}
 
 void CupsPrintersHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "getCupsPrintersList",
       base::Bind(&CupsPrintersHandler::HandleGetCupsPrintersList,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
@@ skipping 73 matching lines @@
   CHECK(args->GetString(1, &printer_name));
   PrintersManager* prefs =
       PrintersManagerFactory::GetForBrowserContext(profile_);
   auto printer = prefs->GetPrinter(printer_id);
   if (!printer)
     return;
 
   Printer::PrinterProtocol protocol = printer->GetProtocol();
   prefs->RemovePrinter(printer_id);
 
-  chromeos::DebugDaemonClient* client =
-      chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
+  DebugDaemonClient* client = DBusThreadManager::Get()->GetDebugDaemonClient();
   client->CupsRemovePrinter(printer_name,
                             base::Bind(&OnRemovedPrinter, protocol),
                             base::Bind(&base::DoNothing));
 }
 
 void CupsPrintersHandler::HandleGetPrinterInfo(const base::ListValue* args) {
   DCHECK(args);
   std::string callback_id;
   if (!args->GetString(0, &callback_id)) {
     NOTREACHED() << "Expected request for a promise";
@@ skipping 44 matching lines @@
     if (printer_protocol == kIppScheme) {
       port = kIppPort;
     } else if (printer_protocol == kIppsScheme) {
       // ipps is ipp over https so it uses the https port.
       port = kIppsPort;
     } else {
       NOTREACHED() << "Unrecognized protocol. Port was not set.";
     }
   }
 
-  ::chromeos::QueryIppPrinter(
-      host.as_string(), port, printer_queue,
-      base::Bind(&CupsPrintersHandler::OnPrinterInfo,
-                 weak_factory_.GetWeakPtr(), callback_id));
+  QueryIppPrinter(host.as_string(), port, printer_queue,
+                  base::Bind(&CupsPrintersHandler::OnPrinterInfo,
+                             weak_factory_.GetWeakPtr(), callback_id));
 }
 
 void CupsPrintersHandler::OnPrinterInfo(const std::string& callback_id,
                                         bool success,
                                         const std::string& make,
                                         const std::string& model,
                                         bool ipp_everywhere) {
   if (!success) {
     base::DictionaryValue reject;
     reject.SetString("message", "Querying printer failed");
@@ skipping 76 matching lines @@
 
   // Copy the printer for the configurer.  Ownership needs to be transfered to
   // the receiver of the callback.
   const Printer printer_copy = *printer;
   printer_configurer_->SetUpPrinter(
       printer_copy,
       base::Bind(&CupsPrintersHandler::OnAddedPrinter,
                  weak_factory_.GetWeakPtr(), base::Passed(&printer)));
 }
 
-void CupsPrintersHandler::OnAddedPrinter(
-    std::unique_ptr<Printer> printer,
-    chromeos::PrinterSetupResult result_code) {
+void CupsPrintersHandler::OnAddedPrinter(std::unique_ptr<Printer> printer,
+                                         PrinterSetupResult result_code) {
   std::string printer_name = printer->display_name();
   UMA_HISTOGRAM_ENUMERATION("Printing.CUPS.PrinterSetupResult", result_code,
-                            chromeos::PrinterSetupResult::kMaxValue);
+                            PrinterSetupResult::kMaxValue);
   switch (result_code) {
-    case chromeos::PrinterSetupResult::kSuccess: {
+    case PrinterSetupResult::kSuccess: {
       UMA_HISTOGRAM_ENUMERATION("Printing.CUPS.PrinterAdded",
                                 printer->GetProtocol(), Printer::kProtocolMax);
       auto* manager = PrintersManagerFactory::GetForBrowserContext(profile_);
       manager->PrinterInstalled(*printer);
       manager->RegisterPrinter(std::move(printer));
       break;
     }
-    case chromeos::PrinterSetupResult::kPpdNotFound:
+    case PrinterSetupResult::kPpdNotFound:
       LOG(WARNING) << "Could not locate requested PPD";
       break;
-    case chromeos::PrinterSetupResult::kPpdTooLarge:
+    case PrinterSetupResult::kPpdTooLarge:
       LOG(WARNING) << "PPD is too large";
       break;
-    case chromeos::PrinterSetupResult::kPpdUnretrievable:
+    case PrinterSetupResult::kPpdUnretrievable:
       LOG(WARNING) << "Could not retrieve PPD from server";
       break;
-    case chromeos::PrinterSetupResult::kInvalidPpd:
+    case PrinterSetupResult::kInvalidPpd:
       LOG(WARNING) << "Provided PPD is invalid.";
       break;
-    case chromeos::PrinterSetupResult::kPrinterUnreachable:
+    case PrinterSetupResult::kPrinterUnreachable:
       LOG(WARNING) << "Could not contact printer for configuration";
       break;
-    case chromeos::PrinterSetupResult::kDbusError:
-    case chromeos::PrinterSetupResult::kFatalError:
+    case PrinterSetupResult::kDbusError:
+    case PrinterSetupResult::kFatalError:
       LOG(ERROR) << "Unrecoverable error.  Reboot required.";
       break;
-    case chromeos::PrinterSetupResult::kMaxValue:
+    case PrinterSetupResult::kMaxValue:
       NOTREACHED() << "This is not an expected value";
       break;
   }
   CallJavascriptFunction(
       "cr.webUIListenerCallback", base::Value("on-add-cups-printer"),
-      base::Value(result_code == chromeos::PrinterSetupResult::kSuccess),
+      base::Value(result_code == PrinterSetupResult::kSuccess),
       base::Value(printer_name));
 }
 
 void CupsPrintersHandler::OnAddPrinterError() {
   FireWebUIListener("on-add-cups-printer", base::Value(false), base::Value(""));
 }
 
 void CupsPrintersHandler::HandleGetCupsPrinterManufacturers(
     const base::ListValue* args) {
   AllowJavascript();
@@ skipping 44 matching lines @@
       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents())
           ->window()
           ->GetNativeWindow();
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_OPEN_FILE, base::string16(), downloads_path,
       nullptr, 0, FILE_PATH_LITERAL(""), owning_window, nullptr);
 }
 
 void CupsPrintersHandler::ResolveManufacturersDone(
     const std::string& js_callback,
-    chromeos::printing::PpdProvider::CallbackResultCode result_code,
+    printing::PpdProvider::CallbackResultCode result_code,
     const std::vector<std::string>& manufacturers) {
   auto manufacturers_value = base::MakeUnique<base::ListValue>();
-  if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
+  if (result_code == printing::PpdProvider::SUCCESS) {
     manufacturers_value->AppendStrings(manufacturers);
   }
   base::DictionaryValue response;
-  response.SetBoolean("success",
-                      result_code == chromeos::printing::PpdProvider::SUCCESS);
+  response.SetBoolean("success", result_code == printing::PpdProvider::SUCCESS);
   response.Set("manufacturers", std::move(manufacturers_value));
   ResolveJavascriptCallback(base::Value(js_callback), response);
 }
 
 void CupsPrintersHandler::ResolvePrintersDone(
     const std::string& js_callback,
-    chromeos::printing::PpdProvider::CallbackResultCode result_code,
+    printing::PpdProvider::CallbackResultCode result_code,
     const std::vector<std::string>& printers) {
   auto printers_value = base::MakeUnique<base::ListValue>();
-  if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
+  if (result_code == printing::PpdProvider::SUCCESS) {
     printers_value->AppendStrings(printers);
   }
   base::DictionaryValue response;
-  response.SetBoolean("success",
-                      result_code == chromeos::printing::PpdProvider::SUCCESS);
+  response.SetBoolean("success", result_code == printing::PpdProvider::SUCCESS);
   response.Set("models", std::move(printers_value));
   ResolveJavascriptCallback(base::Value(js_callback), response);
 }
 
 void CupsPrintersHandler::FileSelected(const base::FilePath& path,
                                        int index,
                                        void* params) {
   DCHECK(!webui_callback_id_.empty());
   ResolveJavascriptCallback(base::Value(webui_callback_id_),
                             base::Value(path.value()));
   webui_callback_id_.clear();
 }
 
 void CupsPrintersHandler::HandleStartDiscovery(const base::ListValue* args) {
-  if (!printer_discoverer_.get()) {
-    printer_discoverer_ =
-        chromeos::PrinterDiscoverer::CreateForProfile(profile_);
-  }
-
-  printer_discoverer_->AddObserver(this);
+  // Create (or recreate) the printer_detector_.  If one already existed, we
+  // want to start over anyways.
+  printer_detector_ = CombiningPrinterDetector::Create();
+  PrinterDetector* usb_detector =
+      UsbPrinterDetectorFactory::GetInstance()->Get(profile_);
+  DCHECK(usb_detector);
+  printer_detector_->AddDetector(usb_detector);
+  printer_detector_->AddObserver(this);
+  OnPrintersFound(printer_detector_->GetPrinters());
+  printer_detector_->Start();
 }
 
 void CupsPrintersHandler::HandleStopDiscovery(const base::ListValue* args) {
-  printer_discoverer_.reset();
+  printer_detector_.reset();
 }
 
 void CupsPrintersHandler::OnPrintersFound(
     const std::vector<Printer>& printers) {
   std::unique_ptr<base::ListValue> printers_list =
       base::MakeUnique<base::ListValue>();
-  for (const auto& printer : printers) {
-    printers_list->Append(GetPrinterInfo(printer));
+  // Filter out already-configured printers as we go.
+  PrintersManager* printers_manager =
+      PrintersManagerFactory::GetForBrowserContext(profile_);
+  if (printers_manager != nullptr) {
+    for (const auto& printer : printers) {
+      if (printers_manager->GetPrinter(printer.id()).get() == nullptr) {
+        printers_list->Append(GetPrinterInfo(printer));
+      }
+    }
+  } else {
+    LOG(WARNING) << "Failing to get available printers because no "
+                    "PrintersManager exists.";
   }
-
   FireWebUIListener("on-printer-discovered", *printers_list);
 }
 
-void CupsPrintersHandler::OnDiscoveryInitialScanDone(int printer_count) {
-  UMA_HISTOGRAM_COUNTS_100("Printing.CUPS.PrintersDiscovered", printer_count);
+void CupsPrintersHandler::OnPrinterScanComplete() {
+  UMA_HISTOGRAM_COUNTS_100("Printing.CUPS.PrintersDiscovered",
+                           printer_detector_->GetPrinters().size());
   FireWebUIListener("on-printer-discovery-done");
 }
 
 }  // namespace settings
 }  // namespace chromeos