Manage HidService lifetime in DeviceClient implementations.

device/hid/hid_service_linux.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 "device/hid/hid_service_linux.h"
 
 #include <fcntl.h>
 #include <limits>
 #include <string>
 
@@ skipping 194 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : file_task_runner_(file_task_runner), weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   scoped_ptr<FileThreadHelper> helper(
       new FileThreadHelper(weak_factory_.GetWeakPtr(), task_runner_));
   helper_ = helper.get();
   file_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FileThreadHelper::Start, base::Passed(&helper)));
 }
 
+HidServiceLinux::~HidServiceLinux() {
+  file_task_runner_->DeleteSoon(FROM_HERE, helper_);
+}
+
 void HidServiceLinux::Connect(const HidDeviceId& device_id,
                               const ConnectCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const auto& map_entry = devices().find(device_id);
   if (map_entry == devices().end()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
   scoped_refptr<HidDeviceInfoLinux> device_info =
       static_cast<HidDeviceInfoLinux*>(map_entry->second.get());
 
   scoped_ptr<ConnectParams> params(new ConnectParams(
       device_info, callback, task_runner_, file_task_runner_));
 
 #if defined(OS_CHROMEOS)
   chromeos::PermissionBrokerClient* client =
       chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission broker client.";
   client->OpenPath(
       device_info->device_node(),
       base::Bind(&HidServiceLinux::OnPathOpened, base::Passed(&params)));
 #else
   file_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&HidServiceLinux::OpenOnBlockingThread,
                                          base::Passed(&params)));
 #endif  // defined(OS_CHROMEOS)
 }
 
-HidServiceLinux::~HidServiceLinux() {
-  file_task_runner_->DeleteSoon(FROM_HERE, helper_);
-}
-
 #if defined(OS_CHROMEOS)
 
 // static
 void HidServiceLinux::OnPathOpened(scoped_ptr<ConnectParams> params,
                                    dbus::FileDescriptor fd) {
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       params->file_task_runner;
   file_task_runner->PostTask(
       FROM_HERE, base::Bind(&HidServiceLinux::ValidateFdOnBlockingThread,
                             base::Passed(&params), base::Passed(&fd)));
@@ skipping 71 matching lines @@
 
 // static
 void HidServiceLinux::CreateConnection(scoped_ptr<ConnectParams> params) {
   DCHECK(params->device_file.IsValid());
   params->callback.Run(make_scoped_refptr(
       new HidConnectionLinux(params->device_info, params->device_file.Pass(),
                              params->file_task_runner)));
 }
 
 }  // namespace device