Manage HidService lifetime in DeviceClient implementations.

device/hid/hid_service_win.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_win.h"
 
 #define INITGUID
 
 #include <dbt.h>
 #include <setupapi.h>
@@ skipping 11 matching lines @@
 #include "device/hid/hid_connection_win.h"
 #include "device/hid/hid_device_info.h"
 #include "net/base/io_buffer.h"
 
 // Setup API is required to enumerate HID devices.
 #pragma comment(lib, "setupapi.lib")
 #pragma comment(lib, "hid.lib")
 
 namespace device {
 
-namespace {
-
-void Noop() {
-  // This function does nothing.
-}
-}
-
 HidServiceWin::HidServiceWin(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : file_task_runner_(file_task_runner),
       device_observer_(this),
       weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   DCHECK(task_runner_.get());
   DeviceMonitorWin* device_monitor =
       DeviceMonitorWin::GetForDeviceInterface(GUID_DEVINTERFACE_HID);
   if (device_monitor) {
     device_observer_.Add(device_monitor);
   }
   file_task_runner_->PostTask(
       FROM_HERE, base::Bind(&HidServiceWin::EnumerateOnFileThread,
                             weak_factory_.GetWeakPtr(), task_runner_));
 }
 
+HidServiceWin::~HidServiceWin() {}
+
 void HidServiceWin::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<HidDeviceInfo> device_info = map_entry->second;
 
   base::win::ScopedHandle file(OpenDevice(device_info->device_id()));
   if (!file.IsValid()) {
     HID_PLOG(EVENT) << "Failed to open device";
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(callback, new HidConnectionWin(device_info, file.Pass())));
 }
 
-HidServiceWin::~HidServiceWin() {
-}
-
 // static
 void HidServiceWin::EnumerateOnFileThread(
     base::WeakPtr<HidServiceWin> service,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   HDEVINFO device_info_set =
       SetupDiGetClassDevs(&GUID_DEVINTERFACE_HID, NULL, NULL,
                           DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 
   if (device_info_set != INVALID_HANDLE_VALUE) {
     SP_DEVICE_INTERFACE_DATA device_interface_data;
@@ skipping 188 matching lines @@
       FROM_HERE,
       base::Bind(&HidServiceWin::AddDeviceOnFileThread,
                  weak_factory_.GetWeakPtr(), task_runner_, device_path));
 }
 
 void HidServiceWin::OnDeviceRemoved(const GUID& class_guid,
                                     const std::string& device_path) {
   // Execute a no-op closure on the file task runner to synchronize with any
   // devices that are still being enumerated.
   file_task_runner_->PostTaskAndReply(
-      FROM_HERE, base::Bind(&Noop),
+      FROM_HERE, base::Bind(&base::DoNothing),
       base::Bind(&HidServiceWin::RemoveDevice, weak_factory_.GetWeakPtr(),
                  device_path));
 }
 
 // static
 base::win::ScopedHandle HidServiceWin::OpenDevice(
     const std::string& device_path) {
   base::win::ScopedHandle file(
       CreateFileA(device_path.c_str(), GENERIC_WRITE | GENERIC_READ,
                   FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                   FILE_FLAG_OVERLAPPED, NULL));
   if (!file.IsValid() &&
       GetLastError() == base::File::FILE_ERROR_ACCESS_DENIED) {
     file.Set(CreateFileA(device_path.c_str(), GENERIC_READ, FILE_SHARE_READ,
                          NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL));
   }
   return file.Pass();
 }
 
 }  // namespace device