Manage UsbService lifetime in DeviceClient implementations.

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 "chrome/browser/extensions/extension_apitest.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
+#include "device/core/device_client.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "device/usb/mock_usb_service.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/usb/usb_api.h"
 #include "extensions/shell/browser/shell_extensions_api_client.h"
 #include "extensions/shell/test/shell_apitest.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "net/base/io_buffer.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 using content::BrowserThread;
+using device::DeviceClient;
 using device::MockUsbDevice;
 using device::MockUsbDeviceHandle;
 using device::MockUsbService;
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
 using device::UsbService;
 
@@ skipping 28 matching lines @@
     for (size_t i = 0; i < prompt()->GetDeviceCount(); ++i) {
       prompt()->GrantDevicePermission(i);
       if (!prompt()->multiple()) {
         break;
       }
     }
     prompt()->Dismissed();
   }
 };
 
+class TestDeviceClient : public DeviceClient {
+ public:
+  TestDeviceClient() : DeviceClient() {}
+  ~TestDeviceClient() override {}
+
+  MockUsbService& mock_usb_service() { return usb_service_; }
+
+ private:
+  UsbService* GetUsbService() override { return &usb_service_; }
+
+  MockUsbService usb_service_;
+};
+
 class TestExtensionsAPIClient : public ShellExtensionsAPIClient {
  public:
   TestExtensionsAPIClient() : ShellExtensionsAPIClient() {}
 
   scoped_ptr<DevicePermissionsPrompt> CreateDevicePermissionsPrompt(
       content::WebContents* web_contents) const override {
     return make_scoped_ptr(new TestDevicePermissionsPrompt(web_contents));
   }
 };
 
 class UsbApiTest : public ShellApiTest {
  public:
   void SetUpOnMainThread() override {
     ShellApiTest::SetUpOnMainThread();
 
     mock_device_ =
         new MockUsbDevice(0, 0, "Test Manufacturer", "Test Device", "ABC123");
     mock_device_handle_ = new MockUsbDeviceHandle(mock_device_.get());
     EXPECT_CALL(*mock_device_.get(), Open(_))
         .WillRepeatedly(InvokeCallback<0>(mock_device_handle_));
-    mock_service_.reset(new MockUsbService());
-    mock_service_->AddDevice(mock_device_);
+    device_client_.reset(new TestDeviceClient());
+    device_client_->mock_usb_service().AddDevice(mock_device_);
   }
 
  protected:
   scoped_refptr<MockUsbDeviceHandle> mock_device_handle_;
   scoped_refptr<MockUsbDevice> mock_device_;
-  scoped_ptr<MockUsbService> mock_service_;
+  scoped_ptr<TestDeviceClient> device_client_;
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, DeviceHandling) {
   EXPECT_CALL(*mock_device_handle_.get(), Close()).Times(2);
   ASSERT_TRUE(RunAppTest("api_test/usb/device_handling"));
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, ResetDevice) {
@@ skipping 81 matching lines @@
 
 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());
 
   scoped_refptr<MockUsbDevice> device(new MockUsbDevice(0x18D1, 0x58F0));
-  mock_service_->AddDevice(device);
+  device_client_->mock_usb_service().AddDevice(device);
 
   device = new MockUsbDevice(0x18D1, 0x58F1);
-  mock_service_->AddDevice(device);
+  device_client_->mock_usb_service().AddDevice(device);
 
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
 }
 
 IN_PROC_BROWSER_TEST_F(UsbApiTest, OnDeviceRemoved) {
   ExtensionTestMessageListener load_listener("loaded", false);
   ExtensionTestMessageListener result_listener("success", false);
   result_listener.set_failure_message("failure");
 
   ASSERT_TRUE(LoadApp("api_test/usb/remove_event"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());
 
-  mock_service_->RemoveDevice(mock_device_);
+  device_client_->mock_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);
 
   TestExtensionsAPIClient test_api_client;
   ASSERT_TRUE(LoadApp("api_test/usb/get_user_selected_devices"));
   ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
 
-  mock_service_->RemoveDevice(mock_device_);
+  device_client_->mock_usb_service().RemoveDevice(mock_device_);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
 }
 
 }  // namespace extensions