Revert of Provide the DeviceManager service to the renderer directly, no app.

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 54 matching lines @@
 
   ~USBServiceInitializer() {}
 
  private:
   scoped_ptr<AppDeviceClient> app_device_client_;
   base::Thread blocking_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(USBServiceInitializer);
 };
 
-DevicesApp::DevicesApp()
-    : app_impl_(nullptr), active_device_manager_count_(0) {}
+DevicesApp::DevicesApp(
+    scoped_refptr<base::SequencedTaskRunner> service_task_runner)
+    : app_impl_(nullptr),
+      service_task_runner_(service_task_runner),
+      active_device_manager_count_(0) {
+}
 
 DevicesApp::~DevicesApp() {
 }
 
 void DevicesApp::Initialize(mojo::ApplicationImpl* app) {
   app_impl_ = app;
-  service_initializer_.reset(new USBServiceInitializer);
+  if (!service_task_runner_) {
+    service_initializer_.reset(new USBServiceInitializer);
+    service_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  }
   StartIdleTimer();
 }
 
 bool DevicesApp::ConfigureIncomingConnection(
     mojo::ApplicationConnection* connection) {
   connection->AddService<usb::DeviceManager>(this);
   return true;
 }
 
 void DevicesApp::Quit() {
   service_initializer_.reset();
   app_impl_ = nullptr;
 }
 
 void DevicesApp::Create(mojo::ApplicationConnection* connection,
                         mojo::InterfaceRequest<usb::DeviceManager> request) {
   // Bind the new device manager to the connecting application's permission
   // provider.
   usb::PermissionProviderPtr permission_provider;
   connection->ConnectToService(&permission_provider);
 
   // Owned by its message pipe.
-  usb::DeviceManagerImpl* device_manager =
-      new usb::DeviceManagerImpl(permission_provider.Pass(), request.Pass());
+  usb::DeviceManagerImpl* device_manager = new usb::DeviceManagerImpl(
+      request.Pass(), permission_provider.Pass(), service_task_runner_);
   device_manager->set_connection_error_handler(
       base::Bind(&DevicesApp::OnConnectionError, base::Unretained(this)));
 
   active_device_manager_count_++;
   idle_timeout_callback_.Cancel();
 }
 
 void DevicesApp::OnConnectionError() {
   DCHECK_GE(active_device_manager_count_, 0u);
   active_device_manager_count_--;
   if (active_device_manager_count_ == 0) {
     // If the last DeviceManager connection has been dropped, kick off an idle
     // timeout to shut ourselves down.
     StartIdleTimer();
   }
 }
 
 void DevicesApp::StartIdleTimer() {
   // Passing unretained |app_impl_| is safe here because |app_impl_| is
   // 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