Manage HidService lifetime in DeviceClient implementations.

extensions/browser/api/hid/hid_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 "base/bind.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
+#include "device/core/device_client.h"
 #include "device/hid/hid_collection_info.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "device/hid/hid_usage_and_page.h"
 #include "extensions/browser/api/device_permissions_prompt.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"
@@ skipping 143 matching lines @@
     HidService::AddDevice(new HidDeviceInfo(device_id, vendor_id, product_id,
                                             "Test Device", "A", kHIDBusTypeUSB,
                                             report_descriptor));
   }
 
   void RemoveDevice(const HidDeviceId& device_id) {
     HidService::RemoveDevice(device_id);
   }
 };
 
+class TestDeviceClient : public DeviceClient {
+ public:
+  TestDeviceClient() : DeviceClient() {}
+  ~TestDeviceClient() override {}
+
+  MockHidService& mock_service() { return hid_service_; }
+
+ private:
+  HidService* GetHidService() override { return &hid_service_; }
+
+  MockHidService hid_service_;
+};
+
 }  // namespace device
 
 namespace extensions {
 
 class TestDevicePermissionsPrompt
     : public DevicePermissionsPrompt,
       public DevicePermissionsPrompt::Prompt::Observer {
  public:
   TestDevicePermissionsPrompt(content::WebContents* web_contents)
       : DevicePermissionsPrompt(web_contents) {}
@@ skipping 20 matching lines @@
   scoped_ptr<DevicePermissionsPrompt> CreateDevicePermissionsPrompt(
       content::WebContents* web_contents) const override {
     return make_scoped_ptr(new TestDevicePermissionsPrompt(web_contents));
   }
 };
 
 class HidApiTest : public ShellApiTest {
  public:
   void SetUpOnMainThread() override {
     ShellApiTest::SetUpOnMainThread();
-    hid_service_ = new device::MockHidService();
-    HidService::SetInstanceForTest(hid_service_);
+    device_client_.reset(new device::TestDeviceClient());
   }
 
  protected:
-  device::MockHidService* hid_service_;
+  scoped_ptr<device::TestDeviceClient> device_client_;
 };
 
 IN_PROC_BROWSER_TEST_F(HidApiTest, HidApp) {
   ASSERT_TRUE(RunAppTest("api_test/hid/api")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceAdded) {
   ExtensionTestMessageListener load_listener("loaded", false);
   ExtensionTestMessageListener result_listener("success", false);
   result_listener.set_failure_message("failure");
 
   ASSERT_TRUE(LoadApp("api_test/hid/add_event"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());
 
   // Add a blocked device first so that the test will fail if a notification is
   // received.
-  hid_service_->AddDevice(kTestDeviceIds[3], 0x18D1, 0x58F1, false);
-  hid_service_->AddDevice(kTestDeviceIds[4], 0x18D1, 0x58F0, false);
+  device_client_->mock_service().AddDevice(kTestDeviceIds[3], 0x18D1, 0x58F1,
+                                           false);
+  device_client_->mock_service().AddDevice(kTestDeviceIds[4], 0x18D1, 0x58F0,
+                                           false);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }
 
 IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceRemoved) {
   ExtensionTestMessageListener load_listener("loaded", false);
   ExtensionTestMessageListener result_listener("success", false);
   result_listener.set_failure_message("failure");
 
   ASSERT_TRUE(LoadApp("api_test/hid/remove_event"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());
 
   // Device C was not returned by chrome.hid.getDevices, the app will not get
   // a notification.
-  hid_service_->RemoveDevice(kTestDeviceIds[2]);
+  device_client_->mock_service().RemoveDevice(kTestDeviceIds[2]);
   // Device A was returned, the app will get a notification.
-  hid_service_->RemoveDevice(kTestDeviceIds[0]);
+  device_client_->mock_service().RemoveDevice(kTestDeviceIds[0]);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }
 
 IN_PROC_BROWSER_TEST_F(HidApiTest, GetUserSelectedDevices) {
   ExtensionTestMessageListener open_listener("opened_device", false);
 
   TestExtensionsAPIClient test_api_client;
   ASSERT_TRUE(LoadApp("api_test/hid/get_user_selected_devices"));
   ASSERT_TRUE(open_listener.WaitUntilSatisfied());
 
   ExtensionTestMessageListener remove_listener("removed", false);
-  hid_service_->RemoveDevice(kTestDeviceIds[0]);
+  device_client_->mock_service().RemoveDevice(kTestDeviceIds[0]);
   ASSERT_TRUE(remove_listener.WaitUntilSatisfied());
 
   ExtensionTestMessageListener add_listener("added", false);
-  hid_service_->AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0, true);
+  device_client_->mock_service().AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0,
+                                           true);
   ASSERT_TRUE(add_listener.WaitUntilSatisfied());
 }
 
 }  // namespace extensions