Remove the legacy (extension-notifier) usb printer detector. Rename the remaining printerdetector …

chrome/browser/chromeos/printer_detector/usb_printer_detector.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 <stdint.h>
 
+#include <map>
 #include <memory>
+#include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/scoped_observer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/chromeos/printer_detector/printer_detector.h"
+#include "chrome/browser/chromeos/printer_detector/usb_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/printers_manager_factory.h"
 #include "chrome/browser/chromeos/printing/usb_printer_util.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #include "chromeos/printing/ppd_provider.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/base/device_client.h"
@@ skipping 32 matching lines @@
 // TODO(justincarlson): Possibly go deeper and query the IEEE1284 fields
 // for make and model if we determine those are more likely to contain
 // what we want.
 std::string GuessEffectiveMakeAndModel(const device::UsbDevice& device) {
   return base::UTF16ToUTF8(device.manufacturer_string()) + " " +
          base::UTF16ToUTF8(device.product_string());
 }
 
 // The PrinterDetector that drives the flow for setting up a USB printer to use
 // CUPS backend.
-class CupsPrinterDetectorImpl : public PrinterDetector,
-                                public device::UsbService::Observer {
+class UsbPrinterDetectorImpl : public UsbPrinterDetector,
+                               public device::UsbService::Observer {
  public:
-  explicit CupsPrinterDetectorImpl(Profile* profile)
+  explicit UsbPrinterDetectorImpl(Profile* profile)
       : profile_(profile),
         usb_observer_(this),
         observer_list_(
-            new base::ObserverListThreadSafe<PrinterDetector::Observer>),
+            new base::ObserverListThreadSafe<UsbPrinterDetector::Observer>),
         weak_ptr_factory_(this) {
     device::UsbService* usb_service =
         device::DeviceClient::Get()->GetUsbService();
     if (usb_service) {
       usb_observer_.Add(usb_service);
-      usb_service->GetDevices(base::Bind(&CupsPrinterDetectorImpl::OnGetDevices,
+      usb_service->GetDevices(base::Bind(&UsbPrinterDetectorImpl::OnGetDevices,
                                          weak_ptr_factory_.GetWeakPtr()));
     }
   }
-  ~CupsPrinterDetectorImpl() override = default;
+  ~UsbPrinterDetectorImpl() override = default;
 
   // PrinterDetector interface function.
-  void AddObserver(PrinterDetector::Observer* observer) override {
+  void AddObserver(UsbPrinterDetector::Observer* observer) override {
     observer_list_->AddObserver(observer);
   }
 
   // PrinterDetector interface function.
-  void RemoveObserver(PrinterDetector::Observer* observer) override {
+  void RemoveObserver(UsbPrinterDetector::Observer* observer) override {
     observer_list_->RemoveObserver(observer);
   }
 
   // PrinterDetector interface function.
   std::vector<Printer> GetPrinters() override {
     base::AutoLock auto_lock(pp_lock_);
     return GetPrintersLocked();
   }
 
  private:
@@ skipping 29 matching lines @@
       return;
     }
 
     base::AutoLock auto_lock(pp_lock_);
     if (base::ContainsKey(present_printers_, device->guid())) {
       present_printers_.erase(device->guid());
       auto printers = GetPrintersLocked();
       // We already have pp_lock_, so need to call the pre-locked version of
       // GetPrinters to prevent deadlock.
       observer_list_->Notify(
-          FROM_HERE, &PrinterDetector::Observer::OnAvailableUsbPrintersChanged,
+          FROM_HERE,
+          &UsbPrinterDetector::Observer::OnAvailableUsbPrintersChanged,
           GetPrintersLocked());
     } else {
       // If the device has been removed but it's not in present_printers_, it
       // must still be in the setup flow.
       deferred_printer_removals_.insert(device->guid());
     }
   }
 
   // If this device is a printer and we haven't already tried to set it up,
   // starts the process of setting the printer up.  |hotplugged|
@@ skipping 36 matching lines @@
     //
     // TODO(justincarlson): Add a notification that we are attempting to set up
     // this printer at this point.
     data->is_new = true;
 
     // Look for an exact match based on USB ids.
     scoped_refptr<PpdProvider> ppd_provider =
         printing::CreateProvider(profile_);
     ppd_provider->ResolveUsbIds(
         device->vendor_id(), device->product_id(),
-        base::Bind(&CupsPrinterDetectorImpl::ResolveUsbIdsDone,
+        base::Bind(&UsbPrinterDetectorImpl::ResolveUsbIdsDone,
                    weak_ptr_factory_.GetWeakPtr(), ppd_provider,
                    base::Passed(std::move(data))));
   }
 
   void OnPrinterResolved(std::unique_ptr<SetUpPrinterData> data) {
     // |data| will be invalidated by the move below, so we have to latch it
     // before the call.
     SetUpPrinterData* data_ptr = data.get();
     data_ptr->configurer->SetUpPrinter(
         *(data_ptr->printer),
-        base::Bind(&CupsPrinterDetectorImpl::SetUpPrinterDone,
+        base::Bind(&UsbPrinterDetectorImpl::SetUpPrinterDone,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(std::move(data))));
   }
 
   // Called when the query for a driver based on usb ids completes.
   //
   // Note |provider| is not used in this function, it's just passed along to
   // keep it alive during the USB resolution.
   void ResolveUsbIdsDone(scoped_refptr<PpdProvider> provider,
                          std::unique_ptr<SetUpPrinterData> data,
@@ skipping 38 matching lines @@
     // configuration settings.
 
     if (base::ContainsKey(deferred_printer_removals_, data->device->guid())) {
       // The device was removed before we finished the flow, so just don't add
       // it to present_printers_;
       deferred_printer_removals_.erase(data->device->guid());
     } else {
       base::AutoLock auto_lock(pp_lock_);
       present_printers_.emplace(data->device->guid(), std::move(data->printer));
       observer_list_->Notify(
-          FROM_HERE, &PrinterDetector::Observer::OnAvailableUsbPrintersChanged,
+          FROM_HERE,
+          &UsbPrinterDetector::Observer::OnAvailableUsbPrintersChanged,
           GetPrintersLocked());
     }
   }
 
-  void SetNotificationUIManagerForTesting(
-      NotificationUIManager* manager) override {
-    LOG(FATAL) << "Not implemented for CUPS";
-  }
-
   // Map from USB GUID to Printer that we have detected as being currently
   // plugged in and have finished processing.  Note present_printers_ may be
   // accessed from multiple threads, so is protected by pp_lock_.
   std::map<std::string, std::unique_ptr<Printer>> present_printers_;
   base::Lock pp_lock_;
 
   // If the usb device is removed before we've finished processing it, we'll
   // defer the cleanup until the setup flow finishes.  This is the set of
   // guids which have been removed before the flow finished.
   std::set<std::string> deferred_printer_removals_;
 
   Profile* profile_;
   ScopedObserver<device::UsbService, device::UsbService::Observer>
       usb_observer_;
-  scoped_refptr<base::ObserverListThreadSafe<PrinterDetector::Observer>>
+  scoped_refptr<base::ObserverListThreadSafe<UsbPrinterDetector::Observer>>
       observer_list_;
-  base::WeakPtrFactory<CupsPrinterDetectorImpl> weak_ptr_factory_;
+  base::WeakPtrFactory<UsbPrinterDetectorImpl> weak_ptr_factory_;
 };
 
 }  // namespace
 
-// Nop base class implementation of GetPrinters().  Because this is non-empty we
-// have to define it out-of-line.
-std::vector<Printer> PrinterDetector::GetPrinters() {
-  return std::vector<Printer>();
-}
-
 // static
-std::unique_ptr<PrinterDetector> PrinterDetector::CreateCups(Profile* profile) {
-  return base::MakeUnique<CupsPrinterDetectorImpl>(profile);
+std::unique_ptr<UsbPrinterDetector> UsbPrinterDetector::Create(
+    Profile* profile) {
+  return base::MakeUnique<UsbPrinterDetectorImpl>(profile);
 }
 
 }  // namespace chromeos