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

chrome/browser/download/download_history.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.
 
 // DownloadHistory manages persisting DownloadItems to the history service by
 // observing a single DownloadManager and all its DownloadItems using an
 // AllDownloadItemNotifier.
 //
 // DownloadHistory decides whether and when to add items to, remove items from,
 // and update items in the database. DownloadHistory uses DownloadHistoryData to
@@ skipping 194 matching lines @@
   return data && (data->state() == DownloadHistoryData::PERSISTED);
 }
 
 DownloadHistory::DownloadHistory(content::DownloadManager* manager,
                                  scoped_ptr<HistoryAdapter> history)
   : notifier_(manager, this),
     history_(history.Pass()),
     loading_id_(content::DownloadItem::kInvalidId),
     history_size_(0),
     weak_ptr_factory_(this) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::DownloadManager::DownloadVector items;
   notifier_.GetManager()->GetAllDownloads(&items);
   for (content::DownloadManager::DownloadVector::const_iterator
        it = items.begin(); it != items.end(); ++it) {
     OnDownloadCreated(notifier_.GetManager(), *it);
   }
   history_->QueryDownloads(base::Bind(
       &DownloadHistory::QueryCallback, weak_ptr_factory_.GetWeakPtr()));
 }
 
 DownloadHistory::~DownloadHistory() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadHistoryDestroyed());
   observers_.Clear();
 }
 
 void DownloadHistory::AddObserver(DownloadHistory::Observer* observer) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
 void DownloadHistory::RemoveObserver(DownloadHistory::Observer* observer) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   observers_.RemoveObserver(observer);
 }
 
 bool DownloadHistory::WasRestoredFromHistory(
     const content::DownloadItem* download) const {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   const DownloadHistoryData* data = DownloadHistoryData::Get(download);
 
   // The OnDownloadCreated handler sets the was_restored_from_history flag when
   // resetting the loading_id_. So one of the two conditions below will hold for
   // a download restored from history even if the caller of this method is
   // racing with our OnDownloadCreated handler.
   return (data && data->was_restored_from_history()) ||
          download->GetId() == loading_id_;
 }
 
 void DownloadHistory::QueryCallback(scoped_ptr<InfoVector> infos) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // ManagerGoingDown() may have happened before the history loaded.
   if (!notifier_.GetManager())
     return;
   for (InfoVector::const_iterator it = infos->begin();
        it != infos->end(); ++it) {
     loading_id_ = history::ToContentDownloadId(it->id);
     content::DownloadItem* item = notifier_.GetManager()->CreateDownloadItem(
         loading_id_,
         it->current_path,
         it->target_path,
@@ skipping 19 matching lines @@
     }
 #endif
     DCHECK_EQ(DownloadHistoryData::PERSISTED,
               DownloadHistoryData::Get(item)->state());
     ++history_size_;
   }
   notifier_.GetManager()->CheckForHistoryFilesRemoval();
 }
 
 void DownloadHistory::MaybeAddToHistory(content::DownloadItem* item) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   uint32 download_id = item->GetId();
   DownloadHistoryData* data = DownloadHistoryData::Get(item);
   bool removing = removing_ids_.find(download_id) != removing_ids_.end();
 
   // TODO(benjhayden): Remove IsTemporary().
   if (download_crx_util::IsExtensionDownload(*item) ||
       item->IsTemporary() ||
       (data->state() != DownloadHistoryData::NOT_PERSISTED) ||
       removing)
@@ skipping 57 matching lines @@
 
   // In case the item changed or became temporary while it was being added.
   // Don't just update all of the item's observers because we're the only
   // observer that can also see data->state(), which is the only thing that
   // ItemAdded() changed.
   OnDownloadUpdated(notifier_.GetManager(), item);
 }
 
 void DownloadHistory::OnDownloadCreated(
     content::DownloadManager* manager, content::DownloadItem* item) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // All downloads should pass through OnDownloadCreated exactly once.
   CHECK(!DownloadHistoryData::Get(item));
   DownloadHistoryData* data = new DownloadHistoryData(item);
   if (item->GetId() == loading_id_) {
     data->SetState(DownloadHistoryData::PERSISTED);
     data->set_was_restored_from_history(true);
     loading_id_ = content::DownloadItem::kInvalidId;
   }
   if (item->GetState() == content::DownloadItem::IN_PROGRESS) {
     data->set_info(GetDownloadRow(item));
   }
   MaybeAddToHistory(item);
 }
 
 void DownloadHistory::OnDownloadUpdated(
     content::DownloadManager* manager, content::DownloadItem* item) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DownloadHistoryData* data = DownloadHistoryData::Get(item);
   if (data->state() == DownloadHistoryData::NOT_PERSISTED) {
     MaybeAddToHistory(item);
     return;
   }
   if (item->IsTemporary()) {
     OnDownloadRemoved(notifier_.GetManager(), item);
     return;
   }
@@ skipping 14 matching lines @@
   }
 }
 
 void DownloadHistory::OnDownloadOpened(
     content::DownloadManager* manager, content::DownloadItem* item) {
   OnDownloadUpdated(manager, item);
 }
 
 void DownloadHistory::OnDownloadRemoved(
     content::DownloadManager* manager, content::DownloadItem* item) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DownloadHistoryData* data = DownloadHistoryData::Get(item);
   if (data->state() != DownloadHistoryData::PERSISTED) {
     if (data->state() == DownloadHistoryData::PERSISTING) {
       // ScheduleRemoveDownload will be called when history_ calls ItemAdded().
       removed_while_adding_.insert(item->GetId());
     }
     return;
   }
   ScheduleRemoveDownload(item->GetId());
   // This is important: another OnDownloadRemoved() handler could do something
   // that synchronously fires an OnDownloadUpdated().
   data->SetState(DownloadHistoryData::NOT_PERSISTED);
   // ItemAdded increments history_size_ only if the item wasn't
   // removed_while_adding_, so the next line does not belong in
   // ScheduleRemoveDownload().
   --history_size_;
 }
 
 void DownloadHistory::ScheduleRemoveDownload(uint32 download_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // For database efficiency, batch removals together if they happen all at
   // once.
   if (removing_ids_.empty()) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadHistory::RemoveDownloadsBatch,
                    weak_ptr_factory_.GetWeakPtr()));
   }
   removing_ids_.insert(download_id);
 }
 
 void DownloadHistory::RemoveDownloadsBatch() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   IdSet remove_ids;
   removing_ids_.swap(remove_ids);
   history_->RemoveDownloads(remove_ids);
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadsRemoved(remove_ids));
 }