Home | History | Annotate | Download | only in profile_resetter 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/profile_resetter/automatic_profile_resetter.h"
      6 
      7 #include <string>
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/metrics/field_trial.h"
     12 #include "base/prefs/pref_registry_simple.h"
     13 #include "base/prefs/testing_pref_service.h"
     14 #include "base/run_loop.h"
     15 #include "base/test/test_simple_task_runner.h"
     16 #include "base/threading/sequenced_worker_pool.h"
     17 #include "base/values.h"
     18 #include "chrome/browser/profile_resetter/automatic_profile_resetter_delegate.h"
     19 #include "chrome/browser/profile_resetter/automatic_profile_resetter_factory.h"
     20 #include "chrome/browser/profile_resetter/automatic_profile_resetter_mementos.h"
     21 #include "chrome/browser/profile_resetter/jtl_foundation.h"
     22 #include "chrome/browser/profile_resetter/jtl_instructions.h"
     23 #include "chrome/test/base/scoped_testing_local_state.h"
     24 #include "chrome/test/base/testing_browser_process.h"
     25 #include "chrome/test/base/testing_pref_service_syncable.h"
     26 #include "chrome/test/base/testing_profile.h"
     27 #include "components/pref_registry/pref_registry_syncable.h"
     28 #include "components/variations/variations_associated_data.h"
     29 #include "content/public/browser/browser_thread.h"
     30 #include "content/public/test/test_browser_thread_bundle.h"
     31 #include "testing/gmock/include/gmock/gmock.h"
     32 #include "testing/gtest/include/gtest/gtest.h"
     33 
     34 using testing::_;
     35 
     36 namespace {
     37 
     38 const char kAutomaticProfileResetStudyName[] = "AutomaticProfileReset";
     39 const char kStudyDisabledGroupName[] = "Disabled";
     40 const char kStudyDryRunGroupName[] = "DryRun";
     41 const char kStudyEnabledGroupName[] = "Enabled";
     42 
     43 const char kTestHashSeed[] = "testing-hash-seed";
     44 const char kTestMementoValue[] = "01234567890123456789012345678901";
     45 const char kTestInvalidMementoValue[] = "12345678901234567890123456789012";
     46 
     47 const char kTestPreferencePath[] = "testing.preference";
     48 const char kTestPreferenceValue[] = "testing-preference-value";
     49 
     50 const char kSearchURLAttributeKey[] = "search_url";
     51 const char kTestSearchURL[] = "http://example.com/search?q={searchTerms}";
     52 const char kTestSearchURL2[] = "http://google.com/?q={searchTerms}";
     53 
     54 const char kTestModuleDigest[] = "01234567890123456789012345678901";
     55 const char kTestModuleDigest2[] = "12345678901234567890123456789012";
     56 
     57 // Helpers ------------------------------------------------------------------
     58 
     59 // A testing version of the AutomaticProfileResetter that differs from the real
     60 // one only in that it has its statistics reporting mocked out for verification.
     61 class AutomaticProfileResetterUnderTest : public AutomaticProfileResetter {
     62  public:
     63   explicit AutomaticProfileResetterUnderTest(Profile* profile)
     64       : AutomaticProfileResetter(profile) {}
     65   virtual ~AutomaticProfileResetterUnderTest() {}
     66 
     67   MOCK_METHOD2(ReportStatistics, void(uint32, uint32));
     68   MOCK_METHOD1(ReportPromptResult,
     69       void(AutomaticProfileResetter::PromptResult));
     70 
     71  private:
     72   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterUnderTest);
     73 };
     74 
     75 class MockProfileResetterDelegate : public AutomaticProfileResetterDelegate {
     76  public:
     77   MockProfileResetterDelegate()
     78       : emulated_is_default_search_provider_managed_(false) {}
     79   virtual ~MockProfileResetterDelegate() {}
     80 
     81   MOCK_METHOD0(EnumerateLoadedModulesIfNeeded, void());
     82   MOCK_CONST_METHOD1(RequestCallbackWhenLoadedModulesAreEnumerated,
     83                      void(const base::Closure&));
     84 
     85   MOCK_METHOD0(LoadTemplateURLServiceIfNeeded, void());
     86   MOCK_CONST_METHOD1(RequestCallbackWhenTemplateURLServiceIsLoaded,
     87                      void(const base::Closure&));
     88 
     89   MOCK_METHOD0(FetchBrandcodedDefaultSettingsIfNeeded, void());
     90   MOCK_CONST_METHOD1(RequestCallbackWhenBrandcodedDefaultsAreFetched,
     91                      void(const base::Closure&));
     92 
     93   MOCK_CONST_METHOD0(OnGetLoadedModuleNameDigestsCalled, void());
     94   MOCK_CONST_METHOD0(OnGetDefaultSearchProviderDetailsCalled, void());
     95   MOCK_CONST_METHOD0(OnIsDefaultSearchProviderManagedCalled, void());
     96   MOCK_CONST_METHOD0(OnGetPrepopulatedSearchProvidersDetailsCalled, void());
     97 
     98   MOCK_METHOD0(TriggerPrompt, bool());
     99   MOCK_METHOD2(TriggerProfileSettingsReset, void(bool, const base::Closure&));
    100   MOCK_METHOD0(DismissPrompt, void());
    101 
    102   virtual scoped_ptr<base::ListValue>
    103       GetLoadedModuleNameDigests() const OVERRIDE {
    104     OnGetLoadedModuleNameDigestsCalled();
    105     return scoped_ptr<base::ListValue>(
    106         emulated_loaded_module_digests_.DeepCopy());
    107   }
    108 
    109   virtual scoped_ptr<base::DictionaryValue>
    110       GetDefaultSearchProviderDetails() const OVERRIDE {
    111     OnGetDefaultSearchProviderDetailsCalled();
    112     return scoped_ptr<base::DictionaryValue>(
    113         emulated_default_search_provider_details_.DeepCopy());
    114   }
    115 
    116   virtual bool IsDefaultSearchProviderManaged() const OVERRIDE {
    117     OnIsDefaultSearchProviderManagedCalled();
    118     return emulated_is_default_search_provider_managed_;
    119   }
    120 
    121   virtual scoped_ptr<base::ListValue>
    122       GetPrepopulatedSearchProvidersDetails() const OVERRIDE {
    123     OnGetPrepopulatedSearchProvidersDetailsCalled();
    124     return scoped_ptr<base::ListValue>(
    125         emulated_search_providers_details_.DeepCopy());
    126   }
    127 
    128   static void ClosureInvoker(const base::Closure& closure) { closure.Run(); }
    129 
    130   void ExpectCallsToDependenciesSetUpMethods() {
    131     EXPECT_CALL(*this, EnumerateLoadedModulesIfNeeded());
    132     EXPECT_CALL(*this, LoadTemplateURLServiceIfNeeded());
    133     EXPECT_CALL(*this, RequestCallbackWhenLoadedModulesAreEnumerated(_))
    134         .WillOnce(testing::Invoke(ClosureInvoker));
    135     EXPECT_CALL(*this, RequestCallbackWhenTemplateURLServiceIsLoaded(_))
    136         .WillOnce(testing::Invoke(ClosureInvoker));
    137   }
    138 
    139   void ExpectCallsToGetterMethods() {
    140     EXPECT_CALL(*this, OnGetLoadedModuleNameDigestsCalled());
    141     EXPECT_CALL(*this, OnGetDefaultSearchProviderDetailsCalled());
    142     EXPECT_CALL(*this, OnIsDefaultSearchProviderManagedCalled());
    143     EXPECT_CALL(*this, OnGetPrepopulatedSearchProvidersDetailsCalled());
    144   }
    145 
    146   void ExpectCallToShowPrompt() {
    147     EXPECT_CALL(*this, TriggerPrompt()).WillOnce(testing::Return(true));
    148     EXPECT_CALL(*this, FetchBrandcodedDefaultSettingsIfNeeded());
    149   }
    150 
    151   void ExpectCallToTriggerReset(bool send_feedback) {
    152     EXPECT_CALL(*this, TriggerProfileSettingsReset(send_feedback, _))
    153         .WillOnce(testing::SaveArg<1>(&reset_completion_));
    154   }
    155 
    156   base::DictionaryValue& emulated_default_search_provider_details() {
    157     return emulated_default_search_provider_details_;
    158   }
    159 
    160   base::ListValue& emulated_search_providers_details() {
    161     return emulated_search_providers_details_;
    162   }
    163 
    164   base::ListValue& emulated_loaded_module_digests() {
    165     return emulated_loaded_module_digests_;
    166   }
    167 
    168   void set_emulated_is_default_search_provider_managed(bool value) {
    169     emulated_is_default_search_provider_managed_ = value;
    170   }
    171 
    172   void EmulateProfileResetCompleted() {
    173     reset_completion_.Run();
    174   }
    175 
    176  private:
    177   base::DictionaryValue emulated_default_search_provider_details_;
    178   base::ListValue emulated_search_providers_details_;
    179   base::ListValue emulated_loaded_module_digests_;
    180   bool emulated_is_default_search_provider_managed_;
    181   base::Closure reset_completion_;
    182 
    183   DISALLOW_COPY_AND_ASSIGN(MockProfileResetterDelegate);
    184 };
    185 
    186 class FileHostedPromptMementoSynchronous : protected FileHostedPromptMemento {
    187  public:
    188   explicit FileHostedPromptMementoSynchronous(Profile* profile)
    189       : FileHostedPromptMemento(profile) {}
    190 
    191   std::string ReadValue() const {
    192     std::string result;
    193     FileHostedPromptMemento::ReadValue(base::Bind(&AssignArgumentTo, &result));
    194     base::RunLoop().RunUntilIdle();
    195     return result;
    196   }
    197 
    198   void StoreValue(const std::string& value) {
    199     FileHostedPromptMemento::StoreValue(value);
    200     base::RunLoop().RunUntilIdle();
    201   }
    202 
    203  private:
    204   static void AssignArgumentTo(std::string* target, const std::string& value) {
    205     *target = value;
    206   }
    207 
    208   DISALLOW_COPY_AND_ASSIGN(FileHostedPromptMementoSynchronous);
    209 };
    210 
    211 std::string GetHash(const std::string& input) {
    212   return jtl_foundation::Hasher(kTestHashSeed).GetHash(input);
    213 }
    214 
    215 // Encodes a Boolean argument value into JTL bytecode.
    216 std::string EncodeBool(bool value) { return value ? VALUE_TRUE : VALUE_FALSE; }
    217 
    218 // Constructs a simple evaluation program to test that basic input/output works
    219 // well. It will emulate a scenario in which the reset criteria are satisfied as
    220 // prescribed by |emulate_satisfied_criterion_{1|2}|, and the reset is triggered
    221 // when either of them is true. The bits in the combined status mask will be set
    222 // according to whether or not the memento values received in the input were as
    223 // expected.
    224 //
    225 // More specifically, the output of the program will be as follows:
    226 // {
    227 //   "satisfied_criteria_mask_bit1": emulate_satisfied_criterion_1,
    228 //   "satisfied_criteria_mask_bit2": emulate_satisfied_criterion_2,
    229 //   "combined_status_mask_bit1":
    230 //      (emulate_satisfied_criterion_1 || emulate_satisfied_criterion_2),
    231 //   "combined_status_mask_bit2":
    232 //      (input["memento_value_in_prefs"] == kTestMementoValue),
    233 //   "combined_status_mask_bit3":
    234 //      (input["memento_value_in_local_state"] == kTestMementoValue),
    235 //   "combined_status_mask_bit4":
    236 //      (input["memento_value_in_file"] == kTestMementoValue),
    237 //   "should_prompt":
    238 //      (emulate_satisfied_criterion_1 || emulate_satisfied_criterion_2),
    239 //   "had_prompted_already": <OR-combination of above three>,
    240 //   "memento_value_in_prefs": kTestMementoValue,
    241 //   "memento_value_in_local_state": kTestMementoValue,
    242 //   "memento_value_in_file": kTestMementoValue
    243 // }
    244 std::string ConstructProgram(bool emulate_satisfied_criterion_1,
    245                              bool emulate_satisfied_criterion_2) {
    246   std::string bytecode;
    247   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit1"),
    248                             EncodeBool(emulate_satisfied_criterion_1));
    249   bytecode += OP_END_OF_SENTENCE;
    250   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit2"),
    251                             EncodeBool(emulate_satisfied_criterion_2));
    252   bytecode += OP_END_OF_SENTENCE;
    253   bytecode += OP_STORE_BOOL(GetHash("should_prompt"),
    254                             EncodeBool(emulate_satisfied_criterion_1 ||
    255                                        emulate_satisfied_criterion_2));
    256   bytecode += OP_END_OF_SENTENCE;
    257   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit1"),
    258                             EncodeBool(emulate_satisfied_criterion_1 ||
    259                                        emulate_satisfied_criterion_2));
    260   bytecode += OP_END_OF_SENTENCE;
    261   bytecode += OP_NAVIGATE(GetHash("memento_value_in_prefs"));
    262   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestMementoValue));
    263   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit2"), VALUE_TRUE);
    264   bytecode += OP_STORE_BOOL(GetHash("had_prompted_already"), VALUE_TRUE);
    265   bytecode += OP_END_OF_SENTENCE;
    266   bytecode += OP_NAVIGATE(GetHash("memento_value_in_local_state"));
    267   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestMementoValue));
    268   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit3"), VALUE_TRUE);
    269   bytecode += OP_STORE_BOOL(GetHash("had_prompted_already"), VALUE_TRUE);
    270   bytecode += OP_END_OF_SENTENCE;
    271   bytecode += OP_NAVIGATE(GetHash("memento_value_in_file"));
    272   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestMementoValue));
    273   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit4"), VALUE_TRUE);
    274   bytecode += OP_STORE_BOOL(GetHash("had_prompted_already"), VALUE_TRUE);
    275   bytecode += OP_END_OF_SENTENCE;
    276   bytecode += OP_STORE_HASH(GetHash("memento_value_in_prefs"),
    277                             kTestMementoValue);
    278   bytecode += OP_END_OF_SENTENCE;
    279   bytecode += OP_STORE_HASH(GetHash("memento_value_in_local_state"),
    280                             kTestMementoValue);
    281   bytecode += OP_END_OF_SENTENCE;
    282   bytecode += OP_STORE_HASH(GetHash("memento_value_in_file"),
    283                             kTestMementoValue);
    284   bytecode += OP_END_OF_SENTENCE;
    285   return bytecode;
    286 }
    287 
    288 // Constructs another evaluation program to specifically test that bits of the
    289 // "satisfied_criteria_mask" are correctly assigned, and so is "should_prompt";
    290 // and that reset is triggered iff the latter is true, regardless of the bits
    291 // in the mask (so as to allow for a non-disjunctive compound criterion).
    292 //
    293 // More specifically, the output of the program will be as follows:
    294 // {
    295 //   "satisfied_criteria_mask_bitN": emulate_satisfied_odd_criteria,
    296 //   "satisfied_criteria_mask_bitM": emulate_satisfied_even_criteria,
    297 //   "combined_status_mask_bit1": emulate_should_prompt,
    298 //   "should_prompt": emulate_should_prompt,
    299 //   "memento_value_in_prefs": kTestMementoValue,
    300 //   "memento_value_in_local_state": kTestMementoValue,
    301 //   "memento_value_in_file": kTestMementoValue
    302 // }
    303 // ... such that N is {1,3,5} and M is {2,4}.
    304 std::string ConstructProgramToExerciseCriteria(
    305     bool emulate_should_prompt,
    306     bool emulate_satisfied_odd_criteria,
    307     bool emulate_satisfied_even_criteria) {
    308   std::string bytecode;
    309   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit1"),
    310                             EncodeBool(emulate_satisfied_odd_criteria));
    311   bytecode += OP_END_OF_SENTENCE;
    312   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit3"),
    313                             EncodeBool(emulate_satisfied_odd_criteria));
    314   bytecode += OP_END_OF_SENTENCE;
    315   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit5"),
    316                             EncodeBool(emulate_satisfied_odd_criteria));
    317   bytecode += OP_END_OF_SENTENCE;
    318   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit2"),
    319                             EncodeBool(emulate_satisfied_even_criteria));
    320   bytecode += OP_END_OF_SENTENCE;
    321   bytecode += OP_STORE_BOOL(GetHash("satisfied_criteria_mask_bit4"),
    322                             EncodeBool(emulate_satisfied_even_criteria));
    323   bytecode += OP_END_OF_SENTENCE;
    324   bytecode += OP_STORE_BOOL(GetHash("should_prompt"),
    325                             EncodeBool(emulate_should_prompt));
    326   bytecode += OP_END_OF_SENTENCE;
    327   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit1"),
    328                             EncodeBool(emulate_should_prompt));
    329   bytecode += OP_END_OF_SENTENCE;
    330   bytecode += OP_STORE_HASH(GetHash("memento_value_in_prefs"),
    331                             kTestMementoValue);
    332   bytecode += OP_END_OF_SENTENCE;
    333   bytecode += OP_STORE_HASH(GetHash("memento_value_in_local_state"),
    334                             kTestMementoValue);
    335   bytecode += OP_END_OF_SENTENCE;
    336   bytecode += OP_STORE_HASH(GetHash("memento_value_in_file"),
    337                             kTestMementoValue);
    338   bytecode += OP_END_OF_SENTENCE;
    339   return bytecode;
    340 }
    341 
    342 // Constructs another evaluation program to specifically test that local state
    343 // and user preference values are included in the input as expected. We will
    344 // re-purpose the output bitmasks to channel out information about the outcome
    345 // of the checks.
    346 //
    347 // More specifically, the output of the program will be as follows:
    348 // {
    349 //   "combined_status_mask_bit1":
    350 //       (input["preferences.testing.preference"] == kTestPreferenceValue)
    351 //   "combined_status_mask_bit2":
    352 //       (input["local_state.testing.preference"] == kTestPreferenceValue)
    353 //   "combined_status_mask_bit3": input["preferences_iuc.testing.preference"]
    354 //   "combined_status_mask_bit4": input["local_state_iuc.testing.preference"]
    355 // }
    356 std::string ConstructProgramToCheckPreferences() {
    357   std::string bytecode;
    358   bytecode += OP_NAVIGATE(GetHash("preferences"));
    359   bytecode += OP_NAVIGATE(GetHash("testing"));
    360   bytecode += OP_NAVIGATE(GetHash("preference"));
    361   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestPreferenceValue));
    362   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit1"),
    363                             EncodeBool(true));
    364   bytecode += OP_END_OF_SENTENCE;
    365   bytecode += OP_NAVIGATE(GetHash("local_state"));
    366   bytecode += OP_NAVIGATE(GetHash("testing"));
    367   bytecode += OP_NAVIGATE(GetHash("preference"));
    368   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestPreferenceValue));
    369   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit2"),
    370                             EncodeBool(true));
    371   bytecode += OP_END_OF_SENTENCE;
    372   bytecode += OP_NAVIGATE(GetHash("preferences_iuc"));
    373   bytecode += OP_NAVIGATE(GetHash("testing"));
    374   bytecode += OP_NAVIGATE(GetHash("preference"));
    375   bytecode += OP_COMPARE_NODE_BOOL(EncodeBool(true));
    376   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit3"),
    377                             EncodeBool(true));
    378   bytecode += OP_END_OF_SENTENCE;
    379   bytecode += OP_NAVIGATE(GetHash("local_state_iuc"));
    380   bytecode += OP_NAVIGATE(GetHash("testing"));
    381   bytecode += OP_NAVIGATE(GetHash("preference"));
    382   bytecode += OP_COMPARE_NODE_BOOL(EncodeBool(true));
    383   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit4"),
    384                             EncodeBool(true));
    385   bytecode += OP_END_OF_SENTENCE;
    386   return bytecode;
    387 }
    388 
    389 // Legend for the bitmask returned by the above program.
    390 enum CombinedStatusMaskLegendForCheckingPreferences {
    391   HAS_EXPECTED_USER_PREFERENCE = 1 << 0,
    392   HAS_EXPECTED_LOCAL_STATE_PREFERENCE = 1 << 1,
    393   USER_PREFERENCE_IS_USER_CONTROLLED = 1 << 2,
    394   LOCAL_STATE_IS_USER_CONTROLLED = 1 << 3,
    395 };
    396 
    397 // Constructs yet another evaluation program to specifically test that default
    398 // and pre-populated search engines are included in the input as expected. We
    399 // will re-purpose the output bitmasks to channel out information about the
    400 // outcome of the checks.
    401 //
    402 // More specifically, the output of the program will be as follows:
    403 // {
    404 //   "combined_status_mask_bit1":
    405 //       (input["default_search_provider.search_url"] == kTestSearchURL)
    406 //   "combined_status_mask_bit2": input["default_search_provider_iuc"]
    407 //   "combined_status_mask_bit3":
    408 //       (input["search_providers.*.search_url"] == kTestSearchURL)
    409 //   "combined_status_mask_bit4":
    410 //       (input["search_providers.*.search_url"] == kTestSearchURL2)
    411 // }
    412 std::string ConstructProgramToCheckSearchEngines() {
    413   std::string bytecode;
    414   bytecode += OP_NAVIGATE(GetHash("default_search_provider"));
    415   bytecode += OP_NAVIGATE(GetHash("search_url"));
    416   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestSearchURL));
    417   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit1"),
    418                             EncodeBool(true));
    419   bytecode += OP_END_OF_SENTENCE;
    420   bytecode += OP_NAVIGATE(GetHash("default_search_provider_iuc"));
    421   bytecode += OP_COMPARE_NODE_BOOL(EncodeBool(true));
    422   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit2"),
    423                             EncodeBool(true));
    424   bytecode += OP_END_OF_SENTENCE;
    425   bytecode += OP_NAVIGATE(GetHash("search_providers"));
    426   bytecode += OP_NAVIGATE_ANY;
    427   bytecode += OP_NAVIGATE(GetHash("search_url"));
    428   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestSearchURL));
    429   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit3"),
    430                             EncodeBool(true));
    431   bytecode += OP_END_OF_SENTENCE;
    432   bytecode += OP_NAVIGATE(GetHash("search_providers"));
    433   bytecode += OP_NAVIGATE_ANY;
    434   bytecode += OP_NAVIGATE(GetHash("search_url"));
    435   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestSearchURL2));
    436   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit4"),
    437                             EncodeBool(true));
    438   bytecode += OP_END_OF_SENTENCE;
    439   return bytecode;
    440 }
    441 
    442 // Legend for the bitmask returned by the above program.
    443 enum CombinedStatusMaskLegendForCheckingSearchEngines {
    444   HAS_EXPECTED_DEFAULT_SEARCH_PROVIDER = 1 << 0,
    445   DEFAULT_SEARCH_PROVIDER_IS_USER_CONTROLLED = 1 << 1,
    446   HAS_EXPECTED_PREPOPULATED_SEARCH_PROVIDER_1 = 1 << 2,
    447   HAS_EXPECTED_PREPOPULATED_SEARCH_PROVIDER_2 = 1 << 3,
    448 };
    449 
    450 // Constructs yet another evaluation program to specifically test that loaded
    451 // module digests are included in the input as expected. We will re-purpose the
    452 // output bitmasks to channel out information about the outcome of the checks.
    453 //
    454 // More specifically, the output of the program will be as follows:
    455 // {
    456 //   "combined_status_mask_bit1":
    457 //       (input["loaded_modules.*"] == kTestModuleDigest)
    458 //   "combined_status_mask_bit2":
    459 //       (input["loaded_modules.*"] == kTestModuleDigest2)
    460 // }
    461 std::string ConstructProgramToCheckLoadedModuleDigests() {
    462   std::string bytecode;
    463   bytecode += OP_NAVIGATE(GetHash("loaded_modules"));
    464   bytecode += OP_NAVIGATE_ANY;
    465   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestModuleDigest));
    466   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit1"),
    467                             EncodeBool(true));
    468   bytecode += OP_END_OF_SENTENCE;
    469   bytecode += OP_NAVIGATE(GetHash("loaded_modules"));
    470   bytecode += OP_NAVIGATE_ANY;
    471   bytecode += OP_COMPARE_NODE_HASH(GetHash(kTestModuleDigest2));
    472   bytecode += OP_STORE_BOOL(GetHash("combined_status_mask_bit2"),
    473                             EncodeBool(true));
    474   bytecode += OP_END_OF_SENTENCE;
    475   return bytecode;
    476 }
    477 
    478 // Legend for the bitmask returned by the above program.
    479 enum CombinedStatusMaskLegendForCheckingLoadedModules {
    480   HAS_EXPECTED_MODULE_DIGEST_1 = 1 << 0,
    481   HAS_EXPECTED_MODULE_DIGEST_2 = 1 << 1,
    482 };
    483 
    484 // Test fixtures -------------------------------------------------------------
    485 
    486 class AutomaticProfileResetterTestBase : public testing::Test {
    487  protected:
    488   explicit AutomaticProfileResetterTestBase(
    489       const std::string& experiment_group_name)
    490       : waiting_task_runner_(new base::TestSimpleTaskRunner),
    491         local_state_(TestingBrowserProcess::GetGlobal()),
    492         profile_(new TestingProfile()),
    493         field_trials_(new base::FieldTrialList(NULL)),
    494         memento_in_prefs_(new PreferenceHostedPromptMemento(profile())),
    495         memento_in_local_state_(new LocalStateHostedPromptMemento(profile())),
    496         memento_in_file_(new FileHostedPromptMementoSynchronous(profile())),
    497         experiment_group_name_(experiment_group_name),
    498         inject_data_through_variation_params_(false),
    499         mock_delegate_(NULL) {
    500     // Make sure the factory is not optimized away, so whatever preferences it
    501     // wants to register will actually get registered.
    502     AutomaticProfileResetterFactory::GetInstance();
    503 
    504     // Register some additional local state preferences for testing purposes.
    505     PrefRegistrySimple* local_state_registry = local_state_.Get()->registry();
    506     DCHECK(local_state_registry);
    507     local_state_registry->RegisterStringPref(kTestPreferencePath, "");
    508 
    509     // Register some additional user preferences for testing purposes.
    510     user_prefs::PrefRegistrySyncable* user_prefs_registry =
    511         profile_->GetTestingPrefService()->registry();
    512     DCHECK(user_prefs_registry);
    513     user_prefs_registry->RegisterStringPref(
    514         kTestPreferencePath, std::string(),
    515         user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    516   }
    517 
    518   virtual void SetUp() OVERRIDE {
    519     variations::testing::ClearAllVariationParams();
    520     base::FieldTrialList::CreateFieldTrial(kAutomaticProfileResetStudyName,
    521                                            experiment_group_name_);
    522     resetter_.reset(
    523         new testing::StrictMock<AutomaticProfileResetterUnderTest>(profile()));
    524     mock_delegate_owned_.reset(
    525         new testing::StrictMock<MockProfileResetterDelegate>());
    526     mock_delegate_ = mock_delegate_owned_.get();
    527 
    528     ExpectAllMementoValuesEqualTo(std::string());
    529   }
    530 
    531   void SetTestingHashSeed(const std::string& hash_seed) {
    532     testing_hash_seed_ = hash_seed;
    533   }
    534 
    535   void SetTestingProgram(const std::string& source_code) {
    536     testing_program_ = source_code;
    537   }
    538 
    539   void AllowInjectingTestDataThroughVariationParams(bool value) {
    540     inject_data_through_variation_params_ = value;
    541   }
    542 
    543   void ExpectAllMementoValuesEqualTo(const std::string& value) {
    544     EXPECT_EQ(value, memento_in_prefs_->ReadValue());
    545     EXPECT_EQ(value, memento_in_local_state_->ReadValue());
    546     EXPECT_EQ(value, memento_in_file_->ReadValue());
    547   }
    548 
    549   void UnleashResetterAndWait() {
    550     if (inject_data_through_variation_params_) {
    551       std::map<std::string, std::string> variation_params;
    552       variation_params["program"] = testing_program_;
    553       variation_params["hash_seed"] = testing_hash_seed_;
    554       ASSERT_TRUE(variations::AssociateVariationParams(
    555           kAutomaticProfileResetStudyName,
    556           experiment_group_name_,
    557           variation_params));
    558     }
    559     resetter_->Initialize();
    560     resetter_->SetDelegateForTesting(
    561         mock_delegate_owned_.PassAs<AutomaticProfileResetterDelegate>());
    562     resetter_->SetTaskRunnerForWaitingForTesting(waiting_task_runner_);
    563     if (!inject_data_through_variation_params_) {
    564       resetter_->SetProgramForTesting(testing_program_);
    565       resetter_->SetHashSeedForTesting(testing_hash_seed_);
    566     }
    567     resetter_->Activate();
    568 
    569     if (waiting_task_runner_->HasPendingTask()) {
    570       ASSERT_EQ(base::TimeDelta::FromSeconds(55),
    571                 waiting_task_runner_->NextPendingTaskDelay());
    572       waiting_task_runner_->RunPendingTasks();
    573     }
    574     base::RunLoop().RunUntilIdle();
    575     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    576     base::RunLoop().RunUntilIdle();
    577   }
    578 
    579   // Goes through an evaluation flow such that the reset criteria are satisfied.
    580   // Used to reduce boilerplate for tests that need to verify behavior during
    581   // the reset prompt flow.
    582   void OrchestrateThroughEvaluationFlow() {
    583     SetTestingProgram(ConstructProgram(true, true));
    584     SetTestingHashSeed(kTestHashSeed);
    585 
    586     mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    587     mock_delegate().ExpectCallsToGetterMethods();
    588     mock_delegate().ExpectCallToShowPrompt();
    589     EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
    590 
    591     UnleashResetterAndWait();
    592 
    593     EXPECT_TRUE(resetter().ShouldShowResetBanner());
    594     testing::Mock::VerifyAndClearExpectations(&resetter());
    595     testing::Mock::VerifyAndClearExpectations(&mock_delegate());
    596   }
    597 
    598   // Explicitly shut down the service to double-check that nothing explodes, but
    599   // first, verify expectations to make sure the service makes no more calls to
    600   // any mocked functions during or after shutdown.
    601   void VerifyExpectationsThenShutdownResetter() {
    602     testing::Mock::VerifyAndClearExpectations(&resetter());
    603     testing::Mock::VerifyAndClearExpectations(&mock_delegate());
    604 
    605     resetter_->Shutdown();
    606     resetter_.reset();
    607   }
    608 
    609   TestingProfile* profile() { return profile_.get(); }
    610   TestingPrefServiceSimple* local_state() { return local_state_.Get(); }
    611 
    612   PreferenceHostedPromptMemento& memento_in_prefs() {
    613     return *memento_in_prefs_;
    614   }
    615 
    616   LocalStateHostedPromptMemento& memento_in_local_state() {
    617     return *memento_in_local_state_;
    618   }
    619 
    620   FileHostedPromptMementoSynchronous& memento_in_file() {
    621     return *memento_in_file_;
    622   }
    623 
    624   MockProfileResetterDelegate& mock_delegate() { return *mock_delegate_; }
    625   AutomaticProfileResetterUnderTest& resetter() { return *resetter_; }
    626 
    627  private:
    628   content::TestBrowserThreadBundle thread_bundle_;
    629   scoped_refptr<base::TestSimpleTaskRunner> waiting_task_runner_;
    630   ScopedTestingLocalState local_state_;
    631   scoped_ptr<TestingProfile> profile_;
    632   scoped_ptr<base::FieldTrialList> field_trials_;
    633   scoped_ptr<PreferenceHostedPromptMemento> memento_in_prefs_;
    634   scoped_ptr<LocalStateHostedPromptMemento> memento_in_local_state_;
    635   scoped_ptr<FileHostedPromptMementoSynchronous> memento_in_file_;
    636 
    637   std::string experiment_group_name_;
    638   std::string testing_program_;
    639   std::string testing_hash_seed_;
    640   bool inject_data_through_variation_params_;
    641 
    642   scoped_ptr<AutomaticProfileResetterUnderTest> resetter_;
    643   scoped_ptr<MockProfileResetterDelegate> mock_delegate_owned_;
    644   MockProfileResetterDelegate* mock_delegate_;
    645 
    646   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterTestBase);
    647 };
    648 
    649 class AutomaticProfileResetterTest : public AutomaticProfileResetterTestBase {
    650  protected:
    651   AutomaticProfileResetterTest()
    652       : AutomaticProfileResetterTestBase(kStudyEnabledGroupName) {}
    653 };
    654 
    655 class AutomaticProfileResetterTestDryRun
    656     : public AutomaticProfileResetterTestBase {
    657  protected:
    658   AutomaticProfileResetterTestDryRun()
    659       : AutomaticProfileResetterTestBase(kStudyDryRunGroupName) {}
    660 };
    661 
    662 class AutomaticProfileResetterTestDisabled
    663     : public AutomaticProfileResetterTestBase {
    664  protected:
    665   AutomaticProfileResetterTestDisabled()
    666       : AutomaticProfileResetterTestBase(kStudyDisabledGroupName) {}
    667 };
    668 
    669 // Tests ---------------------------------------------------------------------
    670 
    671 TEST_F(AutomaticProfileResetterTestDisabled, NothingIsDoneWhenDisabled) {
    672   SetTestingProgram(ConstructProgram(true, true));
    673   SetTestingHashSeed(kTestHashSeed);
    674 
    675   // No calls are expected to the delegate.
    676 
    677   UnleashResetterAndWait();
    678 
    679   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    680   VerifyExpectationsThenShutdownResetter();
    681 
    682   ExpectAllMementoValuesEqualTo(std::string());
    683 }
    684 
    685 TEST_F(AutomaticProfileResetterTestDryRun, CriteriaNotSatisfied) {
    686   SetTestingProgram(ConstructProgramToExerciseCriteria(false, true, true));
    687   SetTestingHashSeed(kTestHashSeed);
    688 
    689   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    690   mock_delegate().ExpectCallsToGetterMethods();
    691   EXPECT_CALL(resetter(), ReportStatistics(0x1fu, 0x00u));
    692 
    693   UnleashResetterAndWait();
    694 
    695   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    696   VerifyExpectationsThenShutdownResetter();
    697 
    698   ExpectAllMementoValuesEqualTo(std::string());
    699 }
    700 
    701 TEST_F(AutomaticProfileResetterTestDryRun, OddCriteriaSatisfied) {
    702   SetTestingProgram(ConstructProgramToExerciseCriteria(true, true, false));
    703   SetTestingHashSeed(kTestHashSeed);
    704 
    705   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    706   mock_delegate().ExpectCallsToGetterMethods();
    707   EXPECT_CALL(resetter(), ReportStatistics(0x15u, 0x01u));
    708   EXPECT_CALL(resetter(), ReportPromptResult(
    709       AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
    710 
    711   UnleashResetterAndWait();
    712 
    713   ExpectAllMementoValuesEqualTo(kTestMementoValue);
    714   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    715   VerifyExpectationsThenShutdownResetter();
    716 }
    717 
    718 TEST_F(AutomaticProfileResetterTestDryRun, EvenCriteriaSatisfied) {
    719   SetTestingProgram(ConstructProgramToExerciseCriteria(true, false, true));
    720   SetTestingHashSeed(kTestHashSeed);
    721 
    722   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    723   mock_delegate().ExpectCallsToGetterMethods();
    724   EXPECT_CALL(resetter(), ReportStatistics(0x0au, 0x01u));
    725   EXPECT_CALL(resetter(), ReportPromptResult(
    726       AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
    727 
    728   UnleashResetterAndWait();
    729 
    730   ExpectAllMementoValuesEqualTo(kTestMementoValue);
    731   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    732   VerifyExpectationsThenShutdownResetter();
    733 }
    734 
    735 #if defined(GOOGLE_CHROME_BUILD)
    736 TEST_F(AutomaticProfileResetterTestDryRun, ProgramSetThroughVariationParams) {
    737   SetTestingProgram(ConstructProgram(true, true));
    738   SetTestingHashSeed(kTestHashSeed);
    739   AllowInjectingTestDataThroughVariationParams(true);
    740 
    741   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    742   mock_delegate().ExpectCallsToGetterMethods();
    743   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
    744   EXPECT_CALL(resetter(), ReportPromptResult(
    745       AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
    746 
    747   UnleashResetterAndWait();
    748 
    749   ExpectAllMementoValuesEqualTo(kTestMementoValue);
    750   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    751   VerifyExpectationsThenShutdownResetter();
    752 }
    753 #endif
    754 
    755 TEST_F(AutomaticProfileResetterTestDryRun,
    756        ConditionsSatisfiedAndInvalidMementos) {
    757   memento_in_prefs().StoreValue(kTestInvalidMementoValue);
    758   memento_in_local_state().StoreValue(kTestInvalidMementoValue);
    759   memento_in_file().StoreValue(kTestInvalidMementoValue);
    760 
    761   SetTestingProgram(ConstructProgram(true, true));
    762   SetTestingHashSeed(kTestHashSeed);
    763 
    764   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    765   mock_delegate().ExpectCallsToGetterMethods();
    766   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
    767   EXPECT_CALL(resetter(), ReportPromptResult(
    768       AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
    769 
    770   UnleashResetterAndWait();
    771 
    772   ExpectAllMementoValuesEqualTo(kTestMementoValue);
    773   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    774   VerifyExpectationsThenShutdownResetter();
    775 }
    776 
    777 TEST_F(AutomaticProfileResetterTestDryRun, AlreadyHadPrefHostedMemento) {
    778   memento_in_prefs().StoreValue(kTestMementoValue);
    779 
    780   SetTestingProgram(ConstructProgram(true, true));
    781   SetTestingHashSeed(kTestHashSeed);
    782 
    783   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    784   mock_delegate().ExpectCallsToGetterMethods();
    785   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x03u));
    786 
    787   UnleashResetterAndWait();
    788 
    789   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    790   VerifyExpectationsThenShutdownResetter();
    791 
    792   EXPECT_EQ(kTestMementoValue, memento_in_prefs().ReadValue());
    793   EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
    794   EXPECT_EQ(std::string(), memento_in_file().ReadValue());
    795 }
    796 
    797 TEST_F(AutomaticProfileResetterTestDryRun, AlreadyHadLocalStateHostedMemento) {
    798   memento_in_local_state().StoreValue(kTestMementoValue);
    799 
    800   SetTestingProgram(ConstructProgram(true, true));
    801   SetTestingHashSeed(kTestHashSeed);
    802 
    803   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    804   mock_delegate().ExpectCallsToGetterMethods();
    805   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x05u));
    806 
    807   UnleashResetterAndWait();
    808 
    809   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    810   VerifyExpectationsThenShutdownResetter();
    811 
    812   EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
    813   EXPECT_EQ(kTestMementoValue, memento_in_local_state().ReadValue());
    814   EXPECT_EQ(std::string(), memento_in_file().ReadValue());
    815 }
    816 
    817 TEST_F(AutomaticProfileResetterTestDryRun, AlreadyHadFileHostedMemento) {
    818   memento_in_file().StoreValue(kTestMementoValue);
    819 
    820   SetTestingProgram(ConstructProgram(true, true));
    821   SetTestingHashSeed(kTestHashSeed);
    822 
    823   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    824   mock_delegate().ExpectCallsToGetterMethods();
    825   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x09u));
    826 
    827   UnleashResetterAndWait();
    828 
    829   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    830   VerifyExpectationsThenShutdownResetter();
    831 
    832   EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
    833   EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
    834   EXPECT_EQ(kTestMementoValue, memento_in_file().ReadValue());
    835 }
    836 
    837 TEST_F(AutomaticProfileResetterTestDryRun, DoNothingWhenResourcesAreMissing) {
    838   SetTestingProgram(std::string());
    839   SetTestingHashSeed(std::string());
    840 
    841   // No calls are expected to the delegate.
    842 
    843   UnleashResetterAndWait();
    844 
    845   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    846   VerifyExpectationsThenShutdownResetter();
    847 
    848   ExpectAllMementoValuesEqualTo(std::string());
    849 }
    850 
    851 TEST_F(AutomaticProfileResetterTest, CriteriaNotSatisfied) {
    852   SetTestingProgram(ConstructProgramToExerciseCriteria(false, true, true));
    853   SetTestingHashSeed(kTestHashSeed);
    854 
    855   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    856   mock_delegate().ExpectCallsToGetterMethods();
    857   EXPECT_CALL(resetter(), ReportStatistics(0x1fu, 0x00u));
    858 
    859   UnleashResetterAndWait();
    860 
    861   EXPECT_FALSE(resetter().ShouldShowResetBanner());
    862   VerifyExpectationsThenShutdownResetter();
    863 
    864   ExpectAllMementoValuesEqualTo(std::string());
    865 }
    866 
    867 TEST_F(AutomaticProfileResetterTest, OddCriteriaSatisfied) {
    868   SetTestingProgram(ConstructProgramToExerciseCriteria(true, true, false));
    869   SetTestingHashSeed(kTestHashSeed);
    870 
    871   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    872   mock_delegate().ExpectCallsToGetterMethods();
    873   mock_delegate().ExpectCallToShowPrompt();
    874   EXPECT_CALL(resetter(), ReportStatistics(0x15u, 0x01u));
    875 
    876   UnleashResetterAndWait();
    877 
    878   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    879   VerifyExpectationsThenShutdownResetter();
    880 }
    881 
    882 TEST_F(AutomaticProfileResetterTest, EvenCriteriaSatisfied) {
    883   SetTestingProgram(ConstructProgramToExerciseCriteria(true, false, true));
    884   SetTestingHashSeed(kTestHashSeed);
    885 
    886   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    887   mock_delegate().ExpectCallsToGetterMethods();
    888   mock_delegate().ExpectCallToShowPrompt();
    889   EXPECT_CALL(resetter(), ReportStatistics(0x0au, 0x01u));
    890 
    891   UnleashResetterAndWait();
    892 
    893   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    894   VerifyExpectationsThenShutdownResetter();
    895 }
    896 
    897 #if defined(GOOGLE_CHROME_BUILD)
    898 TEST_F(AutomaticProfileResetterTest, ProgramSetThroughVariationParams) {
    899   SetTestingProgram(ConstructProgram(true, true));
    900   SetTestingHashSeed(kTestHashSeed);
    901   AllowInjectingTestDataThroughVariationParams(true);
    902 
    903   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    904   mock_delegate().ExpectCallsToGetterMethods();
    905   mock_delegate().ExpectCallToShowPrompt();
    906   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
    907   EXPECT_CALL(resetter(), ReportPromptResult(
    908       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
    909 
    910   UnleashResetterAndWait();
    911   resetter().NotifyDidShowResetBubble();
    912 
    913   ExpectAllMementoValuesEqualTo(kTestMementoValue);
    914   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    915   VerifyExpectationsThenShutdownResetter();
    916 }
    917 #endif
    918 
    919 TEST_F(AutomaticProfileResetterTest, ConditionsSatisfiedAndInvalidMementos) {
    920   memento_in_prefs().StoreValue(kTestInvalidMementoValue);
    921   memento_in_local_state().StoreValue(kTestInvalidMementoValue);
    922   memento_in_file().StoreValue(kTestInvalidMementoValue);
    923 
    924   SetTestingProgram(ConstructProgram(true, true));
    925   SetTestingHashSeed(kTestHashSeed);
    926 
    927   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    928   mock_delegate().ExpectCallsToGetterMethods();
    929   mock_delegate().ExpectCallToShowPrompt();
    930   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
    931   EXPECT_CALL(resetter(), ReportPromptResult(
    932       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
    933 
    934   UnleashResetterAndWait();
    935   resetter().NotifyDidShowResetBubble();
    936 
    937   ExpectAllMementoValuesEqualTo(kTestMementoValue);
    938   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    939   VerifyExpectationsThenShutdownResetter();
    940 }
    941 
    942 TEST_F(AutomaticProfileResetterTest, PrefHostedMementoPreventsPrompt) {
    943   memento_in_prefs().StoreValue(kTestMementoValue);
    944 
    945   SetTestingProgram(ConstructProgram(true, true));
    946   SetTestingHashSeed(kTestHashSeed);
    947 
    948   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    949   mock_delegate().ExpectCallsToGetterMethods();
    950   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x03u));
    951 
    952   UnleashResetterAndWait();
    953 
    954   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    955   VerifyExpectationsThenShutdownResetter();
    956 
    957   EXPECT_EQ(kTestMementoValue, memento_in_prefs().ReadValue());
    958   EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
    959   EXPECT_EQ(std::string(), memento_in_file().ReadValue());
    960 }
    961 
    962 TEST_F(AutomaticProfileResetterTest, LocalStateHostedMementoPreventsPrompt) {
    963   memento_in_local_state().StoreValue(kTestMementoValue);
    964 
    965   SetTestingProgram(ConstructProgram(true, true));
    966   SetTestingHashSeed(kTestHashSeed);
    967 
    968   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    969   mock_delegate().ExpectCallsToGetterMethods();
    970   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x05u));
    971 
    972   UnleashResetterAndWait();
    973 
    974   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    975   VerifyExpectationsThenShutdownResetter();
    976 
    977   EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
    978   EXPECT_EQ(kTestMementoValue, memento_in_local_state().ReadValue());
    979   EXPECT_EQ(std::string(), memento_in_file().ReadValue());
    980 }
    981 
    982 TEST_F(AutomaticProfileResetterTest, FileHostedMementoPreventsPrompt) {
    983   memento_in_file().StoreValue(kTestMementoValue);
    984 
    985   SetTestingProgram(ConstructProgram(true, true));
    986   SetTestingHashSeed(kTestHashSeed);
    987 
    988   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
    989   mock_delegate().ExpectCallsToGetterMethods();
    990   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x09u));
    991 
    992   UnleashResetterAndWait();
    993 
    994   EXPECT_TRUE(resetter().ShouldShowResetBanner());
    995   VerifyExpectationsThenShutdownResetter();
    996 
    997   EXPECT_EQ(std::string(), memento_in_prefs().ReadValue());
    998   EXPECT_EQ(std::string(), memento_in_local_state().ReadValue());
    999   EXPECT_EQ(kTestMementoValue, memento_in_file().ReadValue());
   1000 }
   1001 
   1002 TEST_F(AutomaticProfileResetterTest, DoNothingWhenResourcesAreMissing) {
   1003   SetTestingProgram(std::string());
   1004   SetTestingHashSeed(std::string());
   1005 
   1006   // No calls are expected to the delegate.
   1007 
   1008   UnleashResetterAndWait();
   1009 
   1010   EXPECT_FALSE(resetter().ShouldShowResetBanner());
   1011   VerifyExpectationsThenShutdownResetter();
   1012 
   1013   ExpectAllMementoValuesEqualTo(std::string());
   1014 }
   1015 
   1016 TEST_F(AutomaticProfileResetterTest, PromptSuppressed) {
   1017   OrchestrateThroughEvaluationFlow();
   1018 
   1019   VerifyExpectationsThenShutdownResetter();
   1020 
   1021   ExpectAllMementoValuesEqualTo(std::string());
   1022 }
   1023 
   1024 TEST_F(AutomaticProfileResetterTest, PromptNotSupported) {
   1025   SetTestingProgram(ConstructProgram(true, true));
   1026   SetTestingHashSeed(kTestHashSeed);
   1027 
   1028   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1029   mock_delegate().ExpectCallsToGetterMethods();
   1030   EXPECT_CALL(mock_delegate(), TriggerPrompt())
   1031       .WillOnce(testing::Return(false));
   1032   EXPECT_CALL(resetter(), ReportStatistics(0x03u, 0x01u));
   1033   EXPECT_CALL(resetter(), ReportPromptResult(
   1034       AutomaticProfileResetter::PROMPT_NOT_TRIGGERED));
   1035 
   1036   UnleashResetterAndWait();
   1037 
   1038   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1039   EXPECT_TRUE(resetter().ShouldShowResetBanner());
   1040   VerifyExpectationsThenShutdownResetter();
   1041 }
   1042 
   1043 TEST_F(AutomaticProfileResetterTest, PromptIgnored) {
   1044   OrchestrateThroughEvaluationFlow();
   1045 
   1046   EXPECT_CALL(resetter(), ReportPromptResult(
   1047       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1048   resetter().NotifyDidShowResetBubble();
   1049   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1050   VerifyExpectationsThenShutdownResetter();
   1051 }
   1052 
   1053 TEST_F(AutomaticProfileResetterTest, PromptActionReset) {
   1054   OrchestrateThroughEvaluationFlow();
   1055 
   1056   EXPECT_CALL(resetter(), ReportPromptResult(
   1057       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1058   resetter().NotifyDidShowResetBubble();
   1059   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1060   testing::Mock::VerifyAndClearExpectations(&resetter());
   1061 
   1062   mock_delegate().ExpectCallToTriggerReset(false);
   1063   EXPECT_CALL(resetter(), ReportPromptResult(
   1064       AutomaticProfileResetter::PROMPT_ACTION_RESET));
   1065   resetter().TriggerProfileReset(false /*send_feedback*/);
   1066   testing::Mock::VerifyAndClearExpectations(&resetter());
   1067   testing::Mock::VerifyAndClearExpectations(&mock_delegate());
   1068 
   1069   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1070   mock_delegate().EmulateProfileResetCompleted();
   1071   EXPECT_FALSE(resetter().ShouldShowResetBanner());
   1072   VerifyExpectationsThenShutdownResetter();
   1073 }
   1074 
   1075 TEST_F(AutomaticProfileResetterTest, PromptActionResetWithFeedback) {
   1076   OrchestrateThroughEvaluationFlow();
   1077 
   1078   EXPECT_CALL(resetter(), ReportPromptResult(
   1079       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1080   resetter().NotifyDidShowResetBubble();
   1081   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1082   testing::Mock::VerifyAndClearExpectations(&resetter());
   1083 
   1084   mock_delegate().ExpectCallToTriggerReset(true);
   1085   EXPECT_CALL(resetter(), ReportPromptResult(
   1086       AutomaticProfileResetter::PROMPT_ACTION_RESET));
   1087   resetter().TriggerProfileReset(true /*send_feedback*/);
   1088   testing::Mock::VerifyAndClearExpectations(&resetter());
   1089   testing::Mock::VerifyAndClearExpectations(&mock_delegate());
   1090 
   1091   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1092   mock_delegate().EmulateProfileResetCompleted();
   1093   EXPECT_FALSE(resetter().ShouldShowResetBanner());
   1094   VerifyExpectationsThenShutdownResetter();
   1095 }
   1096 
   1097 TEST_F(AutomaticProfileResetterTest, PromptActionNoReset) {
   1098   OrchestrateThroughEvaluationFlow();
   1099 
   1100   EXPECT_CALL(resetter(), ReportPromptResult(
   1101       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1102   resetter().NotifyDidShowResetBubble();
   1103   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1104   testing::Mock::VerifyAndClearExpectations(&resetter());
   1105 
   1106   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1107   EXPECT_CALL(resetter(), ReportPromptResult(
   1108       AutomaticProfileResetter::PROMPT_ACTION_NO_RESET));
   1109   resetter().SkipProfileReset();
   1110   EXPECT_FALSE(resetter().ShouldShowResetBanner());
   1111   VerifyExpectationsThenShutdownResetter();
   1112 }
   1113 
   1114 TEST_F(AutomaticProfileResetterTest, PromptFollowedByWebUIReset) {
   1115   OrchestrateThroughEvaluationFlow();
   1116 
   1117   EXPECT_CALL(resetter(), ReportPromptResult(
   1118       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1119   resetter().NotifyDidShowResetBubble();
   1120   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1121   testing::Mock::VerifyAndClearExpectations(&resetter());
   1122 
   1123   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1124   resetter().NotifyDidOpenWebUIResetDialog();
   1125   testing::Mock::VerifyAndClearExpectations(&mock_delegate());
   1126 
   1127   EXPECT_CALL(resetter(), ReportPromptResult(
   1128       AutomaticProfileResetter::PROMPT_FOLLOWED_BY_WEBUI_RESET));
   1129   resetter().NotifyDidCloseWebUIResetDialog(true);
   1130   EXPECT_TRUE(resetter().ShouldShowResetBanner());
   1131   VerifyExpectationsThenShutdownResetter();
   1132 }
   1133 
   1134 TEST_F(AutomaticProfileResetterTest, PromptFollowedByWebUINoReset) {
   1135   OrchestrateThroughEvaluationFlow();
   1136 
   1137   EXPECT_CALL(resetter(), ReportPromptResult(
   1138       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1139   resetter().NotifyDidShowResetBubble();
   1140   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1141   testing::Mock::VerifyAndClearExpectations(&resetter());
   1142 
   1143   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1144   resetter().NotifyDidOpenWebUIResetDialog();
   1145   testing::Mock::VerifyAndClearExpectations(&mock_delegate());
   1146 
   1147   EXPECT_CALL(resetter(), ReportPromptResult(
   1148       AutomaticProfileResetter::PROMPT_FOLLOWED_BY_WEBUI_NO_RESET));
   1149   resetter().NotifyDidCloseWebUIResetDialog(false);
   1150   EXPECT_TRUE(resetter().ShouldShowResetBanner());
   1151   VerifyExpectationsThenShutdownResetter();
   1152 }
   1153 
   1154 TEST_F(AutomaticProfileResetterTest, PromptFollowedByIncidentalWebUIReset) {
   1155   OrchestrateThroughEvaluationFlow();
   1156 
   1157   EXPECT_CALL(resetter(), ReportPromptResult(
   1158       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1159   resetter().NotifyDidShowResetBubble();
   1160   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1161   testing::Mock::VerifyAndClearExpectations(&resetter());
   1162 
   1163   // Missing NotifyDidOpenWebUIResetDialog().
   1164   // This can arise if a settings page was already opened at the time the prompt
   1165   // was triggered, and this already opened dialog was used to initiate a reset
   1166   // after having dismissed the prompt.
   1167 
   1168   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1169   EXPECT_CALL(resetter(), ReportPromptResult(
   1170       AutomaticProfileResetter::PROMPT_FOLLOWED_BY_WEBUI_RESET));
   1171   resetter().NotifyDidCloseWebUIResetDialog(true);
   1172   EXPECT_TRUE(resetter().ShouldShowResetBanner());
   1173   VerifyExpectationsThenShutdownResetter();
   1174 }
   1175 
   1176 TEST_F(AutomaticProfileResetterTest, PromptSuppressedButHadWebUIReset) {
   1177   OrchestrateThroughEvaluationFlow();
   1178 
   1179   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1180   resetter().NotifyDidOpenWebUIResetDialog();
   1181   testing::Mock::VerifyAndClearExpectations(&mock_delegate());
   1182 
   1183   EXPECT_CALL(resetter(), ReportPromptResult(
   1184       AutomaticProfileResetter::PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_RESET));
   1185   resetter().NotifyDidCloseWebUIResetDialog(true);
   1186   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1187   EXPECT_TRUE(resetter().ShouldShowResetBanner());
   1188   VerifyExpectationsThenShutdownResetter();
   1189 }
   1190 
   1191 TEST_F(AutomaticProfileResetterTest, PromptSuppressedButHadWebUINoReset) {
   1192   OrchestrateThroughEvaluationFlow();
   1193 
   1194   EXPECT_CALL(mock_delegate(), DismissPrompt());
   1195   resetter().NotifyDidOpenWebUIResetDialog();
   1196   testing::Mock::VerifyAndClearExpectations(&mock_delegate());
   1197 
   1198   EXPECT_CALL(resetter(), ReportPromptResult(AutomaticProfileResetter::
   1199       PROMPT_NOT_SHOWN_BUBBLE_BUT_HAD_WEBUI_NO_RESET));
   1200   resetter().NotifyDidCloseWebUIResetDialog(false);
   1201   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1202   EXPECT_TRUE(resetter().ShouldShowResetBanner());
   1203   VerifyExpectationsThenShutdownResetter();
   1204 }
   1205 
   1206 TEST_F(AutomaticProfileResetterTest, BannerDismissed) {
   1207   OrchestrateThroughEvaluationFlow();
   1208 
   1209   EXPECT_CALL(resetter(), ReportPromptResult(
   1210       AutomaticProfileResetter::PROMPT_SHOWN_BUBBLE));
   1211   resetter().NotifyDidShowResetBubble();
   1212   ExpectAllMementoValuesEqualTo(kTestMementoValue);
   1213   testing::Mock::VerifyAndClearExpectations(&resetter());
   1214 
   1215   resetter().NotifyDidCloseWebUIResetBanner();
   1216 
   1217   EXPECT_TRUE(resetter().IsResetPromptFlowActive());
   1218   EXPECT_FALSE(resetter().ShouldShowResetBanner());
   1219 
   1220   // Note: we use strict mocks, so this also checks the bubble is not closed.
   1221   VerifyExpectationsThenShutdownResetter();
   1222 }
   1223 
   1224 TEST_F(AutomaticProfileResetterTest, BannerDismissedWhilePromptSuppressed) {
   1225   OrchestrateThroughEvaluationFlow();
   1226 
   1227   resetter().NotifyDidCloseWebUIResetBanner();
   1228 
   1229   EXPECT_TRUE(resetter().IsResetPromptFlowActive());
   1230   EXPECT_FALSE(resetter().ShouldShowResetBanner());
   1231   VerifyExpectationsThenShutdownResetter();
   1232 
   1233   ExpectAllMementoValuesEqualTo(std::string());
   1234 }
   1235 
   1236 // Please see comments above ConstructProgramToCheckPreferences() to understand
   1237 // how the following tests work.
   1238 
   1239 TEST_F(AutomaticProfileResetterTest, InputUserPreferencesCorrect) {
   1240   SetTestingProgram(ConstructProgramToCheckPreferences());
   1241   SetTestingHashSeed(kTestHashSeed);
   1242 
   1243   PrefService* prefs = profile()->GetPrefs();
   1244   prefs->SetString(kTestPreferencePath, kTestPreferenceValue);
   1245 
   1246   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1247   mock_delegate().ExpectCallsToGetterMethods();
   1248   uint32 expected_mask = HAS_EXPECTED_USER_PREFERENCE |
   1249                          USER_PREFERENCE_IS_USER_CONTROLLED;
   1250   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1251 
   1252   UnleashResetterAndWait();
   1253 }
   1254 
   1255 TEST_F(AutomaticProfileResetterTest, InputLocalStateCorrect) {
   1256   SetTestingProgram(ConstructProgramToCheckPreferences());
   1257   SetTestingHashSeed(kTestHashSeed);
   1258 
   1259   PrefService* prefs = local_state();
   1260   prefs->SetString(kTestPreferencePath, kTestPreferenceValue);
   1261 
   1262   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1263   mock_delegate().ExpectCallsToGetterMethods();
   1264   uint32 expected_mask = HAS_EXPECTED_LOCAL_STATE_PREFERENCE |
   1265                          LOCAL_STATE_IS_USER_CONTROLLED;
   1266   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1267 
   1268   UnleashResetterAndWait();
   1269 }
   1270 
   1271 TEST_F(AutomaticProfileResetterTest, InputManagedUserPreferencesCorrect) {
   1272   SetTestingProgram(ConstructProgramToCheckPreferences());
   1273   SetTestingHashSeed(kTestHashSeed);
   1274 
   1275   TestingPrefServiceSyncable* prefs = profile()->GetTestingPrefService();
   1276   prefs->SetManagedPref(kTestPreferencePath,
   1277                         new base::StringValue(kTestPreferenceValue));
   1278 
   1279   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1280   mock_delegate().ExpectCallsToGetterMethods();
   1281   uint32 expected_mask = HAS_EXPECTED_USER_PREFERENCE;
   1282   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1283 
   1284   UnleashResetterAndWait();
   1285 }
   1286 
   1287 TEST_F(AutomaticProfileResetterTest, InputManagedLocalStateCorrect) {
   1288   SetTestingProgram(ConstructProgramToCheckPreferences());
   1289   SetTestingHashSeed(kTestHashSeed);
   1290 
   1291   TestingPrefServiceSimple* prefs = local_state();
   1292   prefs->SetManagedPref(kTestPreferencePath,
   1293                         new base::StringValue(kTestPreferenceValue));
   1294 
   1295   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1296   mock_delegate().ExpectCallsToGetterMethods();
   1297   uint32 expected_mask = HAS_EXPECTED_LOCAL_STATE_PREFERENCE;
   1298   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1299 
   1300   UnleashResetterAndWait();
   1301 }
   1302 
   1303 // Please see comments above ConstructProgramToCheckSearchEngines() to
   1304 // understand how the following tests work.
   1305 
   1306 TEST_F(AutomaticProfileResetterTest, InputDefaultSearchProviderCorrect) {
   1307   SetTestingProgram(ConstructProgramToCheckSearchEngines());
   1308   SetTestingHashSeed(kTestHashSeed);
   1309 
   1310   mock_delegate().emulated_default_search_provider_details().SetString(
   1311       kSearchURLAttributeKey, kTestSearchURL);
   1312 
   1313   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1314   mock_delegate().ExpectCallsToGetterMethods();
   1315   uint32 expected_mask = HAS_EXPECTED_DEFAULT_SEARCH_PROVIDER |
   1316                          DEFAULT_SEARCH_PROVIDER_IS_USER_CONTROLLED;
   1317   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1318 
   1319   UnleashResetterAndWait();
   1320 }
   1321 
   1322 TEST_F(AutomaticProfileResetterTest, InputSearchProviderManagedCorrect) {
   1323   SetTestingProgram(ConstructProgramToCheckSearchEngines());
   1324   SetTestingHashSeed(kTestHashSeed);
   1325 
   1326   mock_delegate().emulated_default_search_provider_details().SetString(
   1327       kSearchURLAttributeKey, kTestSearchURL);
   1328   mock_delegate().set_emulated_is_default_search_provider_managed(true);
   1329 
   1330   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1331   mock_delegate().ExpectCallsToGetterMethods();
   1332   uint32 expected_mask = HAS_EXPECTED_DEFAULT_SEARCH_PROVIDER;
   1333   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1334 
   1335   UnleashResetterAndWait();
   1336 }
   1337 
   1338 TEST_F(AutomaticProfileResetterTest, InputSearchProvidersCorrect) {
   1339   SetTestingProgram(ConstructProgramToCheckSearchEngines());
   1340   SetTestingHashSeed(kTestHashSeed);
   1341 
   1342   base::DictionaryValue* search_provider_1 = new base::DictionaryValue;
   1343   base::DictionaryValue* search_provider_2 = new base::DictionaryValue;
   1344   search_provider_1->SetString(kSearchURLAttributeKey, kTestSearchURL);
   1345   search_provider_2->SetString(kSearchURLAttributeKey, kTestSearchURL2);
   1346   mock_delegate().emulated_search_providers_details().Append(search_provider_1);
   1347   mock_delegate().emulated_search_providers_details().Append(search_provider_2);
   1348 
   1349   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1350   mock_delegate().ExpectCallsToGetterMethods();
   1351   uint32 expected_mask = DEFAULT_SEARCH_PROVIDER_IS_USER_CONTROLLED |
   1352                          HAS_EXPECTED_PREPOPULATED_SEARCH_PROVIDER_1 |
   1353                          HAS_EXPECTED_PREPOPULATED_SEARCH_PROVIDER_2;
   1354   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1355 
   1356   UnleashResetterAndWait();
   1357 }
   1358 
   1359 // Please see comments above ConstructProgramToCheckLoadedModuleDigests() to
   1360 // understand how the following tests work.
   1361 
   1362 TEST_F(AutomaticProfileResetterTest, InputModuleDigestsCorrect) {
   1363   SetTestingProgram(ConstructProgramToCheckLoadedModuleDigests());
   1364   SetTestingHashSeed(kTestHashSeed);
   1365 
   1366   mock_delegate().emulated_loaded_module_digests().AppendString(
   1367       kTestModuleDigest);
   1368   mock_delegate().emulated_loaded_module_digests().AppendString(
   1369       kTestModuleDigest2);
   1370 
   1371   mock_delegate().ExpectCallsToDependenciesSetUpMethods();
   1372   mock_delegate().ExpectCallsToGetterMethods();
   1373   uint32 expected_mask =
   1374       HAS_EXPECTED_MODULE_DIGEST_1 | HAS_EXPECTED_MODULE_DIGEST_2;
   1375   EXPECT_CALL(resetter(), ReportStatistics(0x00u, expected_mask));
   1376 
   1377   UnleashResetterAndWait();
   1378 }
   1379 
   1380 }  // namespace
   1381