Refactor PrinterDiscoverer and PrinterDetector to use a common interface.

chrome/browser/chromeos/printing/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>
@@ skipping 89 matching lines @@
   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();
   }
 
+  void Start() override {
+    started_ = true;
+    observer_list_->Notify(FROM_HERE,
+                           &PrinterDetector::Observer::OnPrintersFound,
+                           GetPrintersLocked());
+    observer_list_->Notify(FROM_HERE,
+                           &PrinterDetector::Observer::OnPrinterScanComplete);
+  }
+
  private:
   std::vector<Printer> GetPrintersLocked() {
     pp_lock_.AssertAcquired();
     std::vector<Printer> printers;
     printers.reserve(present_printers_.size());
     for (const auto& entry : present_printers_) {
       printers.push_back(*entry.second);
     }
     return printers;
   }
@@ skipping 16 matching lines @@
   // UsbService::observer override.
   void OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     if (!UsbDeviceIsPrinter(*device)) {
       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,
-          &UsbPrinterDetector::Observer::OnAvailableUsbPrintersChanged,
-          GetPrintersLocked());
+      if (started_) {
+        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::OnPrintersFound,
+                               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|
   // should be true if this was plugged in during the session.
@@ skipping 104 matching lines @@
     // tells the user automatic setup failed and offers to open the CUPS printer
     // 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,
-          &UsbPrinterDetector::Observer::OnAvailableUsbPrintersChanged,
-          GetPrintersLocked());
+      if (started_) {
+        observer_list_->Notify(FROM_HERE,
+                               &PrinterDetector::Observer::OnPrintersFound,
+                               GetPrintersLocked());
+      }
     }
   }
+  // Has Start() been called yet?
+  bool started_ = false;
 
   // 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<UsbPrinterDetector::Observer>>
       observer_list_;
   base::WeakPtrFactory<UsbPrinterDetectorImpl> weak_ptr_factory_;
 };
 
 }  // namespace
 
 // static
 std::unique_ptr<UsbPrinterDetector> UsbPrinterDetector::Create(
     Profile* profile) {
   return base::MakeUnique<UsbPrinterDetectorImpl>(profile);
 }
 
 }  // namespace chromeos