Fix HidService lifetime issues

extensions/browser/api/hid/hid_device_manager.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 "extensions/browser/api/hid/hid_device_manager.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/lazy_instance.h"
+#include "device/core/device_client.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_service.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
 using device::HidDeviceFilter;
 using device::HidService;
 using device::HidUsageAndPage;
 
 namespace extensions {
 
 HidDeviceManager::HidDeviceManager(content::BrowserContext* context)
-  : next_resource_id_(0) {}
+    : next_resource_id_(0) {
+}
 
 HidDeviceManager::~HidDeviceManager() {}
 
 // static
 BrowserContextKeyedAPIFactory<HidDeviceManager>*
 HidDeviceManager::GetFactoryInstance() {
   static base::LazyInstance<BrowserContextKeyedAPIFactory<HidDeviceManager> >
       factory = LAZY_INSTANCE_INITIALIZER;
   return &factory.Get();
 }
 
 scoped_ptr<base::ListValue> HidDeviceManager::GetApiDevices(
     const Extension* extension,
     const std::vector<HidDeviceFilter>& filters) {
   UpdateDevices();
 
-  HidService* hid_service = ExtensionsAPIClient::Get()->GetHidService();
+  HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   DCHECK(hid_service);
   base::ListValue* api_devices = new base::ListValue();
   for (ResourceIdToDeviceIdMap::const_iterator device_iter =
            device_ids_.begin();
        device_iter != device_ids_.end();
        ++device_iter) {
     int resource_id = device_iter->first;
     device::HidDeviceId device_id = device_iter->second;
     device::HidDeviceInfo device_info;
 
@@ skipping 47 matching lines @@
       }
     }
   }
 
   return scoped_ptr<base::ListValue>(api_devices);
 }
 
 bool HidDeviceManager::GetDeviceInfo(int resource_id,
                                      device::HidDeviceInfo* device_info) {
   UpdateDevices();
-  HidService* hid_service = ExtensionsAPIClient::Get()->GetHidService();
+  HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   DCHECK(hid_service);
 
   ResourceIdToDeviceIdMap::const_iterator device_iter =
       device_ids_.find(resource_id);
   if (device_iter == device_ids_.end())
     return false;
 
   return hid_service->GetDeviceInfo(device_iter->second, device_info);
 }
 
@@ skipping 15 matching lines @@
     if (u2f_filter.Matches(device_info)) {
       return true;
     }
   }
 
   return false;
 }
 
 void HidDeviceManager::UpdateDevices() {
   thread_checker_.CalledOnValidThread();
-  HidService* hid_service = ExtensionsAPIClient::Get()->GetHidService();
+  HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   DCHECK(hid_service);
 
   std::vector<device::HidDeviceInfo> devices;
   hid_service->GetDevices(&devices);
 
   // Build an updated bidi mapping between resource ID and underlying device ID.
   DeviceIdToResourceIdMap new_resource_ids;
   ResourceIdToDeviceIdMap new_device_ids;
   for (std::vector<device::HidDeviceInfo>::const_iterator iter =
            devices.begin();
@@ skipping 10 matching lines @@
       new_id = next_resource_id_++;
     }
     new_resource_ids[device_info.device_id] = new_id;
     new_device_ids[new_id] = device_info.device_id;
   }
   device_ids_.swap(new_device_ids);
   resource_ids_.swap(new_resource_ids);
 }
 
 }  // namespace extensions