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

chrome/browser/download/download_target_determiner.cc

 // Copyright 2013 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_target_determiner.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 82 matching lines @@
       virtual_path_(initial_virtual_path),
       is_filetype_handled_safely_(false),
       download_(download),
       is_resumption_(download_->GetLastReason() !=
                          content::DOWNLOAD_INTERRUPT_REASON_NONE &&
                      !initial_virtual_path.empty()),
       download_prefs_(download_prefs),
       delegate_(delegate),
       completion_callback_(callback),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_);
   DCHECK(delegate);
   download_->AddObserver(this);
 
   DoLoop();
 }
 
 DownloadTargetDeterminer::~DownloadTargetDeterminer() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_);
   DCHECK(completion_callback_.is_null());
   download_->RemoveObserver(this);
 }
 
 void DownloadTargetDeterminer::DoLoop() {
   Result result = CONTINUE;
   do {
     State current_state = next_state_;
     next_state_ = STATE_NONE;
@@ skipping 40 matching lines @@
   // Note that if a callback completes synchronously, the handler will still
   // return QUIT_DOLOOP. In this case, an inner DoLoop() may complete the target
   // determination and delete |this|.
 
   if (result == COMPLETE)
     ScheduleCallbackAndDeleteSelf();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoGenerateTargetPath() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(local_path_.empty());
   DCHECK(!should_prompt_);
   DCHECK(!should_notify_extensions_);
   DCHECK_EQ(DownloadPathReservationTracker::OVERWRITE, conflict_action_);
   bool is_forced_path = !download_->GetForcedFilePath().empty();
 
   next_state_ = STATE_NOTIFY_EXTENSIONS;
 
   if (!virtual_path_.empty() && HasPromptedForPath() && !is_forced_path) {
     // The download is being resumed and the user has already been prompted for
@@ skipping 49 matching lines @@
   //
   // A virtual path is determined for DOA downloads for display purposes. This
   // is why this check is performed here instead of at the start.
   if (download_->GetState() != DownloadItem::IN_PROGRESS)
     return COMPLETE;
   return CONTINUE;
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoNotifyExtensions() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
 
   next_state_ = STATE_RESERVE_VIRTUAL_PATH;
 
   if (!should_notify_extensions_)
     return CONTINUE;
 
   delegate_->NotifyExtensions(download_, virtual_path_,
       base::Bind(&DownloadTargetDeterminer::NotifyExtensionsDone,
                  weak_ptr_factory_.GetWeakPtr()));
   return QUIT_DOLOOP;
 }
 
 void DownloadTargetDeterminer::NotifyExtensionsDone(
     const base::FilePath& suggested_path,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "Extension suggested path: " << suggested_path.AsUTF8Unsafe();
 
   // Extensions should not call back here more than once.
   DCHECK_EQ(STATE_RESERVE_VIRTUAL_PATH, next_state_);
 
   if (!suggested_path.empty()) {
     // If an extension overrides the filename, then the target directory will be
     // forced to download_prefs_->DownloadPath() since extensions cannot place
     // downloaded files anywhere except there. This prevents subdirectories from
     // accumulating: if an extension is allowed to say that a file should go in
@@ skipping 11 matching lines @@
   }
   // An extension may set conflictAction without setting filename.
   if (conflict_action != DownloadPathReservationTracker::UNIQUIFY)
     conflict_action_ = conflict_action;
 
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoReserveVirtualPath() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
 
   next_state_ = STATE_PROMPT_USER_FOR_DOWNLOAD_PATH;
 
   delegate_->ReserveVirtualPath(
       download_, virtual_path_, create_target_directory_, conflict_action_,
       base::Bind(&DownloadTargetDeterminer::ReserveVirtualPathDone,
                  weak_ptr_factory_.GetWeakPtr()));
   return QUIT_DOLOOP;
 }
 
 void DownloadTargetDeterminer::ReserveVirtualPathDone(
     const base::FilePath& path, bool verified) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "Reserved path: " << path.AsUTF8Unsafe()
             << " Verified:" << verified;
   DCHECK_EQ(STATE_PROMPT_USER_FOR_DOWNLOAD_PATH, next_state_);
 
   should_prompt_ = (should_prompt_ || !verified);
   virtual_path_ = path;
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoPromptUserForDownloadPath() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
 
   next_state_ = STATE_DETERMINE_LOCAL_PATH;
 
   if (should_prompt_) {
     delegate_->PromptUserForDownloadPath(
         download_,
         virtual_path_,
         base::Bind(&DownloadTargetDeterminer::PromptUserForDownloadPathDone,
                    weak_ptr_factory_.GetWeakPtr()));
     return QUIT_DOLOOP;
   }
   return CONTINUE;
 }
 
 void DownloadTargetDeterminer::PromptUserForDownloadPathDone(
     const base::FilePath& virtual_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "User selected path:" << virtual_path.AsUTF8Unsafe();
   if (virtual_path.empty()) {
     CancelOnFailureAndDeleteSelf();
     return;
   }
   DCHECK_EQ(STATE_DETERMINE_LOCAL_PATH, next_state_);
 
   virtual_path_ = virtual_path;
   download_prefs_->SetSaveFilePath(virtual_path_.DirName());
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineLocalPath() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
   DCHECK(local_path_.empty());
 
   next_state_ = STATE_DETERMINE_MIME_TYPE;
 
   delegate_->DetermineLocalPath(
       download_,
       virtual_path_,
       base::Bind(&DownloadTargetDeterminer::DetermineLocalPathDone,
                  weak_ptr_factory_.GetWeakPtr()));
   return QUIT_DOLOOP;
 }
 
 void DownloadTargetDeterminer::DetermineLocalPathDone(
     const base::FilePath& local_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "Local path: " << local_path.AsUTF8Unsafe();
   if (local_path.empty()) {
     // Path subsitution failed.
     CancelOnFailureAndDeleteSelf();
     return;
   }
   DCHECK_EQ(STATE_DETERMINE_MIME_TYPE, next_state_);
 
   local_path_ = local_path;
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineMimeType() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
   DCHECK(!local_path_.empty());
   DCHECK(mime_type_.empty());
 
   next_state_ = STATE_DETERMINE_IF_HANDLED_SAFELY_BY_BROWSER;
 
   if (virtual_path_ == local_path_) {
     delegate_->GetFileMimeType(
         local_path_,
         base::Bind(&DownloadTargetDeterminer::DetermineMimeTypeDone,
                    weak_ptr_factory_.GetWeakPtr()));
     return QUIT_DOLOOP;
   }
   return CONTINUE;
 }
 
 void DownloadTargetDeterminer::DetermineMimeTypeDone(
     const std::string& mime_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "MIME type: " << mime_type;
   DCHECK_EQ(STATE_DETERMINE_IF_HANDLED_SAFELY_BY_BROWSER, next_state_);
 
   mime_type_ = mime_type;
   DoLoop();
 }
 
 #if defined(ENABLE_PLUGINS)
 // The code below is used by DoDetermineIfHandledSafely to determine if the
 // file type is handled by a sandboxed plugin.
 namespace {
 
 void InvokeClosureAfterGetPluginCallback(
     const base::Closure& closure,
     const std::vector<content::WebPluginInfo>& unused) {
   closure.Run();
 }
 
 enum ActionOnStalePluginList {
   RETRY_IF_STALE_PLUGIN_LIST,
   IGNORE_IF_STALE_PLUGIN_LIST
 };
 
 void IsHandledBySafePlugin(content::ResourceContext* resource_context,
                            const GURL& url,
                            const std::string& mime_type,
                            ActionOnStalePluginList stale_plugin_action,
                            const base::Callback<void(bool)>& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!mime_type.empty());
   using content::WebPluginInfo;
 
   std::string actual_mime_type;
   bool is_stale = false;
   WebPluginInfo plugin_info;
 
   content::PluginService* plugin_service =
       content::PluginService::GetInstance();
   bool plugin_found = plugin_service->GetPluginInfo(-1, -1, resource_context,
@@ skipping 24 matching lines @@
        plugin_info.type == WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(callback, is_handled_safely));
 }
 
 }  // namespace
 #endif  // defined(ENABLE_PLUGINS)
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineIfHandledSafely() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
   DCHECK(!local_path_.empty());
   DCHECK(!is_filetype_handled_safely_);
 
   next_state_ = STATE_DETERMINE_IF_ADOBE_READER_UP_TO_DATE;
 
   if (mime_type_.empty())
     return CONTINUE;
 
   if (net::IsSupportedMimeType(mime_type_)) {
@@ skipping 15 matching lines @@
                      weak_ptr_factory_.GetWeakPtr())));
   return QUIT_DOLOOP;
 #else
   return CONTINUE;
 #endif
 }
 
 #if defined(ENABLE_PLUGINS)
 void DownloadTargetDeterminer::DetermineIfHandledSafelyDone(
     bool is_handled_safely) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "Is file type handled safely: " << is_filetype_handled_safely_;
   DCHECK_EQ(STATE_DETERMINE_IF_ADOBE_READER_UP_TO_DATE, next_state_);
   is_filetype_handled_safely_ = is_handled_safely;
   DoLoop();
 }
 #endif
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineIfAdobeReaderUpToDate() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   next_state_ = STATE_CHECK_DOWNLOAD_URL;
 
 #if defined(OS_WIN)
   if (!local_path_.MatchesExtension(FILE_PATH_LITERAL(".pdf")))
     return CONTINUE;
   if (!IsAdobeReaderDefaultPDFViewer()) {
     g_is_adobe_reader_up_to_date_ = false;
     return CONTINUE;
   }
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&::IsAdobeReaderUpToDate),
       base::Bind(&DownloadTargetDeterminer::DetermineIfAdobeReaderUpToDateDone,
                  weak_ptr_factory_.GetWeakPtr()));
   return QUIT_DOLOOP;
 #else
   return CONTINUE;
 #endif
 }
 
 #if defined(OS_WIN)
 void DownloadTargetDeterminer::DetermineIfAdobeReaderUpToDateDone(
     bool adobe_reader_up_to_date) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "Is Adobe Reader Up To Date: " << adobe_reader_up_to_date;
   DCHECK_EQ(STATE_CHECK_DOWNLOAD_URL, next_state_);
   g_is_adobe_reader_up_to_date_ = adobe_reader_up_to_date;
   DoLoop();
 }
 #endif
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoCheckDownloadUrl() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
   next_state_ = STATE_CHECK_VISITED_REFERRER_BEFORE;
   delegate_->CheckDownloadUrl(
       download_,
       virtual_path_,
       base::Bind(&DownloadTargetDeterminer::CheckDownloadUrlDone,
                  weak_ptr_factory_.GetWeakPtr()));
   return QUIT_DOLOOP;
 }
 
 void DownloadTargetDeterminer::CheckDownloadUrlDone(
     content::DownloadDangerType danger_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << "URL Check Result:" << danger_type;
   DCHECK_EQ(STATE_CHECK_VISITED_REFERRER_BEFORE, next_state_);
   danger_type_ = danger_type;
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoCheckVisitedReferrerBefore() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   next_state_ = STATE_DETERMINE_INTERMEDIATE_PATH;
 
   // Checking if there are prior visits to the referrer is only necessary if the
   // danger level of the download depends on the file type.
   if (danger_type_ != content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS &&
       danger_type_ != content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)
     return CONTINUE;
 
   // Assume that:
@@ skipping 27 matching lines @@
     // is invalid, then assume the referrer has not been visited before.
     is_dangerous_file_ = true;
     if (danger_type_ == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
       danger_type_ = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
   }
   return CONTINUE;
 }
 
 void DownloadTargetDeterminer::CheckVisitedReferrerBeforeDone(
     bool visited_referrer_before) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(STATE_DETERMINE_INTERMEDIATE_PATH, next_state_);
   if (IsDangerousFile(visited_referrer_before ? VISITED_REFERRER
                                               : NO_VISITS_TO_REFERRER)) {
     is_dangerous_file_ = true;
     if (danger_type_ == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
       danger_type_ = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
   }
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineIntermediatePath() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
   DCHECK(!local_path_.empty());
   DCHECK(intermediate_path_.empty());
   DCHECK(!virtual_path_.MatchesExtension(kCrdownloadSuffix));
   DCHECK(!local_path_.MatchesExtension(kCrdownloadSuffix));
 
   next_state_ = STATE_NONE;
 
   // Note that the intermediate filename is always uniquified (i.e. if a file by
   // the same name exists, it is never overwritten). Therefore the code below
@@ skipping 151 matching lines @@
   // conflict.
   return false;
 }
 
 bool DownloadTargetDeterminer::HasPromptedForPath() const {
   return (is_resumption_ && download_->GetTargetDisposition() ==
                                 DownloadItem::TARGET_DISPOSITION_PROMPT);
 }
 
 bool DownloadTargetDeterminer::IsDangerousFile(PriorVisitsToReferrer visits) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // If the user has has been prompted or will be, assume that the user has
   // approved the download. A programmatic download is considered safe unless it
   // contains malware.
   if (HasPromptedForPath() || should_prompt_ ||
       !download_->GetForcedFilePath().empty())
     return false;
 
   const bool is_extension_download =
       download_crx_util::IsExtensionDownload(*download_);
@@ skipping 38 matching lines @@
 
     case download_util::DANGEROUS:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 void DownloadTargetDeterminer::OnDownloadDestroyed(
     DownloadItem* download) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(download_, download);
   CancelOnFailureAndDeleteSelf();
 }
 
 // static
 void DownloadTargetDeterminer::Start(content::DownloadItem* download,
                                      const base::FilePath& initial_virtual_path,
                                      DownloadPrefs* download_prefs,
                                      DownloadTargetDeterminerDelegate* delegate,
                                      const CompletionCallback& callback) {
   // DownloadTargetDeterminer owns itself and will self destruct when the job is
   // complete or the download item is destroyed. The callback is always invoked
   // asynchronously.
   new DownloadTargetDeterminer(download, initial_virtual_path, download_prefs,
                                delegate, callback);
 }
 
 // static
 base::FilePath DownloadTargetDeterminer::GetCrDownloadPath(
     const base::FilePath& suggested_path) {
   return base::FilePath(suggested_path.value() + kCrdownloadSuffix);
 }
 
 #if defined(OS_WIN)
 // static
 bool DownloadTargetDeterminer::IsAdobeReaderUpToDate() {
   return g_is_adobe_reader_up_to_date_;
 }
 #endif