Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/api/downloads/downloads_api.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/extensions/api/downloads/downloads_api.h"
 
 #include <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
@@ skipping 316 matching lines @@
   im->LoadIcon(path,
                icon_size,
                base::Bind(&DownloadFileIconExtractorImpl::OnIconLoadComplete,
                           base::Unretained(this), scale, callback),
                &cancelable_task_tracker_);
   return true;
 }
 
 void DownloadFileIconExtractorImpl::OnIconLoadComplete(
     float scale, const IconURLCallback& callback, gfx::Image* icon) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback.Run(!icon ? std::string() : webui::GetBitmapDataUrl(
       icon->ToImageSkia()->GetRepresentation(scale).sk_bitmap()));
 }
 
 IconLoader::IconSize IconLoaderSizeFromPixelSize(int pixel_size) {
   switch (pixel_size) {
     case 16: return IconLoader::SMALL;
     case 32: return IconLoader::NORMAL;
     default:
       NOTREACHED();
@@ skipping 245 matching lines @@
   explicit ExtensionDownloadsEventRouterData(
       DownloadItem* download_item,
       scoped_ptr<base::DictionaryValue> json_item)
       : updated_(0),
         changed_fired_(0),
         json_(json_item.Pass()),
         creator_conflict_action_(
             downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY),
         determined_conflict_action_(
             downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     download_item->SetUserData(kKey, this);
   }
 
   virtual ~ExtensionDownloadsEventRouterData() {
     if (updated_ > 0) {
       UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged",
                                (changed_fired_ * 100 / updated_));
     }
   }
 
   const base::DictionaryValue& json() const { return *json_.get(); }
   void set_json(scoped_ptr<base::DictionaryValue> json_item) {
     json_ = json_item.Pass();
   }
 
   void OnItemUpdated() { ++updated_; }
   void OnChangedFired() { ++changed_fired_; }
 
   void set_filename_change_callbacks(
       const base::Closure& no_change,
       const ExtensionDownloadsEventRouter::FilenameChangedCallback& change) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     filename_no_change_ = no_change;
     filename_change_ = change;
     determined_filename_ = creator_suggested_filename_;
     determined_conflict_action_ = creator_conflict_action_;
     // determiner_.install_time should default to 0 so that creator suggestions
     // should be lower priority than any actual onDeterminingFilename listeners.
   }
 
   void ClearPendingDeterminers() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     determined_filename_.clear();
     determined_conflict_action_ =
       downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY;
     determiner_ = DeterminerInfo();
     filename_no_change_ = base::Closure();
     filename_change_ = ExtensionDownloadsEventRouter::FilenameChangedCallback();
     weak_ptr_factory_.reset();
     determiners_.clear();
   }
 
   void DeterminerRemoved(const std::string& extension_id) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     for (DeterminerInfoVector::iterator iter = determiners_.begin();
          iter != determiners_.end();) {
       if (iter->extension_id == extension_id) {
         iter = determiners_.erase(iter);
       } else {
         ++iter;
       }
     }
     // If we just removed the last unreported determiner, then we need to call a
     // callback.
     CheckAllDeterminersCalled();
   }
 
   void AddPendingDeterminer(const std::string& extension_id,
                             const base::Time& installed) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     for (size_t index = 0; index < determiners_.size(); ++index) {
       if (determiners_[index].extension_id == extension_id) {
         DCHECK(false) << extension_id;
         return;
       }
     }
     determiners_.push_back(DeterminerInfo(extension_id, installed));
   }
 
   bool DeterminerAlreadyReported(const std::string& extension_id) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     for (size_t index = 0; index < determiners_.size(); ++index) {
       if (determiners_[index].extension_id == extension_id) {
         return determiners_[index].reported;
       }
     }
     return false;
   }
 
   void CreatorSuggestedFilename(
       const base::FilePath& filename,
       downloads::FilenameConflictAction conflict_action) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     creator_suggested_filename_ = filename;
     creator_conflict_action_ = conflict_action;
   }
 
   base::FilePath creator_suggested_filename() const {
     return creator_suggested_filename_;
   }
 
   downloads::FilenameConflictAction
   creator_conflict_action() const {
     return creator_conflict_action_;
   }
 
   void ResetCreatorSuggestion() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     creator_suggested_filename_.clear();
     creator_conflict_action_ =
       downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY;
   }
 
   // Returns false if this |extension_id| was not expected or if this
   // |extension_id| has already reported. The caller is responsible for
   // validating |filename|.
   bool DeterminerCallback(
       Profile* profile,
       const std::string& extension_id,
       const base::FilePath& filename,
       downloads::FilenameConflictAction conflict_action) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     bool found_info = false;
     for (size_t index = 0; index < determiners_.size(); ++index) {
       if (determiners_[index].extension_id == extension_id) {
         found_info = true;
         if (determiners_[index].reported)
           return false;
         determiners_[index].reported = true;
         // Do not use filename if another determiner has already overridden the
         // filename and they take precedence. Extensions that were installed
         // later take precedence over previous extensions.
@@ skipping 310 matching lines @@
   RecordDownloadSource(DOWNLOAD_INITIATED_BY_EXTENSION);
   RecordApiFunctions(DOWNLOADS_FUNCTION_DOWNLOAD);
   return true;
 }
 
 void DownloadsDownloadFunction::OnStarted(
     const base::FilePath& creator_suggested_filename,
     downloads::FilenameConflictAction creator_conflict_action,
     DownloadItem* item,
     content::DownloadInterruptReason interrupt_reason) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << __FUNCTION__ << " " << item << " " << interrupt_reason;
   if (item) {
     DCHECK_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
     SetResult(new base::FundamentalValue(static_cast<int>(item->GetId())));
     if (!creator_suggested_filename.empty()) {
       ExtensionDownloadsEventRouterData* data =
           ExtensionDownloadsEventRouterData::Get(item);
       if (!data) {
         data = new ExtensionDownloadsEventRouterData(
             item,
@@ skipping 162 matching lines @@
       Fault(download_item->GetFileExternallyRemoved(),
             errors::kFileAlreadyDeleted, &error_))
     return false;
   RecordApiFunctions(DOWNLOADS_FUNCTION_REMOVE_FILE);
   download_item->DeleteFile(
       base::Bind(&DownloadsRemoveFileFunction::Done, this));
   return true;
 }
 
 void DownloadsRemoveFileFunction::Done(bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!success) {
     error_ = errors::kFileNotRemoved;
   }
   SendResponse(error_.empty());
 }
 
 DownloadsAcceptDangerFunction::DownloadsAcceptDangerFunction() {}
 
 DownloadsAcceptDangerFunction::~DownloadsAcceptDangerFunction() {}
 
@@ skipping 46 matching lines @@
       base::Bind(&DownloadsAcceptDangerFunction::DangerPromptCallback,
                  this, download_id));
   // DownloadDangerPrompt deletes itself
   if (on_prompt_created_ && !on_prompt_created_->is_null())
     on_prompt_created_->Run(prompt);
   SendResponse(error_.empty());
 }
 
 void DownloadsAcceptDangerFunction::DangerPromptCallback(
     int download_id, DownloadDangerPrompt::Action action) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DownloadItem* download_item =
       GetDownload(GetProfile(), include_incognito(), download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->GetState() != DownloadItem::IN_PROGRESS,
             errors::kNotInProgress, &error_))
     return;
   switch (action) {
     case DownloadDangerPrompt::ACCEPT:
       download_item->ValidateDangerousDownload();
       break;
@@ skipping 188 matching lines @@
   }
   EXTENSION_FUNCTION_VALIDATE(icon_extractor_->ExtractIconURLForPath(
       download_item->GetTargetFilePath(),
       scale,
       IconLoaderSizeFromPixelSize(icon_size),
       base::Bind(&DownloadsGetFileIconFunction::OnIconURLExtracted, this)));
   return true;
 }
 
 void DownloadsGetFileIconFunction::OnIconURLExtracted(const std::string& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (Fault(url.empty(), errors::kIconNotFound, &error_)) {
     SendResponse(false);
     return;
   }
   RecordApiFunctions(DOWNLOADS_FUNCTION_GET_FILE_ICON);
   SetResult(new base::StringValue(url));
   SendResponse(true);
 }
 
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(
     Profile* profile,
     DownloadManager* manager)
     : profile_(profile),
       notifier_(manager, this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile_);
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<Profile>(profile_));
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
       event_router();
   if (router)
     router->RegisterObserver(this,
                              downloads::OnDeterminingFilename::kEventName);
 }
 
 ExtensionDownloadsEventRouter::~ExtensionDownloadsEventRouter() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
       event_router();
   if (router)
     router->UnregisterObserver(this);
 }
 
 void ExtensionDownloadsEventRouter::SetShelfEnabled(
     const extensions::Extension* extension, bool enabled) {
   std::set<const extensions::Extension*>::iterator iter =
     shelf_disabling_extensions_.find(extension);
@@ skipping 32 matching lines @@
 // When the last extension's event handler returns, EDERD calls one of the two
 // callbacks that CVRBD passed to ODF, allowing CDMD to complete the filename
 // determination process. If multiple extensions wish to override the filename,
 // then the extension that was last installed wins.
 
 void ExtensionDownloadsEventRouter::OnDeterminingFilename(
     DownloadItem* item,
     const base::FilePath& suggested_path,
     const base::Closure& no_change,
     const FilenameChangedCallback& change) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionDownloadsEventRouterData* data =
       ExtensionDownloadsEventRouterData::Get(item);
   if (!data) {
     no_change.Run();
     return;
   }
   data->ClearPendingDeterminers();
   data->set_filename_change_callbacks(no_change, change);
   bool any_determiners = false;
   base::DictionaryValue* json = DownloadItemToJSON(
@@ skipping 63 matching lines @@
 }
 
 bool ExtensionDownloadsEventRouter::DetermineFilename(
     Profile* profile,
     bool include_incognito,
     const std::string& ext_id,
     int download_id,
     const base::FilePath& const_filename,
     downloads::FilenameConflictAction conflict_action,
     std::string* error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DownloadItem* item = GetDownload(profile, include_incognito, download_id);
   ExtensionDownloadsEventRouterData* data =
       item ? ExtensionDownloadsEventRouterData::Get(item) : NULL;
   // maxListeners=1 in downloads.idl and suggestCallback in
   // downloads_custom_bindings.js should prevent duplicate DeterminerCallback
   // calls from the same renderer, but an extension may have more than one
   // renderer, so don't DCHECK(!reported).
   if (InvalidId(item, error) ||
       Fault(item->GetState() != DownloadItem::IN_PROGRESS,
             errors::kNotInProgress, error) ||
@@ skipping 15 matching lines @@
                 profile, ext_id, filename, conflict_action),
             errors::kUnexpectedDeterminer, error) ||
       Fault((!const_filename.empty() && !valid_filename),
             errors::kInvalidFilename, error))
     return false;
   return true;
 }
 
 void ExtensionDownloadsEventRouter::OnListenerRemoved(
     const extensions::EventListenerInfo& details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DownloadManager* manager = notifier_.GetManager();
   if (!manager)
     return;
   bool determiner_removed = (
       details.event_name == downloads::OnDeterminingFilename::kEventName);
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
       event_router();
   bool any_listeners =
     router->HasEventListener(downloads::OnChanged::kEventName) ||
     router->HasEventListener(downloads::OnDeterminingFilename::kEventName);
@@ skipping 21 matching lines @@
       ExtensionDownloadsEventRouterData::Remove(*iter);
     }
   }
 }
 
 // That's all the methods that have to do with filename determination. The rest
 // have to do with the other, less special events.
 
 void ExtensionDownloadsEventRouter::OnDownloadCreated(
     DownloadManager* manager, DownloadItem* download_item) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (download_item->IsTemporary())
     return;
 
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
       event_router();
   // Avoid allocating a bunch of memory in DownloadItemToJSON if it isn't going
   // to be used.
   if (!router ||
       (!router->HasEventListener(downloads::OnCreated::kEventName) &&
        !router->HasEventListener(downloads::OnChanged::kEventName) &&
@@ skipping 10 matching lines @@
   if (!ExtensionDownloadsEventRouterData::Get(download_item) &&
       (router->HasEventListener(downloads::OnChanged::kEventName) ||
        router->HasEventListener(
            downloads::OnDeterminingFilename::kEventName))) {
     new ExtensionDownloadsEventRouterData(download_item, json_item.Pass());
   }
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   extensions::EventRouter* router = extensions::ExtensionSystem::Get(profile_)->
       event_router();
   ExtensionDownloadsEventRouterData* data =
     ExtensionDownloadsEventRouterData::Get(download_item);
   if (download_item->IsTemporary() ||
       !router->HasEventListener(downloads::OnChanged::kEventName)) {
     return;
   }
   if (!data) {
     // The download_item probably transitioned from temporary to not temporary,
@@ skipping 49 matching lines @@
                   true,
                   extensions::Event::WillDispatchCallback(),
                   delta.release());
     data->OnChangedFired();
   }
   data->set_json(new_json.Pass());
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* download_item) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (download_item->IsTemporary())
     return;
   DispatchEvent(downloads::OnErased::kEventName,
                 true,
                 extensions::Event::WillDispatchCallback(),
                 new base::FundamentalValue(
                     static_cast<int>(download_item->GetId())));
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     const std::string& event_name,
     bool include_incognito,
     const extensions::Event::WillDispatchCallback& will_dispatch_callback,
     base::Value* arg) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!extensions::ExtensionSystem::Get(profile_)->event_router())
     return;
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   std::string json_args;
   base::JSONWriter::Write(args.get(), &json_args);
   scoped_ptr<extensions::Event> event(new extensions::Event(
       event_name, args.Pass()));
   // The downloads system wants to share on-record events with off-record
   // extension renderers even in incognito_split_mode because that's how
@@ skipping 13 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
       content_source,
       content::Details<std::string>(&json_args));
 }
 
 void ExtensionDownloadsEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
       extensions::UnloadedExtensionInfo* unloaded =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       std::set<const extensions::Extension*>::iterator iter =
         shelf_disabling_extensions_.find(unloaded->extension);
       if (iter != shelf_disabling_extensions_.end())
         shelf_disabling_extensions_.erase(iter);
       break;
     }
   }
 }