favor DCHECK_CURRENTLY_ON for better logs in components/ (part 2)

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 471 matching lines @@
     : notifications_(NULL),
       storage_notifications_(NULL),
       weak_ptr_factory_(this) {
 }
 
 PortableDeviceWatcherWin::~PortableDeviceWatcherWin() {
   UnregisterDeviceNotification(notifications_);
 }
 
 void PortableDeviceWatcherWin::Init(HWND hwnd) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   notifications_ = RegisterPortableDeviceNotification(hwnd);
   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
   media_task_runner_ = pool->GetSequencedTaskRunnerWithShutdownBehavior(
       pool->GetNamedSequenceToken(kMediaTaskRunnerName),
       base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   EnumerateAttachedDevices();
 }
 
 void PortableDeviceWatcherWin::OnWindowMessage(UINT event_type, LPARAM data) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!IsPortableDeviceStructure(data))
     return;
 
   base::string16 device_id = GetPnpDeviceId(data);
   if (event_type == DBT_DEVICEARRIVAL)
     HandleDeviceAttachEvent(device_id);
   else if (event_type == DBT_DEVICEREMOVECOMPLETE)
     HandleDeviceDetachEvent(device_id);
 }
 
 bool PortableDeviceWatcherWin::GetMTPStorageInfoFromDeviceId(
     const std::string& storage_device_id,
     base::string16* device_location,
     base::string16* storage_object_id) const {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(device_location);
   DCHECK(storage_object_id);
   MTPStorageMap::const_iterator storage_map_iter =
       storage_map_.find(storage_device_id);
   if (storage_map_iter == storage_map_.end())
     return false;
 
   MTPDeviceMap::const_iterator device_iter =
       device_map_.find(storage_map_iter->second.location());
   if (device_iter == device_map_.end())
@@ skipping 38 matching lines @@
     callback.Run(StorageMonitor::EJECT_NO_SUCH_DEVICE);
     return;
   }
   HandleDeviceDetachEvent(device_location);
 
   callback.Run(StorageMonitor::EJECT_OK);
 }
 
 void PortableDeviceWatcherWin::EnumerateAttachedDevices() {
   DCHECK(media_task_runner_.get());
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   Devices* devices = new Devices;
   base::PostTaskAndReplyWithResult(
       media_task_runner_.get(), FROM_HERE,
       base::Bind(&EnumerateAttachedDevicesOnBlockingThread, devices),
       base::Bind(&PortableDeviceWatcherWin::OnDidEnumerateAttachedDevices,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(devices)));
 }
 
 void PortableDeviceWatcherWin::OnDidEnumerateAttachedDevices(
     const Devices* devices, const bool result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(devices);
   if (!result)
     return;
   for (Devices::const_iterator device_iter = devices->begin();
        device_iter != devices->end(); ++device_iter) {
     OnDidHandleDeviceAttachEvent(&(*device_iter), result);
   }
 }
 
 void PortableDeviceWatcherWin::HandleDeviceAttachEvent(
     const base::string16& pnp_device_id) {
   DCHECK(media_task_runner_.get());
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DeviceDetails* device_details = new DeviceDetails;
   base::PostTaskAndReplyWithResult(
       media_task_runner_.get(), FROM_HERE,
       base::Bind(&HandleDeviceAttachedEventOnBlockingThread, pnp_device_id,
                  device_details),
       base::Bind(&PortableDeviceWatcherWin::OnDidHandleDeviceAttachEvent,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(device_details)));
 }
 
 void PortableDeviceWatcherWin::OnDidHandleDeviceAttachEvent(
     const DeviceDetails* device_details, const bool result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(device_details);
   if (!result)
     return;
 
   const StorageObjects& storage_objects = device_details->storage_objects;
   const base::string16& name = device_details->name;
   const base::string16& location = device_details->location;
   DCHECK(!ContainsKey(device_map_, location));
   for (StorageObjects::const_iterator storage_iter = storage_objects.begin();
        storage_iter != storage_objects.end(); ++storage_iter) {
@@ skipping 16 matching lines @@
     if (storage_notifications_) {
       info.set_location(GetStoragePathFromStorageId(storage_id));
       storage_notifications_->ProcessAttach(info);
     }
   }
   device_map_[location] = storage_objects;
 }
 
 void PortableDeviceWatcherWin::HandleDeviceDetachEvent(
     const base::string16& pnp_device_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceMap::iterator device_iter = device_map_.find(pnp_device_id);
   if (device_iter == device_map_.end())
     return;
 
   const StorageObjects& storage_objects = device_iter->second;
   for (StorageObjects::const_iterator storage_object_iter =
        storage_objects.begin(); storage_object_iter != storage_objects.end();
        ++storage_object_iter) {
     std::string storage_id = storage_object_iter->object_persistent_id;
     MTPStorageMap::iterator storage_map_iter = storage_map_.find(storage_id);
     DCHECK(storage_map_iter != storage_map_.end());
     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