[Extensions] Code Cleanup - Remove redundant smart-ptr get()s

extensions/browser/api/usb/usb_apitest.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 <stddef.h>
 
 #include <numeric>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/extension_apitest.h"
@@ skipping 126 matching lines @@
     // MockDeviceClient replaces ShellDeviceClient.
     device_client_.reset(new MockDeviceClient());
 
     std::vector<UsbConfigDescriptor> configs;
     configs.emplace_back(1, false, false, 0);
     configs.emplace_back(2, false, false, 0);
 
     mock_device_ = new MockUsbDevice(0, 0, "Test Manufacturer", "Test Device",
                                      "ABC123", configs);
     mock_device_handle_ = new MockUsbDeviceHandle(mock_device_.get());
-    EXPECT_CALL(*mock_device_.get(), Open(_))
+    EXPECT_CALL(*mock_device_, Open(_))
         .WillRepeatedly(InvokeCallback<0>(mock_device_handle_));
     device_client_->usb_service()->AddDevice(mock_device_);
   }
 
  protected:
   scoped_refptr<MockUsbDeviceHandle> mock_device_handle_;
   scoped_refptr<MockUsbDevice> mock_device_;
   std::unique_ptr<MockDeviceClient> device_client_;
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, DeviceHandling) {
   mock_device_->ActiveConfigurationChanged(1);
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(2);
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(2);
   ASSERT_TRUE(RunAppTest("api_test/usb/device_handling"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ResetDevice) {
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(2);
-  EXPECT_CALL(*mock_device_handle_.get(), ResetDevice(_))
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(2);
+  EXPECT_CALL(*mock_device_handle_, ResetDevice(_))
       .WillOnce(InvokeCallback<0>(true))
       .WillOnce(InvokeCallback<0>(false));
-  EXPECT_CALL(*mock_device_handle_.get(),
+  EXPECT_CALL(*mock_device_handle_,
               GenericTransfer(device::USB_DIRECTION_OUTBOUND, 2, _, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_COMPLETED));
   ASSERT_TRUE(RunAppTest("api_test/usb/reset_device"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, SetConfiguration) {
-  EXPECT_CALL(*mock_device_handle_.get(), SetConfiguration(1, _))
+  EXPECT_CALL(*mock_device_handle_, SetConfiguration(1, _))
       .WillOnce(SetConfiguration(mock_device_.get()));
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(1);
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(1);
   ASSERT_TRUE(RunAppTest("api_test/usb/set_configuration"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ListInterfaces) {
   mock_device_->ActiveConfigurationChanged(1);
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(1);
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(1);
   ASSERT_TRUE(RunAppTest("api_test/usb/list_interfaces"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, TransferEvent) {
-  EXPECT_CALL(*mock_device_handle_.get(),
-              ControlTransfer(device::USB_DIRECTION_OUTBOUND,
-                              UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE,
-                              1,
-                              2,
-                              3,
-                              _,
-                              1,
-                              _,
-                              _))
+  EXPECT_CALL(
+      *mock_device_handle_,
+      ControlTransfer(device::USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
+                      UsbDeviceHandle::DEVICE, 1, 2, 3, _, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<9>(device::USB_TRANSFER_COMPLETED));
-  EXPECT_CALL(*mock_device_handle_.get(),
+  EXPECT_CALL(*mock_device_handle_,
               GenericTransfer(device::USB_DIRECTION_OUTBOUND, 1, _, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_COMPLETED));
-  EXPECT_CALL(*mock_device_handle_.get(),
+  EXPECT_CALL(*mock_device_handle_,
               GenericTransfer(device::USB_DIRECTION_OUTBOUND, 2, _, 1, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_COMPLETED));
-  EXPECT_CALL(*mock_device_handle_.get(), IsochronousTransferOut(3, _, _, _, _))
+  EXPECT_CALL(*mock_device_handle_, IsochronousTransferOut(3, _, _, _, _))
       .WillOnce(InvokeUsbIsochronousTransferOutCallback(1, 1u));
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/transfer_event"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ZeroLengthTransfer) {
-  EXPECT_CALL(*mock_device_handle_.get(), GenericTransfer(_, _, _, 0, _, _))
+  EXPECT_CALL(*mock_device_handle_, GenericTransfer(_, _, _, 0, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_COMPLETED));
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/zero_length_transfer"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, TransferFailure) {
-  EXPECT_CALL(*mock_device_handle_.get(),
+  EXPECT_CALL(*mock_device_handle_,
               GenericTransfer(device::USB_DIRECTION_OUTBOUND, 1, _, _, _, _))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_COMPLETED))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_ERROR))
       .WillOnce(InvokeUsbTransferCallback<5>(device::USB_TRANSFER_TIMEOUT));
-  EXPECT_CALL(*mock_device_handle_.get(), IsochronousTransferIn(2, _, _, _))
+  EXPECT_CALL(*mock_device_handle_, IsochronousTransferIn(2, _, _, _))
       .WillOnce(InvokeUsbIsochronousTransferInCallback(8, 10u))
       .WillOnce(InvokeUsbIsochronousTransferInCallback(8, 5u));
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/transfer_failure"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, InvalidLengthTransfer) {
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/invalid_length_transfer"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, InvalidTimeout) {
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(AnyNumber());
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(AnyNumber());
   ASSERT_TRUE(RunAppTest("api_test/usb/invalid_timeout"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, OnDeviceAdded) {
   ExtensionTestMessageListener load_listener("loaded", false);
   ExtensionTestMessageListener result_listener("success", false);
   result_listener.set_failure_message("failure");
 
   ASSERT_TRUE(LoadApp("api_test/usb/add_event"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());
@@ skipping 17 matching lines @@
 
   device_client_->usb_service()->RemoveDevice(mock_device_);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, GetUserSelectedDevices) {
   ExtensionTestMessageListener ready_listener("opened_device", false);
   ExtensionTestMessageListener result_listener("success", false);
   result_listener.set_failure_message("failure");
 
-  EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(1);
+  EXPECT_CALL(*mock_device_handle_, Close()).Times(1);
 
   TestExtensionsAPIClient test_api_client;
   ASSERT_TRUE(LoadApp("api_test/usb/get_user_selected_devices"));
   ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
 
   device_client_->usb_service()->RemoveDevice(mock_device_);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
 }
 
 }  // namespace extensions