Add onGetUsbPrinterInfoRequested event to printerProvider API.

extensions/browser/api/printer_provider/printer_provider_api.cc

 // Copyright 2015 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 "extensions/browser/api/printer_provider/printer_provider_api.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "device/core/device_client.h"
+#include "device/usb/usb_device.h"
+#include "device/usb/usb_service.h"
+#include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
 #include "extensions/browser/api/printer_provider_internal/printer_provider_internal_api.h"
 #include "extensions/browser/api/printer_provider_internal/printer_provider_internal_api_observer.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/api/printer_provider.h"
+#include "extensions/common/api/printer_provider/usb_printer_manifest_data.h"
 #include "extensions/common/api/printer_provider_internal.h"
+#include "extensions/common/api/usb.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/permissions/permissions_data.h"
+#include "extensions/common/value_builder.h"
+
+using device::UsbDevice;
+using device::UsbDeviceFilter;
+using device::UsbService;
 
 namespace extensions {
 
 namespace {
 
 // The separator between extension id and the extension's internal printer id
 // used when generating a printer id unique across extensions.
 const char kPrinterIdSeparator = ':';
 
 // Given an extension ID and an ID of a printer reported by the extension, it
@@ skipping 21 matching lines @@
   return true;
 }
 
 // Holds information about a pending onGetPrintersRequested request;
 // in particular, the list of extensions to which the event was dispatched but
 // which haven't yet responded, and the |GetPrinters| callback associated with
 // the event.
 class GetPrintersRequest {
  public:
   explicit GetPrintersRequest(
+      bool wait_for_usb_printers,
       const PrinterProviderAPI::GetPrintersCallback& callback);
   ~GetPrintersRequest();
 
   // Adds an extension id to the list of the extensions that need to respond
   // to the event.
-  void AddSource(const std::string& extension_id);
+  void AddSource(const std::string& extension);
 
   // Whether all extensions have responded to the event.
   bool IsDone() const;
 
   // Runs the callback for an extension and removes the extension from the
   // list of extensions that still have to respond to the event.
   void ReportForExtension(const std::string& extension_id,
                           const base::ListValue& printers);
 
+  // Runs the callback for USB printers and clears the request for a list of
+  // USB printers.
+  void ReportUsbPrinters(const base::ListValue& printers);
+
  private:
   // Callback reporting event result for an extension. Called once for each
   // extension.
   PrinterProviderAPI::GetPrintersCallback callback_;
 
   // The list of extensions that still have to respond to the event.
   std::set<std::string> extensions_;
+
+  // Set when an extension supporting USB printers is detected and the
+  // GetPrintersRequest is not done until those devices are reported.
+  bool wait_for_usb_printers_;
 };
 
 // Keeps track of pending chrome.printerProvider.onGetPrintersRequested
 // requests.
 class PendingGetPrintersRequests {
  public:
   PendingGetPrintersRequests();
   ~PendingGetPrintersRequests();
 
   // Adds a new request to the set of pending requests. Returns the id
   // assigned to the request.
-  int Add(const PrinterProviderAPI::GetPrintersCallback& callback);
+  int Add(bool wait_for_usb_printers,
+          const PrinterProviderAPI::GetPrintersCallback& callback);
 
   // Completes a request for an extension. It runs the request callback with
   // values reported by the extension.
   bool CompleteForExtension(const std::string& extension_id,
                             int request_id,
                             const base::ListValue& result);
 
   // Runs callbacks for the extension for all requests that are waiting for a
   // response from the extension with the provided extension id. Callbacks are
   // called as if the extension reported empty set of printers.
   void FailAllForExtension(const std::string& extension_id);
 
-  // Adds an extension id to the list of the extensions that need to respond
-  // to the event.
+  // Completes a request for all USB printers associated with registered
+  // extensions.
+  void CompleteUsbPrinters(int request_id, const base::ListValue& result);
+
+  // Adds an extension to the list of the extensions that need to respond to the
+  // event.
   bool AddSource(int request_id, const std::string& extension_id);
 
  private:
   int last_request_id_;
   std::map<int, GetPrintersRequest> pending_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingGetPrintersRequests);
 };
 
 // Keeps track of pending chrome.printerProvider.onGetCapabilityRequested
