[chrome/browser/download] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/download/download_path_reservation_tracker.cc

 // Copyright (c) 2012 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 "chrome/browser/download/download_path_reservation_tracker.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 52 matching lines @@
   DownloadItem* download_item_;
 
   // Last known target path for the download.
   base::FilePath last_target_path_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemObserver);
 };
 
 // Returns true if the given path is in use by a path reservation.
 bool IsPathReserved(const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // No reservation map => no reservations.
   if (g_reservation_map == NULL)
     return false;
   // Unfortunately path normalization doesn't work reliably for non-existant
   // files. So given a FilePath, we can't derive a normalized key that we can
   // use for lookups. We only expect a small number of concurrent downloads at
   // any given time, so going through all of them shouldn't be too slow.
   for (ReservationMap::const_iterator iter = g_reservation_map->begin();
        iter != g_reservation_map->end(); ++iter) {
     if (iter->second == path)
       return true;
   }
   return false;
 }
 
 // Returns true if the given path is in use by any path reservation or the
 // file system. Called on the FILE thread.
 bool IsPathInUse(const base::FilePath& path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // If there is a reservation, then the path is in use.
   if (IsPathReserved(path))
     return true;
 
   // If the path exists in the file system, then the path is in use.
   if (base::PathExists(path))
     return true;
 
   return false;
 }
@@ skipping 45 matching lines @@
 // - Truncates the suggested name if it exceeds the filesystem's limit.
 // - Uniquifies |suggested_path| if |should_uniquify_path| is true.
 // - Returns true if |reserved_path| has been successfully verified.
 bool CreateReservation(
     ReservationKey key,
     const base::FilePath& suggested_path,
     const base::FilePath& default_download_path,
     bool create_directory,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
     base::FilePath* reserved_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(suggested_path.IsAbsolute());
 
   // Create a reservation map if one doesn't exist. It will be automatically
   // deleted when all the reservations are revoked.
   if (g_reservation_map == NULL)
     g_reservation_map = new ReservationMap;
 
   ReservationMap& reservations = *g_reservation_map;
   DCHECK(!ContainsKey(reservations, key));
 
@@ skipping 73 matching lines @@
 
   reservations[key] = target_path;
   bool verified = (is_path_writeable && !has_conflicts && !name_too_long);
   *reserved_path = target_path;
   return verified;
 }
 
 // Called on the FILE thread to update the path of the reservation associated
 // with |key| to |new_path|.
 void UpdateReservation(ReservationKey key, const base::FilePath& new_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(g_reservation_map != NULL);
   ReservationMap::iterator iter = g_reservation_map->find(key);
   if (iter != g_reservation_map->end()) {
     iter->second = new_path;
   } else {
     // This would happen if an UpdateReservation() notification was scheduled on
     // the FILE thread before ReserveInternal(), or after a Revoke()
     // call. Neither should happen.
     NOTREACHED();
   }
 }
 
 // Called on the FILE thread to remove the path reservation associated with
 // |key|.
 void RevokeReservation(ReservationKey key) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(g_reservation_map != NULL);
   DCHECK(ContainsKey(*g_reservation_map, key));
   g_reservation_map->erase(key);
   if (g_reservation_map->size() == 0) {
     // No more reservations. Delete map.
     delete g_reservation_map;
     g_reservation_map = NULL;
   }
 }
 
 void RunGetReservedPathCallback(
     const DownloadPathReservationTracker::ReservedPathCallback& callback,
     const base::FilePath* reserved_path,
     bool verified) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback.Run(*reserved_path, verified);
 }
 
 DownloadItemObserver::DownloadItemObserver(DownloadItem* download_item)
     : download_item_(download_item),
       last_target_path_(download_item->GetTargetFilePath()) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   download_item_->AddObserver(this);
 }
 
 DownloadItemObserver::~DownloadItemObserver() {
   download_item_->RemoveObserver(this);
 }
 
 void DownloadItemObserver::OnDownloadUpdated(DownloadItem* download) {
   switch (download->GetState()) {
     case DownloadItem::IN_PROGRESS: {
@@ skipping 42 matching lines @@
 }  // namespace
 
 // static
 void DownloadPathReservationTracker::GetReservedPath(
     DownloadItem* download_item,
     const base::FilePath& target_path,
     const base::FilePath& default_path,
     bool create_directory,
     FilenameConflictAction conflict_action,
     const ReservedPathCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Attach an observer to the download item so that we know when the target
   // path changes and/or the download is no longer active.
   new DownloadItemObserver(download_item);
   // DownloadItemObserver deletes itself.
 
   base::FilePath* reserved_path = new base::FilePath;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&CreateReservation,
                  download_item,
                  target_path,
                  default_path,
                  create_directory,
                  conflict_action,
                  reserved_path),
       base::Bind(&RunGetReservedPathCallback,
                  callback,
                  base::Owned(reserved_path)));
 }
 
 // static
 bool DownloadPathReservationTracker::IsPathInUseForTesting(
     const base::FilePath& path) {
   return IsPathInUse(path);
 }