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

chrome/browser/extensions/crx_installer.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/crx_installer.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 459 matching lines @@
     return;
   }
 
   if (!BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&CrxInstaller::CheckImportsAndRequirements, this)))
     NOTREACHED();
 }
 
 void CrxInstaller::CheckImportsAndRequirements() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   if (SharedModuleInfo::ImportsModules(extension())) {
     const std::vector<SharedModuleInfo::ImportInfo>& imports =
         SharedModuleInfo::GetImports(extension());
     std::vector<SharedModuleInfo::ImportInfo>::const_iterator i;
     for (i = imports.begin(); i != imports.end(); ++i) {
       Version version_required(i->minimum_version);
       const Extension* imported_module =
           service->GetExtensionById(i->extension_id, true);
       if (imported_module &&
           !SharedModuleInfo::IsSharedModule(imported_module)) {
         ReportFailureFromUIThread(
             CrxInstallerError(l10n_util::GetStringFUTF16(
                 IDS_EXTENSION_INSTALL_DEPENDENCY_NOT_SHARED_MODULE,
                 base::ASCIIToUTF16(i->extension_id))));
         return;
       }
     }
   }
   installer_.CheckRequirements(base::Bind(&CrxInstaller::OnRequirementsChecked,
                                           this));
 }
 
 void CrxInstaller::OnRequirementsChecked(
     std::vector<std::string> requirement_errors) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
   if (!requirement_errors.empty()) {
     if (error_on_unsupported_requirements_) {
       ReportFailureFromUIThread(CrxInstallerError(
           base::UTF8ToUTF16(JoinString(requirement_errors, ' '))));
       return;
     }
     has_requirement_errors_ = true;
   }
 
   ExtensionSystem::Get(profile())->blacklist()->IsBlacklisted(
       extension()->id(),
       base::Bind(&CrxInstaller::OnBlacklistChecked, this));
 }
 
 void CrxInstaller::OnBlacklistChecked(
     extensions::BlacklistState blacklist_state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
   blacklist_state_ = blacklist_state;
 
   if ((blacklist_state_ == extensions::BLACKLISTED_MALWARE ||
        blacklist_state_ == extensions::BLACKLISTED_UNKNOWN) &&
       !allow_silent_install_) {
     // User tried to install a blacklisted extension. Show an error and
     // refuse to install it.
     ReportFailureFromUIThread(extensions::CrxInstallerError(
         l10n_util::GetStringFUTF16(IDS_EXTENSION_IS_BLACKLISTED,
                                    base::UTF8ToUTF16(extension()->name()))));
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlockCRX",
                               extension()->location(),
                               Manifest::NUM_LOCATIONS);
     return;
   }
 
   // NOTE: extension may still be blacklisted, but we're forced to silently
   // install it. In this case, ExtensionService::OnExtensionInstalled needs to
   // deal with it.
   ConfirmInstall();
 }
 
 void CrxInstaller::ConfirmInstall() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   if (KioskModeInfo::IsKioskOnly(installer_.extension())) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     chromeos::UserManager* user_manager = chromeos::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
@@ skipping 44 matching lines @@
   } else {
     if (!installer_task_runner_->PostTask(
             FROM_HERE,
             base::Bind(&CrxInstaller::CompleteInstall, this)))
       NOTREACHED();
   }
   return;
 }
 
 void CrxInstaller::InstallUIProceed() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   // If update_from_settings_page_ boolean is true, this functions is
   // getting called in response to ExtensionInstallPrompt::ConfirmReEnable()
   // and if it is false, this function is called in response to
   // ExtensionInstallPrompt::ConfirmInstall().
   if (update_from_settings_page_) {
@@ skipping 91 matching lines @@
 void CrxInstaller::ReportFailureFromFileThread(const CrxInstallerError& error) {
   DCHECK(installer_task_runner_->RunsTasksOnCurrentThread());
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&CrxInstaller::ReportFailureFromUIThread, this, error))) {
     NOTREACHED();
   }
 }
 
 void CrxInstaller::ReportFailureFromUIThread(const CrxInstallerError& error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::NotificationService* service =
       content::NotificationService::current();
   service->Notify(chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                   content::Source<CrxInstaller>(this),
                   content::Details<const base::string16>(&error.message()));
 
   // This isn't really necessary, it is only used because unit tests expect to
   // see errors get reported via this interface.
   //
@@ skipping 23 matching lines @@
   if (!BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&CrxInstaller::ReportSuccessFromUIThread, this)))
     NOTREACHED();
 
   // Delete temporary files.
   CleanupTempFiles();
 }
 
 void CrxInstaller::ReportSuccessFromUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!service_weak_.get() || service_weak_->browser_terminating())
     return;
 
   if (!update_from_settings_page_) {
     // If there is a client, tell the client about installation.
     if (client_)
       client_->OnInstallSuccess(extension(), install_icon_.get());
 
     // We update the extension's granted permissions if the user already
@@ skipping 45 matching lines @@
     temp_dir_ = base::FilePath();
   }
 
   if (delete_source_ && !source_file_.value().empty()) {
     extension_file_util::DeleteFile(source_file_, false);
     source_file_ = base::FilePath();
   }
 }
 
 void CrxInstaller::CheckUpdateFromSettingsPage() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   if (off_store_install_allow_reason_ != OffStoreInstallAllowedFromSettingsPage)
     return;
 
   const Extension* installed_extension =
       service->GetInstalledExtension(extension()->id());
   if (installed_extension) {
     // Previous version of the extension exists.
     update_from_settings_page_ = true;
     expected_id_ = installed_extension->id();
     install_source_ = installed_extension->location();
     install_cause_ = extension_misc::INSTALL_CAUSE_UPDATE;
   }
 }
 
 void CrxInstaller::ConfirmReEnable() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
   if (!update_from_settings_page_)
     return;
 
   ExtensionPrefs* prefs = ExtensionPrefs::Get(service->profile());
   if (!prefs->DidExtensionEscalatePermissions(extension()->id()))
     return;
 
   if (client_) {
     AddRef();  // Balanced in InstallUIProceed() and InstallUIAbort().
     client_->ConfirmReEnable(this, extension());
   }
 }
 
 }  // namespace extensions