@@ skipping 13 matching lines @@
 
   // Runs all pending callbacks with empty capability value and clears the
   // set of pending requests.
   void FailAll();
 
  private:
   int last_request_id_;
   std::map<int, PrinterProviderAPI::GetCapabilityCallback> pending_requests_;
 };
 
-// Keeps track of pending chrome.printerProvider.ontPrintRequested requests
+// Keeps track of pending chrome.printerProvider.onPrintRequested requests
 // for an extension.
 class PendingPrintRequests {
  public:
   PendingPrintRequests();
   ~PendingPrintRequests();
 
   // Adds a new request to the set. Only information needed is the callback
   // associated with the request. Returns the id assigned to the request.
   int Add(const PrinterProviderPrintJob& job,
           const PrinterProviderAPI::PrintCallback& callback);
@@ skipping 12 matching lines @@
  private:
   struct PrintRequest {
     PrinterProviderAPI::PrintCallback callback;
     PrinterProviderPrintJob job;
   };
 
   int last_request_id_;
   std::map<int, PrintRequest> pending_requests_;
 };
 
+// Keeps track of pending chrome.printerProvider.onUsbAccessGranted requests
+// for an extension.
+class PendingUsbPrinterInfoRequests {
+ public:
+  PendingUsbPrinterInfoRequests();
+  ~PendingUsbPrinterInfoRequests();
+
+  // Adds a new request to the set. Only information needed is the callback
+  // associated with the request. Returns the id assigned to the request.
+  int Add(const PrinterProviderAPI::UsbAccessGrantedCallback& callback);
+
+  // Completes the request with the provided request id. It runs the request
+  // callback and removes the request from the set.
+  void Complete(int request_id,
+                const core_api::printer_provider::PrinterInfo* printer_info);
+
+  // Runs all pending callbacks with empty capability value and clears the
+  // set of pending requests.
+  void FailAll();
+
+ private:
+  int last_request_id_ = 0;
+  std::map<int, PrinterProviderAPI::UsbAccessGrantedCallback> pending_requests_;
+};
+
 // Implements chrome.printerProvider API events.
 class PrinterProviderAPIImpl : public PrinterProviderAPI,
                                public PrinterProviderInternalAPIObserver,
                                public ExtensionRegistryObserver {
  public:
   explicit PrinterProviderAPIImpl(content::BrowserContext* browser_context);
   ~PrinterProviderAPIImpl() override;
 
  private:
   // PrinterProviderAPI implementation:
   void DispatchGetPrintersRequested(
       const PrinterProviderAPI::GetPrintersCallback& callback) override;
   void DispatchGetCapabilityRequested(
       const std::string& printer_id,
       const PrinterProviderAPI::GetCapabilityCallback& callback) override;
   void DispatchPrintRequested(
       const PrinterProviderPrintJob& job,
       const PrinterProviderAPI::PrintCallback& callback) override;
   const PrinterProviderPrintJob* GetPrintJob(const Extension* extension,
                                              int request_id) const override;
+  void DispatchGrantUsbPrinterAccess(
+      const std::string& extension_id,
+      int device_id,
+      const PrinterProviderAPI::UsbAccessGrantedCallback& callback) override;
 
   // PrinterProviderInternalAPIObserver implementation:
   void OnGetPrintersResult(
       const Extension* extension,
       int request_id,
       const PrinterProviderInternalAPIObserver::PrinterInfoVector& result)
       override;
   void OnGetCapabilityResult(const Extension* extension,
                              int request_id,
                              const base::DictionaryValue& result) override;
   void OnPrintResult(
       const Extension* extension,
       int request_id,
       core_api::printer_provider_internal::PrintError error) override;
+  void OnUsbAccessGrantedResult(
+      const Extension* extension,
+      int request_id,
+      const core_api::printer_provider::PrinterInfo* printer_info) override;
 
   // ExtensionRegistryObserver implementation:
   void OnExtensionUnloaded(content::BrowserContext* browser_context,
                            const Extension* extension,
                            UnloadedExtensionInfo::Reason reason) override;
 
   // Called before chrome.printerProvider.onGetPrintersRequested event is
   // dispatched to an extension. It returns whether the extension is interested
   // in the event. If the extension listens to the event, it's added to the set
   // of |request| sources. |request| is |GetPrintersRequest| object associated
   // with the event.
   bool WillRequestPrinters(int request_id,
                            content::BrowserContext* browser_context,
                            const Extension* extension,
                            base::ListValue* args);
 
+  void OnUsbDevicesEnumerated(
+      int request_id,
+      const std::vector<scoped_refptr<UsbDevice>>& devices);
+
   content::BrowserContext* browser_context_;
 
   PendingGetPrintersRequests pending_get_printers_requests_;
 
   std::map<std::string, PendingPrintRequests> pending_print_requests_;
 
   std::map<std::string, PendingGetCapabilityRequests>
       pending_capability_requests_;
 
+  std::map<std::string, PendingUsbPrinterInfoRequests>
+      pending_usb_printer_info_requests_;
+
   ScopedObserver<PrinterProviderInternalAPI, PrinterProviderInternalAPIObserver>
       internal_api_observer_;
 
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
+  base::WeakPtrFactory<PrinterProviderAPIImpl> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(PrinterProviderAPIImpl);
 };
 
 GetPrintersRequest::GetPrintersRequest(
+    bool wait_for_usb_printers,
     const PrinterProviderAPI::GetPrintersCallback& callback)
