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

chrome/browser/profile_resetter/automatic_profile_resetter_unittest.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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/profile_resetter/automatic_profile_resetter_delegate.h"
 #include "chrome/browser/profile_resetter/automatic_profile_resetter_factory.h"
 #include "chrome/browser/profile_resetter/automatic_profile_resetter_mementos.h"
 #include "chrome/browser/profile_resetter/jtl_foundation.h"
 #include "chrome/browser/profile_resetter/jtl_instructions.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/user_prefs/pref_registry_syncable.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Invoke;
 
 namespace {
 
@@ skipping 362 matching lines @@
 // Test fixtures -------------------------------------------------------------
 
 class AutomaticProfileResetterTestBase : public testing::Test {
  protected:
   explicit AutomaticProfileResetterTestBase(
       const std::string& experiment_group_name)
       : waiting_task_runner_(new base::TestSimpleTaskRunner),
         local_state_(TestingBrowserProcess::GetGlobal()),
         profile_(new TestingProfile()),
         experiment_group_name_(experiment_group_name),
+        inject_data_through_variation_params_(false),
         mock_delegate_(NULL) {
     // Make sure the factory is not optimized away, so whatever preferences it
     // wants to register will actually get registered.
     AutomaticProfileResetterFactory::GetInstance();
 
     // Register some additional local state preferences for testing purposes.
     PrefRegistrySimple* local_state_registry = local_state_.Get()->registry();
     DCHECK(local_state_registry);
     local_state_registry->RegisterStringPref(kTestPreferencePath, "");
 
     // Register some additional user preferences for testing purposes.
     user_prefs::PrefRegistrySyncable* user_prefs_registry =
         profile_->GetTestingPrefService()->registry();
     DCHECK(user_prefs_registry);
     user_prefs_registry->RegisterStringPref(
         kTestPreferencePath,
         "",
         user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   }
 
   virtual void SetUp() OVERRIDE {
     field_trials_.reset(new base::FieldTrialList(NULL));
+    chrome_variations::testing::ClearAllVariationParams();
     base::FieldTrialList::CreateFieldTrial(kAutomaticProfileResetStudyName,
                                            experiment_group_name_);
-
-    resetter_.reset(new testing::StrictMock<AutomaticProfileResetterUnderTest>(
-        profile_.get()));
-
-    scoped_ptr<MockProfileResetterDelegate> mock_delegate(
+    resetter_.reset(
+        new testing::StrictMock<AutomaticProfileResetterUnderTest>(profile()));
+    mock_delegate_owned_.reset(
         new testing::StrictMock<MockProfileResetterDelegate>());
-    mock_delegate_ = mock_delegate.get();
-    resetter_->SetDelegateForTesting(
-        mock_delegate.PassAs<AutomaticProfileResetterDelegate>());
-    resetter_->SetTaskRunnerForWaitingForTesting(waiting_task_runner_);
+    mock_delegate_ = mock_delegate_owned_.get();
   }
 
   void SetTestingHashSeed(const std::string& hash_seed) {
     testing_hash_seed_ = hash_seed;
   }
 
   void SetTestingProgram(const std::string& source_code) {
     testing_program_ = source_code;
   }
 
+  void AllowInjectingTestDataThroughVariationParams(bool value) {
+    inject_data_through_variation_params_ = value;
+  }
+
   void UnleashResetterAndWait() {
-    resetter_->SetHashSeedForTesting(testing_hash_seed_);
-    resetter_->SetProgramForTesting(testing_program_);
-
+    if (inject_data_through_variation_params_) {
+      std::map<std::string, std::string> variation_params;
+      variation_params["program"] = testing_program_;
+      variation_params["hash_seed"] = testing_hash_seed_;
+      ASSERT_TRUE(chrome_variations::AssociateVariationParams(
+          kAutomaticProfileResetStudyName,
+          experiment_group_name_,
+          variation_params));
+    }
+    resetter_->Initialize();
+    resetter_->SetDelegateForTesting(
+        mock_delegate_owned_.PassAs<AutomaticProfileResetterDelegate>());
+    resetter_->SetTaskRunnerForWaitingForTesting(waiting_task_runner_);
+    if (!inject_data_through_variation_params_) {
+      resetter_->SetProgramForTesting(testing_program_);
+      resetter_->SetHashSeedForTesting(testing_hash_seed_);
+    }
     resetter_->Activate();
 
     if (waiting_task_runner_->HasPendingTask()) {
-      EXPECT_EQ(base::TimeDelta::FromSeconds(55),
+      ASSERT_EQ(base::TimeDelta::FromSeconds(55),
                 waiting_task_runner_->NextPendingTaskDelay());
       waiting_task_runner_->RunPendingTasks();
     }
     base::RunLoop().RunUntilIdle();
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   }
 
   TestingProfile* profile() { return profile_.get(); }
   TestingPrefServiceSimple* local_state() { return local_state_.Get(); }
 
   MockProfileResetterDelegate& mock_delegate() { return *mock_delegate_; }
   AutomaticProfileResetterUnderTest& resetter() { return *resetter_; }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<base::TestSimpleTaskRunner> waiting_task_runner_;
   ScopedTestingLocalState local_state_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<base::FieldTrialList> field_trials_;
   std::string experiment_group_name_;
   std::string testing_program_;
   std::string testing_hash_seed_;
+  bool inject_data_through_variation_params_;
 
   scoped_ptr<AutomaticProfileResetterUnderTest> resetter_;
+  scoped_ptr<MockProfileResetterDelegate> mock_delegate_owned_;
   MockProfileResetterDelegate* mock_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterTestBase);
 };
 
 class AutomaticProfileResetterTest : public AutomaticProfileResetterTestBase {
  protected:
   AutomaticProfileResetterTest()
       : AutomaticProfileResetterTestBase(kStudyEnabledGroupName) {}
 };
@@ skipping 97 matching lines @@
   mock_delegate().ExpectCallsToGetterMethods();
   EXPECT_CALL(resetter(), ReportStatistics(0x02u, 0x01u));
 
   UnleashResetterAndWait();
 
   EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
   EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
   EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
 }
 
+#if defined(GOOGLE_CHROME_BUILD)
+TEST_F(AutomaticProfileResetterTestDryRun, ProgramSetThroughVariationParams) {
+  PreferenceHostedPromptMemento memento_in_prefs(profile());
+  LocalStateHostedPromptMemento memento_in_local_state(profile());
+  FileHostedPromptMementoSynchronous memento_in_file(profile());
+
+  EXPECT_EQ("", memento_in_prefs.ReadValue());
+  EXPECT_EQ("", memento_in_local_state.ReadValue());
+  EXPECT_EQ("", memento_in_file.ReadValue());
+
+  SetTestingProgram(ConstructProgram(true, true));
+  SetTestingHashSeed(kTestHashSeed);
+  AllowInjectingTestDataThroughVariationParams(true);
+
+  mock_delegate().ExpectCallsToDependenciesSetUpMethods();
+  mock_delegate().ExpectCallsToGetterMethods();
+  EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+
+  UnleashResetterAndWait();
+
+  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+}
+#endif
+
 TEST_F(AutomaticProfileResetterTestDryRun,
        ConditionsSatisfiedAndInvalidMementos) {
   PreferenceHostedPromptMemento memento_in_prefs(profile());
   LocalStateHostedPromptMemento memento_in_local_state(profile());
   FileHostedPromptMementoSynchronous memento_in_file(profile());
 
   memento_in_prefs.StoreValue(kTestInvalidMementoValue);
   memento_in_local_state.StoreValue(kTestInvalidMementoValue);
   memento_in_file.StoreValue(kTestInvalidMementoValue);
 
@@ skipping 155 matching lines @@
   EXPECT_CALL(mock_delegate(), ShowPrompt());
   EXPECT_CALL(resetter(), ReportStatistics(0x02u, 0x01u));
 
   UnleashResetterAndWait();
 
   EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
   EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
   EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
 }
 
+#if defined(GOOGLE_CHROME_BUILD)
+TEST_F(AutomaticProfileResetterTest, ProgramSetThroughVariationParams) {
+  PreferenceHostedPromptMemento memento_in_prefs(profile());
+  LocalStateHostedPromptMemento memento_in_local_state(profile());
+  FileHostedPromptMementoSynchronous memento_in_file(profile());
+
+  EXPECT_EQ("", memento_in_prefs.ReadValue());
+  EXPECT_EQ("", memento_in_local_state.ReadValue());
+  EXPECT_EQ("", memento_in_file.ReadValue());
+
+  SetTestingProgram(ConstructProgram(true, true));
+  SetTestingHashSeed(kTestHashSeed);
+  AllowInjectingTestDataThroughVariationParams(true);
+
+  mock_delegate().ExpectCallsToDependenciesSetUpMethods();
+  mock_delegate().ExpectCallsToGetterMethods();
+  EXPECT_CALL(mock_delegate(), ShowPrompt());
+  EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
+
+  UnleashResetterAndWait();
+
+  EXPECT_EQ(kTestMementoValue, memento_in_prefs.ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_local_state.ReadValue());
+  EXPECT_EQ(kTestMementoValue, memento_in_file.ReadValue());
+}
+#endif
+
 TEST_F(AutomaticProfileResetterTest, ConditionsSatisfiedAndInvalidMementos) {
   PreferenceHostedPromptMemento memento_in_prefs(profile());
   LocalStateHostedPromptMemento memento_in_local_state(profile());
   FileHostedPromptMementoSynchronous memento_in_file(profile());
 
   memento_in_prefs.StoreValue(kTestInvalidMementoValue);
   memento_in_local_state.StoreValue(kTestInvalidMementoValue);
   memento_in_file.StoreValue(kTestInvalidMementoValue);
 
   SetTestingProgram(ConstructProgram(true, true));
@@ skipping 229 matching lines @@
   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   mock_delegate().ExpectCallsToGetterMethods();
   uint32 expected_mask =
       HAS_EXPECTED_MODULE_DIGEST_1 | HAS_EXPECTED_MODULE_DIGEST_2;
   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
 
   UnleashResetterAndWait();
 }
 
 }  // namespace