favor DCHECK_CURRENTLY_ON for better logs in components/

components/storage_monitor/storage_monitor_linux.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.
 
 // StorageMonitorLinux implementation.
 
 #include "components/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
@@ skipping 101 matching lines @@
   uint64 total_size_in_bytes = 0;
   if (!base::StringToUint64(partition_size, &total_size_in_bytes))
     return 0;
   return (total_size_in_bytes <= kuint64max / 512) ?
       total_size_in_bytes * 512 : 0;
 }
 
 // Gets the device information using udev library.
 scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
                                       const base::FilePath& mount_point) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!device_path.empty());
 
   scoped_ptr<StorageInfo> storage_info;
 
   ScopedGetDeviceInfoResultRecorder results_recorder;
 
   device::ScopedUdevPtr udev_obj(device::udev_new());
   if (!udev_obj.get())
     return storage_info.Pass();
 
@@ skipping 58 matching lines @@
       volume_label,
       vendor_name,
       model_name,
       GetDeviceStorageSize(device_path, device.get())));
   return storage_info.Pass();
 }
 
 MtabWatcherLinux* CreateMtabWatcherLinuxOnFileThread(
     const base::FilePath& mtab_path,
     base::WeakPtr<MtabWatcherLinux::Delegate> delegate) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // Owned by caller.
   return new MtabWatcherLinux(mtab_path, delegate);
 }
 
 StorageMonitor::EjectStatus EjectPathOnFileThread(
     const base::FilePath& path,
     const base::FilePath& device) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // Note: Linux LSB says umount should exist in /bin.
   static const char kUmountBinary[] = "/bin/umount";
   std::vector<std::string> command;
   command.push_back(kUmountBinary);
   command.push_back(path.value());
 
   base::LaunchOptions options;
   base::Process process = base::LaunchProcess(command, options);
   if (!process.IsValid())
@@ skipping 17 matching lines @@
 
   return StorageMonitor::EJECT_OK;
 }
 
 }  // namespace
 
 StorageMonitorLinux::StorageMonitorLinux(const base::FilePath& path)
     : mtab_path_(path),
       get_device_info_callback_(base::Bind(&GetDeviceInfo)),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 StorageMonitorLinux::~StorageMonitorLinux() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void StorageMonitorLinux::Init() {
   DCHECK(!mtab_path_.empty());
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateMtabWatcherLinuxOnFileThread,
                  mtab_path_,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&StorageMonitorLinux::OnMtabWatcherCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 
   if (!media_transfer_protocol_manager_) {
     scoped_refptr<base::MessageLoopProxy> loop_proxy =
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
     media_transfer_protocol_manager_.reset(
         device::MediaTransferProtocolManager::Initialize(loop_proxy));
   }
 
   media_transfer_protocol_device_observer_.reset(
       new MediaTransferProtocolDeviceObserverLinux(
           receiver(), media_transfer_protocol_manager_.get()));
 }
 
 bool StorageMonitorLinux::GetStorageInfoForPath(
     const base::FilePath& path,
     StorageInfo* device_info) const {
   DCHECK(device_info);
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // TODO(thestig) |media_transfer_protocol_device_observer_| should always be
   // valid.
   if (media_transfer_protocol_device_observer_ &&
       media_transfer_protocol_device_observer_->GetStorageInfoForPath(
           path, device_info)) {
     return true;
   }
 
   if (!path.IsAbsolute())
@@ skipping 60 matching lines @@
 
   receiver()->ProcessDetach(device_id);
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&EjectPathOnFileThread, path, device),
       callback);
 }
 
 void StorageMonitorLinux::OnMtabWatcherCreated(MtabWatcherLinux* watcher) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   mtab_watcher_.reset(watcher);
 }
 
 void StorageMonitorLinux::UpdateMtab(const MountPointDeviceMap& new_mtab) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Check existing mtab entries for unaccounted mount points.
   // These mount points must have been removed in the new mtab.
   std::list<base::FilePath> mount_points_to_erase;
   std::list<base::FilePath> multiple_mounted_devices_needing_reattachment;
   for (MountMap::const_iterator old_iter = mount_info_map_.begin();
        old_iter != mount_info_map_.end(); ++old_iter) {
     const base::FilePath& mount_point = old_iter->first;
     const base::FilePath& mount_device = old_iter->second.mount_device;
     MountPointDeviceMap::const_iterator new_iter = new_mtab.find(mount_point);
@@ skipping 80 matching lines @@
     BrowserThread::PostTaskAndReply(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&base::DoNothing),
         base::Bind(&StorageMonitorLinux::MarkInitialized,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 bool StorageMonitorLinux::IsDeviceAlreadyMounted(
     const base::FilePath& mount_device) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return ContainsKey(mount_priority_map_, mount_device);
 }
 
 void StorageMonitorLinux::HandleDeviceMountedMultipleTimes(
     const base::FilePath& mount_device,
     const base::FilePath& mount_point) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   MountPriorityMap::iterator priority = mount_priority_map_.find(mount_device);
   DCHECK(priority != mount_priority_map_.end());
   const base::FilePath& other_mount_point = priority->second.begin()->first;
   priority->second[mount_point] = false;
   mount_info_map_[mount_point] =
       mount_info_map_.find(other_mount_point)->second;
 }
 
 void StorageMonitorLinux::AddNewMount(const base::FilePath& mount_device,
                                       scoped_ptr<StorageInfo> storage_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!storage_info)
     return;
 
   DCHECK(!storage_info->device_id().empty());
 
   bool removable = StorageInfo::IsRemovableDevice(storage_info->device_id());
   const base::FilePath mount_point(storage_info->location());
 
   MountPointInfo mount_point_info;
   mount_point_info.mount_device = mount_device;
   mount_point_info.storage_info = *storage_info;
   mount_info_map_[mount_point] = mount_point_info;
   mount_priority_map_[mount_device][mount_point] = removable;
   receiver()->ProcessAttach(*storage_info);
 }
 
 StorageMonitor* StorageMonitor::CreateInternal() {
   const base::FilePath kDefaultMtabPath("/etc/mtab");
   return new StorageMonitorLinux(kDefaultMtabPath);
 }
 
 }  // namespace storage_monitor