Added the ability to specify AutomaticProfileResetter's evaluation program through field trials.

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"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile_resetter/automatic_profile_resetter_delegate.h"
 #include "chrome/browser/profile_resetter/jtl_interpreter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/browser_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 
 // AutomaticProfileResetter::EvaluationResults -------------------------------
 
 // Encapsulates the output values extracted from the evaluator program.
 struct AutomaticProfileResetter::EvaluationResults {
   EvaluationResults()
@@ skipping 12 matching lines @@
 
 
 // Helpers -------------------------------------------------------------------
 
 namespace {
 
 // Name constants for the field trial behind which we enable this feature.
 const char kAutomaticProfileResetStudyName[] = "AutomaticProfileReset";
 const char kAutomaticProfileResetStudyDryRunGroupName[] = "DryRun";
 const char kAutomaticProfileResetStudyEnabledGroupName[] = "Enabled";
+const char kAutomaticProfileResetStudyProgramParameterName[] = "program";
+const char kAutomaticProfileResetStudyHashSeedParameterName[] = "hash_seed";
 
 // How long to wait after start-up before unleashing the evaluation flow.
 const int64 kEvaluationFlowDelayInSeconds = 55;
 
 // Keys used in the input dictionary of the program.
 const char kDefaultSearchProviderKey[] = "default_search_provider";
 const char kDefaultSearchProviderIsUserControlledKey[] =
     "default_search_provider_iuc";
 const char kLoadedModuleDigestsKey[] = "loaded_modules";
 const char kLocalStateKey[] = "local_state";
@@ skipping 42 matching lines @@
   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 base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName) ==
-         kAutomaticProfileResetStudyDryRunGroupName;
+  return StartsWithASCII(
+      base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName),
+      kAutomaticProfileResetStudyDryRunGroupName, true);
 }
 
 // Returns whether or not a live-run shall be performed.
 bool ShouldPerformLiveRun() {
-  return base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName) ==
-         kAutomaticProfileResetStudyEnabledGroupName;
+  return StartsWithASCII(
+      base::FieldTrialList::FindFullName(kAutomaticProfileResetStudyName),
+      kAutomaticProfileResetStudyEnabledGroupName, true);
+}
+
+// Returns whether or not the currently active experiment group prescribes the
+// program and hash seed to use instead of the baked-in ones.
+bool DoesExperimentOverrideProgramAndHashSeed() {
+#if defined(GOOGLE_CHROME_BUILD)
+  std::map<std::string, std::string> params;
+  chrome_variations::GetVariationParams(kAutomaticProfileResetStudyName,
+                                        &params);
+  return params.count(kAutomaticProfileResetStudyProgramParameterName) &&
+         params.count(kAutomaticProfileResetStudyHashSeedParameterName);
+#else
+  return false;
+#endif
 }
 
 // Deep-copies all preferences in |source| to a sub-tree named |value_tree_key|
 // in |target_dictionary|, with path expansion, and also creates an isomorphic
 // sub-tree under the key |is_user_controlled_tree_key| that contains only
 // Boolean values, indicating whether or not the corresponding preferences are
 // coming from the 'user' PrefStore.
 void BuildSubTreesFromPreferences(const PrefService* source,
                                   const char* value_tree_key,
                                   const char* is_user_controlled_tree_key,
@@ skipping 31 matching lines @@
 AutomaticProfileResetter::AutomaticProfileResetter(Profile* profile)
     : profile_(profile),
       state_(STATE_UNINITIALIZED),
       enumeration_of_loaded_modules_ready_(false),
       template_url_service_ready_(false),
       memento_in_prefs_(profile_),
       memento_in_local_state_(profile_),
       memento_in_file_(profile_),
       weak_ptr_factory_(this) {
   DCHECK(profile_);
-  Initialize();
 }
 
 AutomaticProfileResetter::~AutomaticProfileResetter() {}
 
+void AutomaticProfileResetter::Initialize() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(state_, STATE_UNINITIALIZED);
+
+  if (!ShouldPerformDryRun() && !ShouldPerformLiveRun()) {
+    state_ = STATE_DISABLED;
+    return;
+  }
+
+  ui::ResourceBundle& resources(ui::ResourceBundle::GetSharedInstance());
+  if (DoesExperimentOverrideProgramAndHashSeed()) {

[Alexei Svitkine (slow), 2013/11/06 15:24:56]

I would have made this call:

GetOverrideProgramAndHashSeedFromParams(&program_, &hash_seed_)

(that still returns true/false if it succeeded).

That way, you don't have to query the Variations API 3 different times (each
call involves grabbing a lock and copying a map).

[engedy, 2013/11/06 16:55:01]

Done.

+    program_ = chrome_variations::GetVariationParamValue(
+        kAutomaticProfileResetStudyName,
+        kAutomaticProfileResetStudyProgramParameterName);
+    hash_seed_ = chrome_variations::GetVariationParamValue(
+        kAutomaticProfileResetStudyName,
+        kAutomaticProfileResetStudyHashSeedParameterName);
+  } else if (ShouldPerformLiveRun()) {
+    program_ = resources.GetRawDataResource(
+        IDR_AUTOMATIC_PROFILE_RESET_RULES).as_string();
+    hash_seed_ = resources.GetRawDataResource(
+        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_)));
+  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::SetHashSeedForTesting(
-    const base::StringPiece& hash_key) {
-  hash_seed_ = hash_key;
+void AutomaticProfileResetter::SetProgramForTesting(
+    const std::string& program) {
+  program_ = program;
 }
 
-void AutomaticProfileResetter::SetProgramForTesting(
-    const base::StringPiece& 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::Initialize() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK_EQ(state_, STATE_UNINITIALIZED);
-
-  if (ShouldPerformDryRun() || ShouldPerformLiveRun()) {
-    ui::ResourceBundle& resources(ui::ResourceBundle::GetSharedInstance());
-    if (ShouldPerformLiveRun()) {
-      program_ =
-          resources.GetRawDataResource(IDR_AUTOMATIC_PROFILE_RESET_RULES);
-      hash_seed_ =
-          resources.GetRawDataResource(IDR_AUTOMATIC_PROFILE_RESET_HASH_SEED);
-    } else {  // ShouldPerformDryRun()
-      program_ =
-          resources.GetRawDataResource(IDR_AUTOMATIC_PROFILE_RESET_RULES_DRY);
-      hash_seed_ = resources.GetRawDataResource(
-          IDR_AUTOMATIC_PROFILE_RESET_HASH_SEED_DRY);
-    }
-    delegate_.reset(new AutomaticProfileResetterDelegateImpl(
-        TemplateURLServiceFactory::GetForProfile(profile_)));
-    task_runner_for_waiting_ =
-        content::BrowserThread::GetMessageLoopProxyForThread(
-            content::BrowserThread::UI);
-    state_ = STATE_INITIALIZED;
-  } else {
-    state_ = STATE_DISABLED;
-  }
-}
-
 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 111 matching lines @@
                  hash_seed_,
                  program_,
                  base::Passed(&input)),
       base::Bind(&AutomaticProfileResetter::FinishEvaluationFlow,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 // static
 scoped_ptr<AutomaticProfileResetter::EvaluationResults>
     AutomaticProfileResetter::EvaluateConditionsOnWorkerPoolThread(
-    const base::StringPiece& hash_seed,
-    const base::StringPiece& program,
+    const std::string& hash_seed,
+    const std::string& program,
     scoped_ptr<base::DictionaryValue> program_input) {
-  JtlInterpreter interpreter(
-      hash_seed.as_string(), program.as_string(), program_input.get());
+  JtlInterpreter interpreter(hash_seed, program, program_input.get());
   interpreter.Execute();
   UMA_HISTOGRAM_ENUMERATION("AutomaticProfileReset.InterpreterResult",
                             interpreter.result(),
                             JtlInterpreter::RESULT_MAX);
 
   // In each case below, the respective field in result originally contains the
   // default, so if the getter fails, we still have the correct value there.
   scoped_ptr<EvaluationResults> results(new EvaluationResults);
   interpreter.GetOutputBoolean(kHadPromptedAlreadyKey,
                                &results->had_prompted_already);
@@ skipping 52 matching lines @@
                             kCombinedStatusMaskMaximumValue);
 }
 
 void AutomaticProfileResetter::Shutdown() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   state_ = STATE_DISABLED;
   delegate_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }