Manage UsbService lifetime in DeviceClient implementations.

chrome/browser/devtools/device/usb/android_usb_browsertest.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 <algorithm>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/devtools/device/adb/mock_adb_server.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
 #include "chrome/browser/devtools/device/usb/android_usb_device.h"
 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
+#include "device/core/device_client.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
+using device::DeviceClient;
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDescriptor;
 using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
 using device::UsbService;
 using device::UsbSynchronizationType;
 using device::UsbTransferType;
 using device::UsbUsageType;
@@ skipping 459 matching lines @@
         break;
     }
     step_++;
     callback.Run(devices);
   }
 
  private:
   int step_;
 };
 
+class TestDeviceClient : public DeviceClient {
+ public:
+  explicit TestDeviceClient(scoped_ptr<UsbService> service)
+      : DeviceClient(), usb_service_(service.Pass()) {}
+  ~TestDeviceClient() override {}
+
+ private:
+  UsbService* GetUsbService() override { return usb_service_.get(); }
+
+  scoped_ptr<UsbService> usb_service_;
+};
+
 class DevToolsAndroidBridgeWarmUp
     : public DevToolsAndroidBridge::DeviceCountListener {
  public:
   DevToolsAndroidBridgeWarmUp(base::Closure closure,
                               DevToolsAndroidBridge* adb_bridge)
       : closure_(closure), adb_bridge_(adb_bridge) {}
 
   void DeviceCountChanged(int count) override {
     adb_bridge_->RemoveDeviceCountListener(this);
     closure_.Run();
   }
 
   base::Closure closure_;
   DevToolsAndroidBridge* adb_bridge_;
 };
 
 class AndroidUsbDiscoveryTest : public InProcessBrowserTest {
  protected:
   AndroidUsbDiscoveryTest()
       : scheduler_invoked_(0) {
   }
 
-  void SetUp() override {
-    // This must happen before profile creation as there are KeyedServices that
-    // may trigger the creation of a non-mock instance of UsbService.
-    mock_usb_service_.reset(CreateMockService());
-    InProcessBrowserTest::SetUp();
-  }
-
   void SetUpOnMainThread() override {
+    device_client_.reset(new TestDeviceClient(CreateMockService()));
     adb_bridge_ =
         DevToolsAndroidBridge::Factory::GetForProfile(browser()->profile());
     DCHECK(adb_bridge_);
     adb_bridge_->set_task_scheduler_for_test(base::Bind(
         &AndroidUsbDiscoveryTest::ScheduleDeviceCountRequest, this));
 
     scoped_refptr<UsbDeviceProvider> provider =
         new UsbDeviceProvider(browser()->profile());
 
     AndroidDeviceManager::DeviceProviders providers;
     providers.push_back(provider);
     adb_bridge_->set_device_providers_for_test(providers);
     runner_ = new content::MessageLoopRunner;
   }
 
   void ScheduleDeviceCountRequest(const base::Closure& request) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     scheduler_invoked_++;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, request);
   }
 
-  virtual MockUsbService* CreateMockService() { return new MockUsbService(); }
+  virtual scoped_ptr<MockUsbService> CreateMockService() {
+    return make_scoped_ptr(new MockUsbService());
+  }
 
   scoped_refptr<content::MessageLoopRunner> runner_;
-  scoped_ptr<MockUsbService> mock_usb_service_;
+  scoped_ptr<TestDeviceClient> device_client_;
   DevToolsAndroidBridge* adb_bridge_;
   int scheduler_invoked_;
 };
 
 class AndroidUsbCountTest : public AndroidUsbDiscoveryTest {
  protected:
   void SetUpOnMainThread() override {
     AndroidUsbDiscoveryTest::SetUpOnMainThread();
     DevToolsAndroidBridgeWarmUp warmup(runner_->QuitClosure(), adb_bridge_);
     adb_bridge_->AddDeviceCountListener(&warmup);
     runner_->Run();
     runner_ = new content::MessageLoopRunner;
   }
 };
 
 class AndroidUsbTraitsTest : public AndroidUsbDiscoveryTest {
  protected:
-  MockUsbService* CreateMockService() override {
-    return new MockUsbServiceForCheckingTraits();
+  scoped_ptr<MockUsbService> CreateMockService() override {
+    return make_scoped_ptr(new MockUsbServiceForCheckingTraits());
   }
 };
 
 class AndroidBreakingUsbTest : public AndroidUsbDiscoveryTest {
  protected:
-  MockUsbService* CreateMockService() override {
-    return new MockBreakingUsbService();
+  scoped_ptr<MockUsbService> CreateMockService() override {
+    return make_scoped_ptr(new MockBreakingUsbService());
   }
 };
 
 class AndroidNoConfigUsbTest : public AndroidUsbDiscoveryTest {
  protected:
-  MockUsbService* CreateMockService() override {
-    return new MockNoConfigUsbService();
+  scoped_ptr<MockUsbService> CreateMockService() override {
+    return make_scoped_ptr(new MockNoConfigUsbService());
   }
 };
 
 class MockListListener : public DevToolsAndroidBridge::DeviceListListener {
  public:
   MockListListener(DevToolsAndroidBridge* adb_bridge,
                    const base::Closure& callback)
       : adb_bridge_(adb_bridge),
         callback_(callback) {
   }
@@ skipping 183 matching lines @@
   EXPECT_EQ(2, listener.invoked_);
   EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_);
   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 }
 
 IN_PROC_BROWSER_TEST_F(AndroidUsbTraitsTest, TestDeviceCounting) {
   MockCountListenerForCheckingTraits listener(adb_bridge_);
   adb_bridge_->AddDeviceCountListener(&listener);
   runner_->Run();
 }