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

chrome/browser/profile_resetter/automatic_profile_resetter.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/profile_resetter/automatic_profile_resetter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 200 matching lines @@
   void IncludeMementoValues() {
     data_->SetString(kMementoValueInPrefsKey, memento_in_prefs_.ReadValue());
     data_->SetString(kMementoValueInLocalStateKey,
                      memento_in_local_state_.ReadValue());
     memento_in_file_.ReadValue(base::Bind(
         &InputBuilder::IncludeFileBasedMementoCallback, AsWeakPtr()));
   }
 
   // Called back by |memento_in_file_| once the |memento_value| has been read.
   void IncludeFileBasedMementoCallback(const std::string& memento_value) {
-    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     data_->SetString(kMementoValueInFileKey, memento_value);
     // As an asynchronous task, we need to take care of posting the next task.
     PostNextTask();
   }
 
   // Task that includes all user (i.e. profile-specific) preferences, along with
   // information about whether the value is coming from the 'user' PrefStore.
   // This is the most expensive operation, so it is itself split into two parts.
   void IncludeUserPreferences() {
     PrefService* prefs = profile_->GetPrefs();
@@ skipping 143 matching lines @@
       template_url_service_ready_(false),
       has_already_dismissed_prompt_(false),
       should_show_reset_banner_(false),
       weak_ptr_factory_(this) {
   DCHECK(profile_);
 }
 
 AutomaticProfileResetter::~AutomaticProfileResetter() {}
 
 void AutomaticProfileResetter::Initialize() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   if (!ShouldPerformDryRun() && !ShouldPerformLiveRun()) {
     state_ = STATE_DISABLED;
     return;
   }
 
   if (!GetProgramAndHashSeedOverridesFromExperiment(&program_, &hash_seed_)) {
     ui::ResourceBundle& resources(ui::ResourceBundle::GetSharedInstance());
     if (ShouldPerformLiveRun()) {
@@ skipping 12 matching lines @@
   delegate_.reset(new AutomaticProfileResetterDelegateImpl(
       profile_, ProfileResetter::ALL));
   task_runner_for_waiting_ =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::UI);
 
   state_ = STATE_INITIALIZED;
 }
 
 void AutomaticProfileResetter::Activate() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(state_ == STATE_INITIALIZED || state_ == STATE_DISABLED);
 
   if (state_ == STATE_INITIALIZED) {
     if (!program_.empty()) {
       // Some steps in the flow (e.g. loaded modules, file-based memento) are
       // IO-intensive, so defer execution until some time later.
       task_runner_for_waiting_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&AutomaticProfileResetter::PrepareEvaluationFlow,
                      weak_ptr_factory_.GetWeakPtr()),
           base::TimeDelta::FromSeconds(kEvaluationFlowDelayInSeconds));
     } else {
       // Terminate early if there is no program included (nor set by tests).
       state_ = STATE_DISABLED;
     }
   }
 }
 
 void AutomaticProfileResetter::TriggerProfileReset(bool send_feedback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_HAS_SHOWN_BUBBLE);
 
   state_ = STATE_PERFORMING_RESET;
   should_show_reset_banner_ = false;
 
   ReportPromptResult(PROMPT_ACTION_RESET);
   delegate_->TriggerProfileSettingsReset(
       send_feedback,
       base::Bind(&AutomaticProfileResetter::OnProfileSettingsResetCompleted,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void AutomaticProfileResetter::SkipProfileReset() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_HAS_SHOWN_BUBBLE);
 
   should_show_reset_banner_ = false;
 
   ReportPromptResult(PROMPT_ACTION_NO_RESET);
   delegate_->DismissPrompt();
   FinishResetPromptFlow();
 }
 
 bool AutomaticProfileResetter::IsResetPromptFlowActive() const {
   return state_ == STATE_HAS_TRIGGERED_PROMPT ||
       state_ == STATE_HAS_SHOWN_BUBBLE;
 }
 
 bool AutomaticProfileResetter::ShouldShowResetBanner() const {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return should_show_reset_banner_ && ShouldPerformLiveRun();
 }
 
 void AutomaticProfileResetter::NotifyDidShowResetBubble() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_HAS_TRIGGERED_PROMPT);
 
   state_ = STATE_HAS_SHOWN_BUBBLE;
 
   PersistMementos();
   ReportPromptResult(PROMPT_SHOWN_BUBBLE);
 }
 
 void AutomaticProfileResetter::NotifyDidOpenWebUIResetDialog() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // This notification is invoked unconditionally by the WebUI, only care about
   // it when the prompt flow is currently active (and not yet resetting).
   if (state_ == STATE_HAS_TRIGGERED_PROMPT ||
       state_ == STATE_HAS_SHOWN_BUBBLE) {
     has_already_dismissed_prompt_ = true;
     delegate_->DismissPrompt();
   }
 }
 
 void AutomaticProfileResetter::NotifyDidCloseWebUIResetDialog(
     bool performed_reset) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // This notification is invoked unconditionally by the WebUI, only care about
   // it when the prompt flow is currently active (and not yet resetting).
   if (state_ == STATE_HAS_TRIGGERED_PROMPT ||
       state_ == STATE_HAS_SHOWN_BUBBLE) {
     if (!has_already_dismissed_prompt_)
       delegate_->DismissPrompt();
     if (state_ == STATE_HAS_TRIGGERED_PROMPT) {
       PersistMementos();
       ReportPromptResult(performed_reset ?
           PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_RESET :
           PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_NO_RESET);
     } else {  // if (state_ == STATE_HAS_SHOWN_PROMPT)
       ReportPromptResult(performed_reset ?
           PROMPT_FOLLOWED_BY_WEBUI_RESET :
           PROMPT_FOLLOWED_BY_WEBUI_NO_RESET);
     }
     FinishResetPromptFlow();
   }
 }
 
 void AutomaticProfileResetter::NotifyDidCloseWebUIResetBanner() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   should_show_reset_banner_ = false;
 }
 
 void AutomaticProfileResetter::SetProgramForTesting(
     const std::string& program) {
   program_ = program;
 }
 
 void AutomaticProfileResetter::SetHashSeedForTesting(
     const std::string& hash_key) {
   hash_seed_ = hash_key;
 }
 
 void AutomaticProfileResetter::SetDelegateForTesting(
     scoped_ptr<AutomaticProfileResetterDelegate> delegate) {
   delegate_ = delegate.Pass();
 }
 
 void AutomaticProfileResetter::SetTaskRunnerForWaitingForTesting(
     const scoped_refptr<base::TaskRunner>& task_runner) {
   task_runner_for_waiting_ = task_runner;
 }
 
 void AutomaticProfileResetter::Shutdown() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // We better not do anything substantial at this point. The metrics service
   // has already been shut down; and local state has already been commited to
   // file (in the regular fashion) for the last time.
 
   state_ = STATE_DISABLED;
 
   weak_ptr_factory_.InvalidateWeakPtrs();
   delegate_.reset();
 }
 
 void AutomaticProfileResetter::PrepareEvaluationFlow() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_INITIALIZED);
 
   state_ = STATE_WAITING_ON_DEPENDENCIES;
 
   delegate_->RequestCallbackWhenTemplateURLServiceIsLoaded(
       base::Bind(&AutomaticProfileResetter::OnTemplateURLServiceIsLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
   delegate_->RequestCallbackWhenLoadedModulesAreEnumerated(
       base::Bind(&AutomaticProfileResetter::OnLoadedModulesAreEnumerated,
                  weak_ptr_factory_.GetWeakPtr()));
   delegate_->LoadTemplateURLServiceIfNeeded();
   delegate_->EnumerateLoadedModulesIfNeeded();
 }
 
 void AutomaticProfileResetter::OnTemplateURLServiceIsLoaded() {
   template_url_service_ready_ = true;
   OnDependencyIsReady();
 }
 
 void AutomaticProfileResetter::OnLoadedModulesAreEnumerated() {
   enumeration_of_loaded_modules_ready_ = true;
   OnDependencyIsReady();
 }
 
 void AutomaticProfileResetter::OnDependencyIsReady() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_WAITING_ON_DEPENDENCIES);
 
   if (template_url_service_ready_ && enumeration_of_loaded_modules_ready_) {
     state_ = STATE_READY;
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
         base::Bind(&AutomaticProfileResetter::BeginEvaluationFlow,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void AutomaticProfileResetter::BeginEvaluationFlow() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_READY);
   DCHECK(!program_.empty());
   DCHECK(!input_builder_);
 
   state_ = STATE_EVALUATING_CONDITIONS;
 
   input_builder_.reset(new InputBuilder(profile_, delegate_.get()));
   input_builder_->BuildEvaluatorProgramInput(
       base::Bind(&AutomaticProfileResetter::ContinueWithEvaluationFlow,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void AutomaticProfileResetter::ContinueWithEvaluationFlow(
     scoped_ptr<base::DictionaryValue> program_input) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS);
 
   input_builder_.reset();
 
   base::SequencedWorkerPool* blocking_pool =
       content::BrowserThread::GetBlockingPool();
   scoped_refptr<base::TaskRunner> task_runner =
       blocking_pool->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
@@ skipping 56 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.SatisfiedCriteriaMask",
                             satisfied_criteria_mask,
                             kSatisfiedCriteriaMaskMaximumValue);
   UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.CombinedStatusMask",
                             combined_status_mask,
                             kCombinedStatusMaskMaximumValue);
 }
 
 void AutomaticProfileResetter::FinishEvaluationFlow(
     scoped_ptr<EvaluationResults> results) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS);
 
   ReportStatistics(results->satisfied_criteria_mask,
                    results->combined_status_mask);
 
   if (results->should_prompt)
     should_show_reset_banner_ = true;
 
   if (results->should_prompt && !results->had_prompted_already) {
     evaluation_results_ = results.Pass();
     BeginResetPromptFlow();
   } else {
     state_ = STATE_DONE;
   }
 }
 
 void AutomaticProfileResetter::BeginResetPromptFlow() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS);
 
   state_ = STATE_HAS_TRIGGERED_PROMPT;
 
   if (ShouldPerformLiveRun() && delegate_->TriggerPrompt()) {
     // Start fetching the brandcoded default settings speculatively in the
     // background, so as to reduce waiting time if the user chooses to go
     // through with the reset.
     delegate_->FetchBrandcodedDefaultSettingsIfNeeded();
   } else {
     PersistMementos();
     ReportPromptResult(PROMPT_NOT_TRIGGERED);
     FinishResetPromptFlow();
   }
 }
 
 void AutomaticProfileResetter::OnProfileSettingsResetCompleted() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, STATE_PERFORMING_RESET);
 
   delegate_->DismissPrompt();
   FinishResetPromptFlow();
 }
 
 void AutomaticProfileResetter::ReportPromptResult(PromptResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "AutomaticProfileReset.PromptResult", result, PROMPT_RESULT_MAX);
 }
 
 void AutomaticProfileResetter::PersistMementos() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(state_ == STATE_HAS_TRIGGERED_PROMPT ||
          state_ == STATE_HAS_SHOWN_BUBBLE);
   DCHECK(evaluation_results_);
 
   PreferenceHostedPromptMemento memento_in_prefs(profile_);
   LocalStateHostedPromptMemento memento_in_local_state(profile_);
   FileHostedPromptMemento memento_in_file(profile_);
 
   memento_in_prefs.StoreValue(evaluation_results_->memento_value_in_prefs);
   memento_in_local_state.StoreValue(
       evaluation_results_->memento_value_in_local_state);
   memento_in_file.StoreValue(evaluation_results_->memento_value_in_file);
 
   evaluation_results_.reset();
 }
 
 void AutomaticProfileResetter::FinishResetPromptFlow() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(state_ == STATE_HAS_TRIGGERED_PROMPT ||
          state_ == STATE_HAS_SHOWN_BUBBLE ||
          state_ == STATE_PERFORMING_RESET);
   DCHECK(!evaluation_results_);
 
   state_ = STATE_DONE;
 }