Move string descriptor getters from UsbDeviceHandle to UsbDevice.

device/test/usb_test_gadget_impl.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 "device/test/usb_test_gadget.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 53 matching lines @@
 
 class UsbTestGadgetImpl : public UsbTestGadget {
  public:
   virtual ~UsbTestGadgetImpl();
 
   virtual bool Unclaim() OVERRIDE;
   virtual bool Disconnect() OVERRIDE;
   virtual bool Reconnect() OVERRIDE;
   virtual bool SetType(Type type) OVERRIDE;
   virtual UsbDevice* GetDevice() const OVERRIDE;
-  virtual std::string GetSerial() const OVERRIDE;
+  virtual std::string GetSerialNumber() const OVERRIDE;
 
  protected:
   UsbTestGadgetImpl();
 
  private:
   scoped_ptr<net::URLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* delegate);
   int SimplePOSTRequest(const GURL& url, const std::string& form_data);
@@ skipping 74 matching lines @@
 UsbTestGadgetImpl::~UsbTestGadgetImpl() {
   if (!device_address_.empty()) {
     Unclaim();
   }
 }
 
 UsbDevice* UsbTestGadgetImpl::GetDevice() const {
   return device_.get();
 }
 
-std::string UsbTestGadgetImpl::GetSerial() const {
+std::string UsbTestGadgetImpl::GetSerialNumber() const {
   return device_address_;
 }
 
 scoped_ptr<net::URLFetcher> UsbTestGadgetImpl::CreateURLFetcher(
     const GURL& url, net::URLFetcher::RequestType request_type,
     net::URLFetcherDelegate* delegate) {
   scoped_ptr<net::URLFetcher> url_fetcher(
       net::URLFetcher::Create(url, request_type, delegate));
 
   url_fetcher->SetRequestContext(
@@ skipping 18 matching lines @@
 }
 
 bool UsbTestGadgetImpl::FindUnclaimed() {
   std::vector<scoped_refptr<UsbDevice> > devices;
   usb_service_->GetDevices(&devices);
 
   for (std::vector<scoped_refptr<UsbDevice> >::const_iterator iter =
          devices.begin(); iter != devices.end(); ++iter) {
     const scoped_refptr<UsbDevice> &device = *iter;
     if (device->vendor_id() == 0x18D1 && device->product_id() == 0x58F0) {
-      scoped_refptr<UsbDeviceHandle> handle = device->Open();
-      if (handle.get() == NULL) {
+      base::string16 serial_utf16;
+      if (!device->GetSerialNumber(&serial_utf16)) {
         continue;
       }
 
-      base::string16 serial_utf16;
-      if (!handle->GetSerial(&serial_utf16)) {
-        continue;
-      }
-
       const std::string serial = base::UTF16ToUTF8(serial_utf16);
       const GURL url("http://" + serial + "/claim");
       const std::string form_data = base::StringPrintf(
           "session_id=%s",
           net::EscapeUrlEncodedData(session_id_, true).c_str());
       const int response_code = SimplePOSTRequest(url, form_data);
 
       if (response_code == 200) {
         device_address_ = serial;
         device_ = device;
@@ skipping 105 matching lines @@
   }
   VLOG(1) << "It took " << (kReconnectRetries - retries)
           << " retries to find the updated device.";
 
   return true;
 }
 
 bool UsbTestGadgetImpl::FindClaimed() {
   CHECK(!device_.get());
 
-  std::string expected_serial = GetSerial();
+  std::string expected_serial = GetSerialNumber();
 
   std::vector<scoped_refptr<UsbDevice> > devices;
   usb_service_->GetDevices(&devices);
 
   for (std::vector<scoped_refptr<UsbDevice> >::iterator iter =
          devices.begin(); iter != devices.end(); ++iter) {
     scoped_refptr<UsbDevice> &device = *iter;
 
     if (device->vendor_id() == 0x18D1) {
       const uint16 product_id = device->product_id();
       bool found = false;
       for (size_t i = 0; i < arraysize(kConfigurations); ++i) {
         if (product_id == kConfigurations[i].product_id) {
           found = true;
           break;
         }
       }
       if (!found) {
         continue;
       }
 
-      scoped_refptr<UsbDeviceHandle> handle(device->Open());
-      if (handle.get() == NULL) {
-        continue;
-      }
-
       base::string16 serial_utf16;
-      if (!handle->GetSerial(&serial_utf16)) {
+      if (!device->GetSerialNumber(&serial_utf16)) {
         continue;
       }
 
       std::string serial = base::UTF16ToUTF8(serial_utf16);
       if (serial != expected_serial) {
         continue;
       }
 
       device_ = device;
       return true;
@@ skipping 142 matching lines @@
     }
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(kRetryPeriod));
   }
   VLOG(1) << "It took " << (kDisconnectRetries - retries)
           << " retries for the device to reconnect.";
 
   return true;
 }
 
 }  // namespace device