Check that extensions::HidDeviceManager is used from the FILE thread.

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 "content/public/browser/browser_thread.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;
@@ skipping 10 matching lines @@
 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) {
+  DCHECK(IsCalledOnValidThread());
   UpdateDevices();
 
   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;
@@ skipping 49 matching lines @@
         api_devices->Append(api_device_info.ToValue().release());
       }
     }
   }
 
   return scoped_ptr<base::ListValue>(api_devices);
 }
 
 bool HidDeviceManager::GetDeviceInfo(int resource_id,
                                      device::HidDeviceInfo* device_info) {
+  DCHECK(IsCalledOnValidThread());
   UpdateDevices();
   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);
 }
 
 bool HidDeviceManager::HasPermission(const Extension* extension,
                                      const device::HidDeviceInfo& device_info) {
+  DCHECK(IsCalledOnValidThread());
   UsbDevicePermission::CheckParam usbParam(
       device_info.vendor_id,
       device_info.product_id,
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
   if (extension->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kUsbDevice, &usbParam)) {
     return true;
   }
 
   if (extension->permissions_data()->HasAPIPermission(
           APIPermission::kU2fDevices)) {
     HidDeviceFilter u2f_filter;
     u2f_filter.SetUsagePage(0xF1D0);
     if (u2f_filter.Matches(device_info)) {
       return true;
     }
   }
 
   return false;
 }
 
+// static
+bool HidDeviceManager::IsCalledOnValidThread() {
+  return content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE);
+}
+
 void HidDeviceManager::UpdateDevices() {
-  thread_checker_.CalledOnValidThread();
+  DCHECK(IsCalledOnValidThread());
   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 =
@@ skipping 11 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