Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/storage_monitor/portable_device_watcher_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.
 //
 // Any tasks that communicates with the portable device may take >100ms to
 // complete. Those tasks should be run on an blocking thread instead of the
 // UI thread.
 
 #include "components/storage_monitor/portable_device_watcher_win.h"
 
@@ skipping 295 matching lines @@
   // the volume name.
   return ((device_name.length() >= 2) && (device_name[1] == L':') &&
       (((device_name[0] >= L'A') && (device_name[0] <= L'Z')) ||
           ((device_name[0] >= L'a') && (device_name[0] <= L'z'))));
 }
 
 // Returns the name of the device specified by |pnp_device_id|.
 base::string16 GetDeviceNameOnBlockingThread(
     IPortableDeviceManager* portable_device_manager,
     const base::string16& pnp_device_id) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(portable_device_manager);
+  base::ThreadRestrictions::AssertIOAllowed();

[blundell, 2017/05/17 15:24:52]

Is this the canonical change to make here?

[Yeol Park, 2017/05/19 04:34:51]

I used TaskScheduler instead of blocking pool and referenced to
crbug.com/667892.
Is this the wrong direction? or should it be created in a separate CL? :)

[blundell, 2017/05/22 09:29:39]

I would do this in a different CL, yes.

[Yeol Park, 2017/06/23 04:59:20]

Done in https://codereview.chromium.org/2943923002 :)

   base::string16 name;
   GetFriendlyName(pnp_device_id, portable_device_manager, &name) ||
       GetDeviceDescription(pnp_device_id, portable_device_manager, &name) ||
       GetManufacturerName(pnp_device_id, portable_device_manager, &name);
   return name;
 }
 
 // Access the device and gets the device storage details. On success, returns
 // true and populates |storage_objects| with device storage details.
 bool GetDeviceStorageObjectsOnBlockingThread(
     const base::string16& pnp_device_id,
     PortableDeviceWatcherWin::StorageObjects* storage_objects) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(storage_objects);
+  base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedComPtr<IPortableDevice> device;
   if (!SetUp(pnp_device_id, &device))
     return false;
 
   base::string16 device_serial_num;
   if (!GetObjectUniqueId(device.Get(), WPD_DEVICE_OBJECT_ID,
                          &device_serial_num)) {
     return false;
   }
 
@@ skipping 16 matching lines @@
   return true;
 }
 
 // Accesses the device and gets the device details (name, storage info, etc).
 // On success returns true and fills in |device_details|. On failure, returns
 // false. |pnp_device_id| specifies the plug and play device ID string.
 bool GetDeviceInfoOnBlockingThread(
     IPortableDeviceManager* portable_device_manager,
     const base::string16& pnp_device_id,
     PortableDeviceWatcherWin::DeviceDetails* device_details) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(portable_device_manager);
   DCHECK(device_details);
   DCHECK(!pnp_device_id.empty());
+  base::ThreadRestrictions::AssertIOAllowed();
   device_details->name = GetDeviceNameOnBlockingThread(portable_device_manager,
                                                        pnp_device_id);
   if (IsMassStoragePortableDevice(pnp_device_id, device_details->name))
     return false;
 
   device_details->location = pnp_device_id;
   PortableDeviceWatcherWin::StorageObjects storage_objects;
   return GetDeviceStorageObjectsOnBlockingThread(
       pnp_device_id, &device_details->storage_objects);
 }
 
 // Wrapper function to get an instance of portable device manager. On success,
 // returns true and fills in |portable_device_mgr|. On failure, returns false.
 bool GetPortableDeviceManager(
   base::win::ScopedComPtr<IPortableDeviceManager>* portable_device_mgr) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  base::ThreadRestrictions::AssertIOAllowed();
   HRESULT hr = portable_device_mgr->CreateInstance(
       __uuidof(PortableDeviceManager), NULL, CLSCTX_INPROC_SERVER);
   if (SUCCEEDED(hr))
     return true;
 
   // Either there is no portable device support (Windows XP with old versions of
   // Media Player) or the thread does not have COM initialized.
   DCHECK_NE(CO_E_NOTINITIALIZED, hr);
   return false;
 }
 
 // Enumerates the attached portable devices. On success, returns true and fills
 // in |devices| with the attached portable device details. On failure, returns
 // false.
 bool EnumerateAttachedDevicesOnBlockingThread(
     PortableDeviceWatcherWin::Devices* devices) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(devices);
+  base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedComPtr<IPortableDeviceManager> portable_device_mgr;
   if (!GetPortableDeviceManager(&portable_device_mgr))
     return false;
 
   // Get the total number of devices found on the system.
   DWORD pnp_device_count = 0;
   HRESULT hr = portable_device_mgr->GetDevices(NULL, &pnp_device_count);
   if (FAILED(hr))
     return false;
 
@@ skipping 13 matching lines @@
   return !devices->empty();
 }
 
 // Handles the device attach event message on a media task runner.
 // |pnp_device_id| specifies the attached plug and play device ID string. On
 // success, returns true and populates |device_details| with device information.
 // On failure, returns false.
 bool HandleDeviceAttachedEventOnBlockingThread(
     const base::string16& pnp_device_id,
     PortableDeviceWatcherWin::DeviceDetails* device_details) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(device_details);
+  base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedComPtr<IPortableDeviceManager> portable_device_mgr;
   if (!GetPortableDeviceManager(&portable_device_mgr))
     return false;
   // Sometimes, portable device manager doesn't have the new device details.
   // Refresh the manager device list to update its details.
   portable_device_mgr->RefreshDeviceList();
   return GetDeviceInfoOnBlockingThread(portable_device_mgr.Get(), pnp_device_id,
                                        device_details);
 }
 
@@ skipping 214 matching lines @@
     if (storage_notifications_) {
       storage_notifications_->ProcessDetach(
           storage_map_iter->second.device_id());
     }
     storage_map_.erase(storage_map_iter);
   }
   device_map_.erase(device_iter);
 }
 
 }  // namespace storage_monitor