-    : callback_(callback) {
+    : callback_(callback), wait_for_usb_printers_(wait_for_usb_printers) {
 }
 
 GetPrintersRequest::~GetPrintersRequest() {
 }
 
 void GetPrintersRequest::AddSource(const std::string& extension_id) {
   extensions_.insert(extension_id);
 }
 
 bool GetPrintersRequest::IsDone() const {
-  return extensions_.empty();
+  return extensions_.empty() && !wait_for_usb_printers_;
 }
 
 void GetPrintersRequest::ReportForExtension(const std::string& extension_id,
                                             const base::ListValue& printers) {
   if (extensions_.erase(extension_id) > 0)
     callback_.Run(printers, IsDone());
 }
 
+void GetPrintersRequest::ReportUsbPrinters(const base::ListValue& printers) {
+  DCHECK(wait_for_usb_printers_);
+  wait_for_usb_printers_ = false;
+  callback_.Run(printers, IsDone());
+}
+
 PendingGetPrintersRequests::PendingGetPrintersRequests() : last_request_id_(0) {
 }
 
 PendingGetPrintersRequests::~PendingGetPrintersRequests() {
 }
 
 int PendingGetPrintersRequests::Add(
+    bool wait_for_usb_printers,
     const PrinterProviderAPI::GetPrintersCallback& callback) {
-  pending_requests_.insert(
-      std::make_pair(++last_request_id_, GetPrintersRequest(callback)));
+  pending_requests_.insert(std::make_pair(
+      ++last_request_id_, GetPrintersRequest(wait_for_usb_printers, callback)));
   return last_request_id_;
 }
 
 bool PendingGetPrintersRequests::CompleteForExtension(
     const std::string& extension_id,
     int request_id,
     const base::ListValue& result) {
   auto it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())
     return false;
@@ skipping 10 matching lines @@
   auto it = pending_requests_.begin();
   while (it != pending_requests_.end()) {
     int request_id = it->first;
     // |it| may get deleted during |CompleteForExtension|, so progress it to the
     // next item before calling the method.
     ++it;
     CompleteForExtension(extension_id, request_id, base::ListValue());
   }
 }
 
