Remove unnecessary InterfaceClaimer::Claim method.

device/usb/usb_device_handle_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/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 104 matching lines @@
     callback_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, status, buffer, result));
   }
 }
 
 }  // namespace
 
 class UsbDeviceHandleImpl::InterfaceClaimer
     : public base::RefCountedThreadSafe<UsbDeviceHandleImpl::InterfaceClaimer> {
  public:
-  InterfaceClaimer(const scoped_refptr<UsbDeviceHandleImpl> handle,
-                   const int interface_number);
-
-  bool Claim() const;
+  InterfaceClaimer(scoped_refptr<UsbDeviceHandleImpl> handle,
+                   int interface_number);
 
   int alternate_setting() const { return alternate_setting_; }
   void set_alternate_setting(const int alternate_setting) {
     alternate_setting_ = alternate_setting;
   }
 
  private:
-  friend class UsbDevice;
   friend class base::RefCountedThreadSafe<InterfaceClaimer>;
   ~InterfaceClaimer();
 
   const scoped_refptr<UsbDeviceHandleImpl> handle_;
   const int interface_number_;
   int alternate_setting_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceClaimer);
 };
 
 UsbDeviceHandleImpl::InterfaceClaimer::InterfaceClaimer(
-    const scoped_refptr<UsbDeviceHandleImpl> handle,
-    const int interface_number)
+    scoped_refptr<UsbDeviceHandleImpl> handle,
+    int interface_number)
     : handle_(handle),
       interface_number_(interface_number),
-      alternate_setting_(0) {
-}
+      alternate_setting_(0) {}
 
 UsbDeviceHandleImpl::InterfaceClaimer::~InterfaceClaimer() {
   libusb_release_interface(handle_->handle(), interface_number_);
 }
 
-bool UsbDeviceHandleImpl::InterfaceClaimer::Claim() const {
-  const int rv = libusb_claim_interface(handle_->handle(), interface_number_);
-  if (rv != LIBUSB_SUCCESS) {
-    USB_LOG(EVENT) << "Failed to claim interface " << interface_number_ << ": "
-                   << ConvertPlatformUsbErrorToString(rv);
-  }
-  return rv == LIBUSB_SUCCESS;
-}
-
 // This inner class owns the underlying libusb_transfer and may outlast
 // the UsbDeviceHandle that created it.
 class UsbDeviceHandleImpl::Transfer {
  public:
   static scoped_ptr<Transfer> CreateControlTransfer(
       scoped_refptr<UsbDeviceHandleImpl> device_handle,
       uint8_t type,
       uint8_t request,
       uint16_t value,
       uint16_t index,
@@ skipping 546 matching lines @@
     RefreshEndpointMap();
   }
   callback.Run(success);
 }
 
 void UsbDeviceHandleImpl::ClaimInterfaceOnBlockingThread(
     int interface_number,
     const ResultCallback& callback) {
   int rv = libusb_claim_interface(handle_, interface_number);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to claim interface: "
-            << ConvertPlatformUsbErrorToString(rv);
+    USB_LOG(EVENT) << "Failed to claim interface: "
+                   << ConvertPlatformUsbErrorToString(rv);
   }
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ClaimInterfaceComplete, this,
                             interface_number, rv == LIBUSB_SUCCESS, callback));
 }
 
 void UsbDeviceHandleImpl::ClaimInterfaceComplete(
     int interface_number,
     bool success,
     const ResultCallback& callback) {
@@ skipping 264 matching lines @@
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace device