Integrate UI and reset logic into AutomaticProfileResetter.

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 73 matching lines @@
 const uint32 kCombinedStatusMaskMaximumValue =
     (1u << kCombinedStatusMaskNumberOfBits);
 
 COMPILE_ASSERT(
     arraysize(kSatisfiedCriteriaMaskKeys) == kSatisfiedCriteriaMaskNumberOfBits,
     satisfied_criteria_mask_bits_mismatch);
 COMPILE_ASSERT(
     arraysize(kCombinedStatusMaskKeys) == kCombinedStatusMaskNumberOfBits,
     combined_status_mask_bits_mismatch);
 
-// Enumeration of the possible outcomes of showing the profile reset prompt.
-enum PromptResult {
-  // Prompt was not shown because only a dry-run was performed.
-  PROMPT_NOT_SHOWN,
-  PROMPT_ACTION_RESET,
-  PROMPT_ACTION_NO_RESET,
-  PROMPT_DISMISSED,
-  // Prompt was still shown (not dismissed by the user) when Chrome was closed.
-  PROMPT_IGNORED,
-  PROMPT_RESULT_MAX
-};
-
 // Returns whether or not a dry-run shall be performed.
 bool ShouldPerformDryRun() {
   return StartsWithASCII(
       base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName),
       kAutomaticProfileResetStudyDryRunGroupName, true);
 }
 
 // Returns whether or not a live-run shall be performed.
 bool ShouldPerformLiveRun() {
   return StartsWithASCII(
@@ skipping 269 matching lines @@
 };
 
 
 // AutomaticProfileResetter --------------------------------------------------
 
 AutomaticProfileResetter::AutomaticProfileResetter(Profile* profile)
     : profile_(profile),
       state_(STATE_UNINITIALIZED),
       enumeration_of_loaded_modules_ready_(false),
       template_url_service_ready_(false),
+      has_already_dismissed_prompt_(false),
       weak_ptr_factory_(this) {
   DCHECK(profile_);
 }
 
 AutomaticProfileResetter::~AutomaticProfileResetter() {}
 
 void AutomaticProfileResetter::Initialize() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
@@ skipping 11 matching lines @@
           IDR_AUTOMATIC_PROFILE_RESET_HASH_SEED).as_string();
     } else {  // ShouldPerformDryRun()
       program_ = resources.GetRawDataResource(
           IDR_AUTOMATIC_PROFILE_RESET_RULES_DRY).as_string();
       hash_seed_ = resources.GetRawDataResource(
           IDR_AUTOMATIC_PROFILE_RESET_HASH_SEED_DRY).as_string();
     }
   }
 
   delegate_.reset(new AutomaticProfileResetterDelegateImpl(
-      TemplateURLServiceFactory::GetForProfile(profile_)));
+      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(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_EQ(state_, STATE_HAS_SHOWN_BUBBLE);
+
+  state_ = STATE_PERFORMING_RESET;
+
+  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_EQ(state_, STATE_HAS_SHOWN_BUBBLE);
+
+  ReportPromptResult(PROMPT_ACTION_NO_RESET);
+  delegate_->DismissPrompt();
+  FinishResetPromptFlow();
+}
+
+bool AutomaticProfileResetter::IsResetPromptFlowActive() const {
+  return state_ == STATE_HAS_TRIGGERED_PROMPT ||
+      state_ == STATE_HAS_SHOWN_BUBBLE;
+}
+
+void AutomaticProfileResetter::NotifyDidShowResetBubble() {
+  DCHECK(content::BrowserThread::CurrentlyOn(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));
+
+  // 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));
+
+  // 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::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));
+
+  // 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_EQ(state_, STATE_INITIALIZED);
 
   state_ = STATE_WAITING_ON_DEPENDENCIES;
 
   delegate_->RequestCallbackWhenTemplateURLServiceIsLoaded(
       base::Bind(&AutomaticProfileResetter::OnTemplateURLServiceIsLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
   delegate_->RequestCallbackWhenLoadedModulesAreEnumerated(
@@ skipping 26 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void AutomaticProfileResetter::BeginEvaluationFlow() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK_EQ(state_, STATE_READY);
   DCHECK(!program_.empty());
   DCHECK(!input_builder_);
 
-  state_ = STATE_WORKING;
+  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_EQ(state_, STATE_WORKING);
+  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);
 
   base::PostTaskAndReplyWithResult(
@@ skipping 37 matching lines @@
   }
   for (size_t i = 0; i < arraysize(kSatisfiedCriteriaMaskKeys); ++i) {
     bool flag = false;
     if (interpreter.GetOutputBoolean(kSatisfiedCriteriaMaskKeys[i], &flag) &&
         flag)
       results->satisfied_criteria_mask |= (1 << i);
   }
   return results.Pass();
 }
 
-void AutomaticProfileResetter::FinishEvaluationFlow(
-    scoped_ptr<EvaluationResults> results) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK_EQ(state_, STATE_WORKING);
-
-  ReportStatistics(results->satisfied_criteria_mask,
-                   results->combined_status_mask);
-
-  if (results->satisfied_criteria_mask != 0 && !results->had_prompted_already) {
-    PreferenceHostedPromptMemento memento_in_prefs(profile_);
-    LocalStateHostedPromptMemento memento_in_local_state(profile_);
-    FileHostedPromptMemento memento_in_file(profile_);
-
-    memento_in_prefs.StoreValue(results->memento_value_in_prefs);
-    memento_in_local_state.StoreValue(results->memento_value_in_local_state);
-    memento_in_file.StoreValue(results->memento_value_in_file);
-
-    if (ShouldPerformLiveRun()) {
-      delegate_->ShowPrompt();
-    } else {
-      UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.PromptResult",
-                                PROMPT_NOT_SHOWN,
-                                PROMPT_RESULT_MAX);
-    }
-  }
-
-  state_ = STATE_DONE;
-}
-
 void AutomaticProfileResetter::ReportStatistics(uint32 satisfied_criteria_mask,
                                                 uint32 combined_status_mask) {
   UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.SatisfiedCriteriaMask",
                             satisfied_criteria_mask,
                             kSatisfiedCriteriaMaskMaximumValue);
   UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.CombinedStatusMask",
                             combined_status_mask,
                             kCombinedStatusMaskMaximumValue);
 }
 
-void AutomaticProfileResetter::Shutdown() {
+void AutomaticProfileResetter::FinishEvaluationFlow(
+    scoped_ptr<EvaluationResults> results) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS);
 
-  state_ = STATE_DISABLED;
-  delegate_.reset();
-  weak_ptr_factory_.InvalidateWeakPtrs();
+  ReportStatistics(results->satisfied_criteria_mask,
+                   results->combined_status_mask);
+
+  if (results->satisfied_criteria_mask != 0 && !results->had_prompted_already) {
+    evaluation_results_ = results.Pass();
+    BeginResetPromptFlow();
+  } else {
+    state_ = STATE_DONE;
+  }
 }
+
+void AutomaticProfileResetter::BeginResetPromptFlow() {
+  DCHECK(content::BrowserThread::CurrentlyOn(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_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(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(state_ == STATE_HAS_TRIGGERED_PROMPT ||
+         state_ == STATE_HAS_SHOWN_BUBBLE ||
+         state_ == STATE_PERFORMING_RESET);
+  DCHECK(!evaluation_results_);
+
+  state_ = STATE_DONE;
+}