+void PendingGetPrintersRequests::CompleteUsbPrinters(
+    int request_id,
+    const base::ListValue& result) {
+  auto it = pending_requests_.find(request_id);
+  if (it == pending_requests_.end()) {
+    return;
+  }
+
+  it->second.ReportUsbPrinters(result);
+  if (it->second.IsDone()) {
+    pending_requests_.erase(it);
+  }
+}
+
 bool PendingGetPrintersRequests::AddSource(int request_id,
                                            const std::string& extension_id) {
   auto it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())
     return false;
 
   it->second.AddSource(extension_id);
   return true;
 }
 
@@ skipping 69 matching lines @@
   return &it->second.job;
 }
 
 void PendingPrintRequests::FailAll() {
   for (auto& request : pending_requests_)
     request.second.callback.Run(false,
                                 PrinterProviderAPI::GetDefaultPrintError());
   pending_requests_.clear();
 }
 
+PendingUsbPrinterInfoRequests::PendingUsbPrinterInfoRequests() {
+}
+
+PendingUsbPrinterInfoRequests::~PendingUsbPrinterInfoRequests() {
+}
+
+int PendingUsbPrinterInfoRequests::Add(
+    const PrinterProviderAPI::UsbAccessGrantedCallback& callback) {
+  pending_requests_[++last_request_id_] = callback;
+  return last_request_id_;
+}
+
+void PendingUsbPrinterInfoRequests::Complete(
+    int request_id,
+    const core_api::printer_provider::PrinterInfo* printer_info) {
+  auto it = pending_requests_.find(request_id);
+  if (it == pending_requests_.end()) {
+    return;
+  }
+
+  PrinterProviderAPI::UsbAccessGrantedCallback callback = it->second;
+  pending_requests_.erase(it);
+
+  if (printer_info) {
+    callback.Run(*printer_info->ToValue().get());
+  } else {
+    callback.Run(base::DictionaryValue());
+  }
+}
+
+void PendingUsbPrinterInfoRequests::FailAll() {
+  for (auto& request : pending_requests_) {
+    request.second.Run(base::DictionaryValue());
+  }
+  pending_requests_.clear();
+}
+
 PrinterProviderAPIImpl::PrinterProviderAPIImpl(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context),
       internal_api_observer_(this),
-      extension_registry_observer_(this) {
+      extension_registry_observer_(this),
+      weak_factory_(this) {
   internal_api_observer_.Add(
       PrinterProviderInternalAPI::GetFactoryInstance()->Get(browser_context));
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context));
 }
 
 PrinterProviderAPIImpl::~PrinterProviderAPIImpl() {
 }
 
 void PrinterProviderAPIImpl::DispatchGetPrintersRequested(
     const GetPrintersCallback& callback) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->HasEventListener(
           core_api::printer_provider::OnGetPrintersRequested::kEventName)) {
     callback.Run(base::ListValue(), true /* done */);
     return;
   }
 
-  // |pending_get_printers_requests_| take ownership of |request| which gets
-  // NULLed out. Save the pointer before passing it to the requests, as it will
-  // be needed later on.
-  int request_id = pending_get_printers_requests_.Add(callback);
+  bool extensions_support_usb_devices = false;
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
+  for (const auto& extension : registry->enabled_extensions()) {
+    if (UsbPrinterManifestData::Get(extension.get()) &&
+        extension->permissions_data() &&
+        extension->permissions_data()->HasAPIPermission(
+            extensions::APIPermission::kPrinterProvider) &&
+        extension->permissions_data()->HasAPIPermission(
+            extensions::APIPermission::kUsb)) {
+      extensions_support_usb_devices = true;
+    }
+  }
+
+  int request_id = pending_get_printers_requests_.Add(
+      extensions_support_usb_devices, callback);
 
   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
   // Request id is not part of the public API, but it will be massaged out in
   // custom bindings.
   internal_args->AppendInteger(request_id);
 
   scoped_ptr<Event> event(
       new Event(core_api::printer_provider::OnGetPrintersRequested::kEventName,
                 internal_args.Pass()));
   // This callback is called synchronously during |BroadcastEvent|, so
   // Unretained is safe.
   event->will_dispatch_callback =
       base::Bind(&PrinterProviderAPIImpl::WillRequestPrinters,
                  base::Unretained(this), request_id);
 
   event_router->BroadcastEvent(event.Pass());
