Remove BrowserThread dependency from usb_service.

extensions/browser/api/usb_private/usb_private_api.cc

 // Copyright 2014 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/usb_private/usb_private_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/usb_service/usb_device_filter.h"
 #include "components/usb_service/usb_device_handle.h"
 #include "components/usb_service/usb_service.h"
+#include "device/common/device_client.h"
 #include "device/usb/usb_ids.h"
 #include "extensions/common/api/usb_private.h"
 
 namespace usb_private = extensions::core_api::usb_private;
 namespace GetDevices = usb_private::GetDevices;
 namespace GetDeviceInfo = usb_private::GetDeviceInfo;
 
+using content::BrowserThread;
 using usb_service::UsbDevice;
 using usb_service::UsbDeviceFilter;
 using usb_service::UsbDeviceHandle;
 using usb_service::UsbService;
 
 namespace {
 
 const char kErrorInitService[] = "Failed to initialize USB service.";
 const char kErrorNoDevice[] = "No such device.";
 const char kErrorOpen[] = "Failed to open device.";
 
 }  // namespace
 
 namespace extensions {
 
 UsbPrivateGetDevicesFunction::UsbPrivateGetDevicesFunction() {
 }
 
 UsbPrivateGetDevicesFunction::~UsbPrivateGetDevicesFunction() {
 }
 
 bool UsbPrivateGetDevicesFunction::Prepare() {
   parameters_ = GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbPrivateGetDevicesFunction::AsyncWorkStart() {
-  UsbService* service = UsbService::GetInstance();
+  UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return;
   }
 
   std::vector<UsbDeviceFilter> filters;
   filters.resize(parameters_->filters.size());
   for (size_t i = 0; i < parameters_->filters.size(); ++i) {
     UsbDeviceFilter& filter = filters[i];
     const usb_private::DeviceFilter* filter_param =
@@ skipping 49 matching lines @@
 UsbPrivateGetDeviceInfoFunction::~UsbPrivateGetDeviceInfoFunction() {
 }
 
 bool UsbPrivateGetDeviceInfoFunction::Prepare() {
   parameters_ = GetDeviceInfo::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbPrivateGetDeviceInfoFunction::AsyncWorkStart() {
-  UsbService* service = UsbService::GetInstance();
+  UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return;
   }
 
   scoped_refptr<UsbDevice> device =
       service->GetDeviceById(parameters_->device_id);
   if (!device.get()) {
     CompleteWithError(kErrorNoDevice);
     return;
@@ skipping 32 matching lines @@
 
   if (device_handle->GetSerial(&utf16)) {
     device_info.serial_string.reset(new std::string(base::UTF16ToUTF8(utf16)));
   }
 
   SetResult(device_info.ToValue().release());
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions