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 91 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 59 matching lines @@
 }  // namespace
 
 
 // AutomaticProfileResetter --------------------------------------------------
 
 AutomaticProfileResetter::AutomaticProfileResetter(Profile* profile)
     : profile_(profile),
       state_(STATE_UNINITIALIZED),
       enumeration_of_loaded_modules_ready_(false),
       template_url_service_ready_(false),
+      has_shown_bubble_(false),
       memento_in_prefs_(profile_),
       memento_in_local_state_(profile_),
       memento_in_file_(profile_),
       weak_ptr_factory_(this) {
   DCHECK(profile_);
 }
 
 AutomaticProfileResetter::~AutomaticProfileResetter() {}
 
 void AutomaticProfileResetter::Initialize() {
@@ skipping 14 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_AWAITING_USER_CHOICE);
+
+  state_ = STATE_PERFORMING_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_AWAITING_USER_CHOICE);
+
+  FinishResetPromptFlow(PROMPT_ACTION_NO_RESET);
+}
+
+bool AutomaticProfileResetter::IsResetPromptActive() const {
+  return state_ == STATE_AWAITING_USER_CHOICE;
+}
+
+void AutomaticProfileResetter::NotifyDidShowResetBubble() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(state_, STATE_AWAITING_USER_CHOICE);
+
+  has_shown_bubble_ = true;
+}
+
+void AutomaticProfileResetter::NotifyDidOpenWebUIResetDialog() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // This notification is invoked unconditionally by the WebUI, but we only care
+  // about it when the prompt is currently active.
+  if (state_ == STATE_AWAITING_USER_CHOICE)
+    delegate_->DismissPrompt();
+}
+
+void AutomaticProfileResetter::NotifyDidCloseWebUIResetDialog(
+    bool performed_reset) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // This notification is invoked unconditionally by the WebUI, but we only care
+    // about it when the prompt is currently active.

[battre, 2013/11/11 02:38:22]

nit: -2 spaces.

[engedy, 2013/11/13 00:40:44]

Done.

+  if (state_ == STATE_AWAITING_USER_CHOICE) {
+    FinishResetPromptFlow(has_shown_bubble_ ?
+        (performed_reset ?
+            PROMPT_FOLLOWED_BY_WEBUI_RESET :
+            PROMPT_FOLLOWED_BY_WEBUI_NO_RESET) :
+        (performed_reset ?
+            PROMPT_SUPPRESSED_BUT_HAD_WEBUI_RESET :
+            PROMPT_SUPPRESSED_BUT_HAD_WEBUI_NO_RESET));
+  }
+}
+
+void AutomaticProfileResetter::Shutdown() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // At this point, metrics service is already shut down and the local state
+  // should already no longer be written...
+
+  // Conclude the flow in case the bubble was shown, so as to prevent showing
+  // the prompt on next start-up. However, if the bubble was not even shown, or
+  // if the ongoing reset did not complete, show the prompt on next start-up.
+  if (state_ == STATE_AWAITING_USER_CHOICE && has_shown_bubble_)
+    FinishResetPromptFlow(PROMPT_IGNORED);
+  else if (state_ == STATE_AWAITING_USER_CHOICE ||
+           state_ == STATE_PERFORMING_RESET)
+    delegate_->DismissPrompt();
+
+  state_ = STATE_DISABLED;
+  delegate_.reset();
+  weak_ptr_factory_.InvalidateWeakPtrs();
+}
+
 void AutomaticProfileResetter::SetProgramForTesting(
     const std::string& program) {
   program_ = program;
 }
 
 void AutomaticProfileResetter::SetHashSeedForTesting(
     const std::string& hash_key) {
   hash_seed_ = hash_key;
 }
 
@@ skipping 45 matching lines @@
         base::Bind(&AutomaticProfileResetter::BeginEvaluationFlow,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void AutomaticProfileResetter::BeginEvaluationFlow() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK_EQ(state_, STATE_READY);
   DCHECK(!program_.empty());
 
-  state_ = STATE_WORKING;
+  state_ = STATE_EVALUATING_CONDITIONS;
   memento_in_file_.ReadValue(
       base::Bind(&AutomaticProfileResetter::ContinueWithEvaluationFlow,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 scoped_ptr<base::DictionaryValue>
     AutomaticProfileResetter::BuildEvaluatorProgramInput(
     const std::string& memento_value_in_file) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
@@ skipping 38 matching lines @@
   scoped_ptr<base::ListValue> loaded_module_digests(
       delegate_->GetLoadedModuleNameDigests());
   input->Set(kLoadedModuleDigestsKey, loaded_module_digests.release());
 
   return input.Pass();
 }
 
 void AutomaticProfileResetter::ContinueWithEvaluationFlow(
     const std::string& memento_value_in_file) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK_EQ(state_, STATE_WORKING);
+  DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS);
   PrefService* prefs = profile_->GetPrefs();
   DCHECK(prefs);
 
   scoped_ptr<base::DictionaryValue> input(
       BuildEvaluatorProgramInput(memento_value_in_file));
 
   base::SequencedWorkerPool* blocking_pool =
       content::BrowserThread::GetBlockingPool();
   scoped_refptr<base::TaskRunner> task_runner =
       blocking_pool->GetTaskRunnerWithShutdownBehavior(
@@ skipping 40 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) {
-    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();
+  evaluation_results_ = results.Pass();
+
+  ReportStatistics(evaluation_results_->satisfied_criteria_mask,
+                   evaluation_results_->combined_status_mask);
+
+  if (evaluation_results_->satisfied_criteria_mask != 0 &&
+      !evaluation_results_->had_prompted_already) {
+    BeginResetPromptFlow();
+  } else {
+    state_ = STATE_DONE;
+  }
 }
+
+void AutomaticProfileResetter::BeginResetPromptFlow() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(state_, STATE_EVALUATING_CONDITIONS);
+
+  state_ = STATE_AWAITING_USER_CHOICE;
+
+  if (ShouldPerformLiveRun() && delegate_->ShowPrompt()) {
+    // Start fetching brandcode config in the background speculatively.
+    delegate_->FetchBrandcodedDefaultSettingsIfNeeded();
+  } else {
+    FinishResetPromptFlow(PROMPT_NOT_SHOWN);
+  }
+}
+
+void AutomaticProfileResetter::OnProfileSettingsResetCompleted() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(state_, STATE_PERFORMING_RESET);
+
+  FinishResetPromptFlow(PROMPT_ACTION_RESET);
+}
+
+void AutomaticProfileResetter::ReportPromptResult(PromptResult result) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "AutomaticProfileReset.PromptResult", result, PROMPT_RESULT_MAX);
+}
+
+void AutomaticProfileResetter::FinishResetPromptFlow(PromptResult result) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(state_ == STATE_PERFORMING_RESET ||
+         state_ == STATE_AWAITING_USER_CHOICE);
+
+  delegate_->DismissPrompt();
+
+  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);
+
+  ReportPromptResult(result);
+
+  state_ = STATE_DONE;
+}