+
+  // Start the USB device enumeration after the event has been broadcast to
+  // extensions as OnUsbDevicesEnumerated may be called synchronously and that
+  // would complete the request before extensions can be Added to it.
+  if (extensions_support_usb_devices) {
+    UsbService* service = device::DeviceClient::Get()->GetUsbService();
+    DCHECK(service);
+    service->GetDevices(
+        base::Bind(&PrinterProviderAPIImpl::OnUsbDevicesEnumerated,
+                   weak_factory_.GetWeakPtr(), request_id));
+  }
 }
 
 void PrinterProviderAPIImpl::DispatchGetCapabilityRequested(
     const std::string& printer_id,
     const PrinterProviderAPI::GetCapabilityCallback& callback) {
   std::string extension_id;
   std::string internal_printer_id;
   if (!ParsePrinterId(printer_id, &extension_id, &internal_printer_id)) {
     callback.Run(base::DictionaryValue());
     return;
@@ skipping 71 matching lines @@
 
 const PrinterProviderPrintJob* PrinterProviderAPIImpl::GetPrintJob(
     const Extension* extension,
     int request_id) const {
   auto it = pending_print_requests_.find(extension->id());
   if (it == pending_print_requests_.end())
     return nullptr;
   return it->second.GetPrintJob(request_id);
 }
 
+void PrinterProviderAPIImpl::DispatchGrantUsbPrinterAccess(
+    const std::string& extension_id,
+    int device_id,
+    const PrinterProviderAPI::UsbAccessGrantedCallback& callback) {
+  UsbService* service = device::DeviceClient::Get()->GetUsbService();
+  DCHECK(service);
+  scoped_refptr<UsbDevice> device = service->GetDeviceById(device_id);
+  if (!device) {
+    callback.Run(base::DictionaryValue());
+    return;
+  }
+
+  DevicePermissionsManager* permissions_manager =
+      DevicePermissionsManager::Get(browser_context_);
+  DCHECK(permissions_manager);
+  permissions_manager->AllowUsbDevice(extension_id, device);
+
+  EventRouter* event_router = EventRouter::Get(browser_context_);
+  if (!event_router->ExtensionHasEventListener(
+          extension_id,
+          core_api::printer_provider::OnUsbAccessGranted::kEventName)) {
+    callback.Run(base::DictionaryValue());
+    return;
+  }
+
+  int request_id =
+      pending_usb_printer_info_requests_[extension_id].Add(callback);
+  core_api::usb::Device usb_device;
+  usb_device.device = device->unique_id();
+  usb_device.vendor_id = device->vendor_id();
+  usb_device.product_id = device->product_id();
+
+  scoped_ptr<base::ListValue> internal_args(new base::ListValue);
+  // Request id is not part of the public API and it will be massaged out in
+  // custom bindings.
+  internal_args->AppendInteger(request_id);
+  internal_args->Append(usb_device.ToValue().release());
+  scoped_ptr<Event> event(
+      new Event(core_api::printer_provider::OnUsbAccessGranted::kEventName,
+                internal_args.Pass()));
+  event_router->DispatchEventToExtension(extension_id, event.Pass());
+}
+
 void PrinterProviderAPIImpl::OnGetPrintersResult(
     const Extension* extension,
     int request_id,
     const PrinterProviderInternalAPIObserver::PrinterInfoVector& result) {
   base::ListValue printer_list;
 
   // Update some printer description properties to better identify the extension
   // managing the printer.
   for (size_t i = 0; i < result.size(); ++i) {
     scoped_ptr<base::DictionaryValue> printer(result[i]->ToValue());
@@ skipping 36 matching lines @@
     core_api::printer_provider_internal::PrintError error) {
   const std::string error_str =
       error == core_api::printer_provider_internal::PRINT_ERROR_NONE
           ? PrinterProviderAPI::GetDefaultPrintError()
           : core_api::printer_provider_internal::ToString(error);
   pending_print_requests_[extension->id()].Complete(
       request_id, error == core_api::printer_provider_internal::PRINT_ERROR_OK,
       error_str);
 }
 
+void PrinterProviderAPIImpl::OnUsbAccessGrantedResult(
+    const Extension* extension,
+    int request_id,
+    const core_api::printer_provider::PrinterInfo* printer_info) {
+  pending_usb_printer_info_requests_[extension->id()].Complete(request_id,
+                                                               printer_info);
+}
+
 void PrinterProviderAPIImpl::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   pending_get_printers_requests_.FailAllForExtension(extension->id());
 
   auto print_it = pending_print_requests_.find(extension->id());
   if (print_it != pending_print_requests_.end()) {
     print_it->second.FailAll();
     pending_print_requests_.erase(print_it);
   }
 
   auto capability_it = pending_capability_requests_.find(extension->id());
   if (capability_it != pending_capability_requests_.end()) {
     capability_it->second.FailAll();
     pending_capability_requests_.erase(capability_it);
   }
+
+  auto usb_it = pending_usb_printer_info_requests_.find(extension->id());
+  if (usb_it != pending_usb_printer_info_requests_.end()) {
+    usb_it->second.FailAll();
+    pending_usb_printer_info_requests_.erase(usb_it);
+  }
 }
 
 bool PrinterProviderAPIImpl::WillRequestPrinters(
     int request_id,
     content::BrowserContext* browser_context,
     const Extension* extension,
     base::ListValue* args) {
   if (!extension)
     return false;
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->ExtensionHasEventListener(
           extension->id(),
           core_api::printer_provider::OnGetPrintersRequested::kEventName)) {
     return false;
   }
 
   return pending_get_printers_requests_.AddSource(request_id, extension->id());
 }
 
+void PrinterProviderAPIImpl::OnUsbDevicesEnumerated(
+    int request_id,
+    const std::vector<scoped_refptr<UsbDevice>>& devices) {
+  std::map<scoped_refptr<UsbDevice>,
+           std::vector<scoped_refptr<const Extension>>> result_map;
+
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
+  for (const auto& extension : registry->enabled_extensions()) {
+    const UsbPrinterManifestData* manifest_data =
+        UsbPrinterManifestData::Get(extension.get());
+
+    if (!manifest_data || !extension->permissions_data() ||
+        !extension->permissions_data()->HasAPIPermission(
+            extensions::APIPermission::kPrinterProvider) ||
+        !extension->permissions_data()->HasAPIPermission(
+            extensions::APIPermission::kUsb)) {
+      continue;
+    }
+
+    for (const auto& device : devices) {
+      if (manifest_data->SupportsDevice(device)) {
+        result_map[device].push_back(extension);
+      }
+    }
+  }
+
+  ListBuilder printer_list;
+  for (const auto& map_entry : result_map) {
+    ListBuilder extension_list;
+    for (const scoped_refptr<const Extension>& extension : map_entry.second) {
+      extension_list.Append(DictionaryBuilder()
+                                .Set("extensionId", extension->id())
+                                .Set("extensionName", extension->name()));
+    }
+
+    const scoped_refptr<UsbDevice>& device = map_entry.first;
+    printer_list.Append(
+        DictionaryBuilder()
+            .Set("name", DevicePermissionsManager::GetPermissionMessage(
+                             device->vendor_id(), device->product_id(),
+                             device->manufacturer_string(),
+                             device->product_string(), base::string16(), false))
+            .Set("usbDevice", static_cast<int>(device->unique_id()))
+            .Set("extensions", extension_list.Pass()));
+  }
+
+  pending_get_printers_requests_.CompleteUsbPrinters(
+      request_id, *printer_list.Build().get());
+}
+
 }  // namespace
 
 // static
 PrinterProviderAPI* PrinterProviderAPI::Create(
     content::BrowserContext* context) {
   return new PrinterProviderAPIImpl(context);
 }
 
 // static
 std::string PrinterProviderAPI::GetDefaultPrintError() {
   return core_api::printer_provider_internal::ToString(
       core_api::printer_provider_internal::PRINT_ERROR_FAILED);
 }
 
 }  // namespace extensions