Manage UsbService lifetime in DeviceClient implementations.

device/devices_app/devices_app.cc

 // Copyright 2015 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/devices_app/devices_app.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 47 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(USBDeviceManagerDelegate);
 };
 
 // A DeviceClient implementation to be constructed iff the app is not running
 // in an embedder that provides a DeviceClient (i.e. running as a standalone
 // Mojo app, not in Chrome).
 class AppDeviceClient : public DeviceClient {
  public:
   explicit AppDeviceClient(
       scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-      : usb_service_(UsbService::GetInstance(blocking_task_runner)) {}
+      : blocking_task_runner_(blocking_task_runner) {}
   ~AppDeviceClient() override {}
 
  private:
   // DeviceClient:
-  UsbService* GetUsbService() override { return usb_service_; }
+  UsbService* GetUsbService() override {
+    if (!usb_service_) {
+      usb_service_ = UsbService::Create(blocking_task_runner_);
+    }
+    return usb_service_.get();
+  }
 
-  UsbService* usb_service_;
+  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
+  scoped_ptr<UsbService> usb_service_;
 };
 
 }  // namespace
 
 // This class insures that a UsbService has been initialized and is accessible
 // via the DeviceClient interface.
 class DevicesApp::USBServiceInitializer {
  public:
   USBServiceInitializer()
       : blocking_thread_("USB service blocking I/O thread") {
@@ skipping 71 matching lines @@
   // guaranteed to outlive |this|, and the callback is canceled if |this| is
   // destroyed.
   idle_timeout_callback_.Reset(base::Bind(&mojo::ApplicationImpl::Quit,
                                           base::Unretained(app_impl_)));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, idle_timeout_callback_.callback(),
       base::TimeDelta::FromSeconds(kIdleTimeoutInSeconds));
 }
 
 }  // namespace device