favor DCHECK_CURRENTLY_ON for better logs in components/

components/storage_monitor/volume_mount_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.
 
 #include "components/storage_monitor/volume_mount_watcher_win.h"
 
 #include <windows.h>
 
 #include <dbt.h>
 #include <fileapi.h>
@@ skipping 333 matching lines @@
 }
 
 // In order to get all the weak pointers created on the UI thread, and doing
 // synchronous Windows calls in the worker pool, this kicks off a chain of
 // events which will
 // a) Enumerate attached devices
 // b) Create weak pointers for which to send completion signals from
 // c) Retrieve metadata on the volumes and then
 // d) Notify that metadata to listeners.
 void VolumeMountWatcherWin::Init() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // When VolumeMountWatcherWin is created, the message pumps are not running
   // so a posted task from the constructor would never run. Therefore, do all
   // the initializations here.
   base::PostTaskAndReplyWithResult(
       device_info_task_runner_.get(), FROM_HERE, GetAttachedDevicesCallback(),
       base::Bind(&VolumeMountWatcherWin::AddDevicesOnUIThread,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VolumeMountWatcherWin::AddDevicesOnUIThread(
     std::vector<base::FilePath> removable_devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (size_t i = 0; i < removable_devices.size(); i++) {
     if (ContainsKey(pending_device_checks_, removable_devices[i]))
       continue;
     pending_device_checks_.insert(removable_devices[i]);
     device_info_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VolumeMountWatcherWin::RetrieveInfoForDeviceAndAdd,
                    removable_devices[i], GetDeviceDetailsCallback(),
                    weak_factory_.GetWeakPtr()));
@@ skipping 15 matching lines @@
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&VolumeMountWatcherWin::HandleDeviceAttachEventOnUIThread,
                  volume_watcher, device_path, info));
 }
 
 void VolumeMountWatcherWin::DeviceCheckComplete(
     const base::FilePath& device_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   pending_device_checks_.erase(device_path);
 
   if (pending_device_checks_.size() == 0) {
     if (notifications_)
       notifications_->MarkInitialized();
   }
 }
 
 VolumeMountWatcherWin::GetAttachedDevicesCallbackType
     VolumeMountWatcherWin::GetAttachedDevicesCallback() const {
   return base::Bind(&GetAttachedDevices);
 }
 
 VolumeMountWatcherWin::GetDeviceDetailsCallbackType
     VolumeMountWatcherWin::GetDeviceDetailsCallback() const {
   return base::Bind(&GetDeviceDetails);
 }
 
 bool VolumeMountWatcherWin::GetDeviceInfo(const base::FilePath& device_path,
                                           StorageInfo* info) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(info);
   base::FilePath path(device_path);
   MountPointDeviceMetadataMap::const_iterator iter =
       device_metadata_.find(path);
   while (iter == device_metadata_.end() && path.DirName() != path) {
     path = path.DirName();
     iter = device_metadata_.find(path);
   }
 
   if (iter == device_metadata_.end())
     return false;
 
   *info = iter->second;
   return true;
 }
 
 void VolumeMountWatcherWin::OnWindowMessage(UINT event_type, LPARAM data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   switch (event_type) {
     case DBT_DEVICEARRIVAL: {
       if (IsLogicalVolumeStructure(data)) {
         DWORD unitmask = GetVolumeBitMaskFromBroadcastHeader(data);
         std::vector<base::FilePath> paths;
         for (int i = 0; unitmask; ++i, unitmask >>= 1) {
           if (!(unitmask & 0x01))
             continue;
           paths.push_back(DriveNumberToFilePath(i));
         }
@@ skipping 44 matching lines @@
   notifications_ = notifications;
 }
 
 VolumeMountWatcherWin::~VolumeMountWatcherWin() {
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void VolumeMountWatcherWin::HandleDeviceAttachEventOnUIThread(
     const base::FilePath& device_path,
     const StorageInfo& info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   device_metadata_[device_path] = info;
 
   if (notifications_)
     notifications_->ProcessAttach(info);
 
   DeviceCheckComplete(device_path);
 }
 
 void VolumeMountWatcherWin::HandleDeviceDetachEventOnUIThread(
     const base::string16& device_location) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   MountPointDeviceMetadataMap::const_iterator device_info =
       device_metadata_.find(base::FilePath(device_location));
   // If the device isn't type removable (like a CD), it won't be there.
   if (device_info == device_metadata_.end())
     return;
 
   if (notifications_)
     notifications_->ProcessDetach(device_info->second.device_id());
   device_metadata_.erase(device_info);
 }
 
 void VolumeMountWatcherWin::EjectDevice(
     const std::string& device_id,
     base::Callback<void(StorageMonitor::EjectStatus)> callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::FilePath device = MediaStorageUtil::FindDevicePathById(device_id);
   if (device.empty()) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
   if (device_metadata_.erase(device) == 0) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
 
   device_info_task_runner_->PostTask(
       FROM_HERE, base::Bind(&EjectDeviceInThreadPool, device, callback,
                             device_info_task_runner_, 0));
 }
 
 }  // namespace storage_monitor