chrome/browser/profile_resetter/automatic_profile_resetter_delegate_unittest.cc

   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_delegate.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/run_loop.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/string_split.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/test/values_test_util.h"
  20 #include "base/values.h"
  21 #include "chrome/app/chrome_command_ids.h"
  22 #include "chrome/browser/chrome_notification_types.h"
  23 #include "chrome/browser/extensions/extension_service.h"
  24 #include "chrome/browser/extensions/extension_service_test_base.h"
  25 #include "chrome/browser/google/google_brand.h"
  26 #include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
  27 #include "chrome/browser/profile_resetter/profile_reset_global_error.h"
  28 #include "chrome/browser/search_engines/template_url_service_factory.h"
  29 #include "chrome/browser/search_engines/template_url_service_factory_test_util.h"
  30 #include "chrome/browser/ui/global_error/global_error.h"
  31 #include "chrome/browser/ui/global_error/global_error_service.h"
  32 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
  33 #include "chrome/common/pref_names.h"
  34 #include "chrome/test/base/testing_pref_service_syncable.h"
  35 #include "chrome/test/base/testing_profile.h"
  36 #include "components/search_engines/default_search_manager.h"
  37 #include "components/search_engines/template_url_prepopulate_data.h"
  38 #include "components/search_engines/template_url_service.h"
  39 #include "content/public/browser/notification_service.h"
  40 #include "net/http/http_response_headers.h"
  41 #include "net/url_request/test_url_fetcher_factory.h"
  42 #include "testing/gmock/include/gmock/gmock.h"
  43 #include "testing/gtest/include/gtest/gtest.h"
  44
  45 #if defined(OS_WIN)
  46 #include "chrome/browser/enumerate_modules_model_win.h"
  47 #endif
  48
  49 namespace {
  50
  51 const char kTestBrandcode[] = "FOOBAR";
  52
  53 const char kTestHomepage[] = "http://google.com";
  54 const char kTestBrandedHomepage[] = "http://example.com";
  55
  56 const ProfileResetter::ResettableFlags kResettableAspectsForTest =
  57     ProfileResetter::ALL & ~ProfileResetter::COOKIES_AND_SITE_DATA;
  58
  59 // Helpers -------------------------------------------------------------------
  60
  61 // A testing version of the AutomaticProfileResetterDelegate that differs from
  62 // the real one only in that it has its feedback reporting mocked out, and it
  63 // will not reset COOKIES_AND_SITE_DATA, due to difficulties to set up some
  64 // required URLRequestContexts in unit tests.
  65 class AutomaticProfileResetterDelegateUnderTest
  66     : public AutomaticProfileResetterDelegateImpl {
  67  public:
  68   explicit AutomaticProfileResetterDelegateUnderTest(Profile* profile)
  69       : AutomaticProfileResetterDelegateImpl(
  70             profile, kResettableAspectsForTest) {}
  71   virtual ~AutomaticProfileResetterDelegateUnderTest() {}
  72
  73   MOCK_CONST_METHOD1(SendFeedback, void(const std::string&));
  74
  75  private:
  76   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterDelegateUnderTest);
  77 };
  78
  79 class MockCallbackTarget {
  80  public:
  81   MockCallbackTarget() {}
  82   ~MockCallbackTarget() {}
  83
  84   MOCK_CONST_METHOD0(Run, void(void));
  85
  86   base::Closure CreateClosure() {
  87     return base::Bind(&MockCallbackTarget::Run, base::Unretained(this));
  88   }
  89
  90  private:
  91   DISALLOW_COPY_AND_ASSIGN(MockCallbackTarget);
  92 };
  93
  94 // Returns the details of the default search provider from |prefs| in a format
  95 // suitable for usage as |expected_details| in ExpectDetailsMatch().
  96 const base::DictionaryValue* GetDefaultSearchProviderDetailsFromPrefs(
  97     const PrefService* prefs) {
  98   return prefs->GetDictionary(
  99       DefaultSearchManager::kDefaultSearchProviderDataPrefName);
 100 }
 101
 102 // Verifies that the |details| of a search engine as provided by the delegate
 103 // are correct in comparison to the |expected_details| coming from the Prefs.
 104 void ExpectDetailsMatch(const base::DictionaryValue& expected_details,
 105                         const base::DictionaryValue& details) {
 106   for (base::DictionaryValue::Iterator it(expected_details); !it.IsAtEnd();
 107        it.Advance()) {
 108     SCOPED_TRACE(testing::Message("Key: ") << it.key());
 109     if (it.key() == "enabled" || it.key() == "synced_guid") {
 110       // These attributes should not be present.
 111       EXPECT_FALSE(details.HasKey(it.key()));
 112       continue;
 113     }
 114     const base::Value* expected_value = &it.value();
 115     const base::Value* actual_value = NULL;
 116     ASSERT_TRUE(details.Get(it.key(), &actual_value));
 117
 118     // Ignore ID as it is dynamically assigned by the TemplateURLService.
 119     // last_modified may get updated during a run, so ignore value differences.
 120     if (it.key() != "id" && it.key() != "last_modified") {
 121       // Everything else is the same format.
 122       EXPECT_TRUE(actual_value->Equals(expected_value))
 123           << "Expected: " << *expected_value << ". Actual: " << *actual_value;
 124     }
 125   }
 126 }
 127
 128 // If |simulate_failure| is false, then replies to the pending request on
 129 // |fetcher| with a brandcoded config that only specifies a home page URL.
 130 // If |simulate_failure| is true, replies with 404.
 131 void ServicePendingBrancodedConfigFetch(net::TestURLFetcher* fetcher,
 132                                         bool simulate_failure) {
 133   const char kBrandcodedXmlSettings[] =
 134       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 135       "<response protocol=\"3.0\" server=\"prod\">"
 136         "<app appid=\"{8A69D345-D564-463C-AFF1-A69D9E530F96}\" status=\"ok\">"
 137           "<data index=\"skipfirstrunui-importsearch-defaultbrowser\" "
 138           "name=\"install\" status=\"ok\">"
 139             "{\"homepage\" : \"$1\"}"
 140           "</data>"
 141         "</app>"
 142       "</response>";
 143
 144   fetcher->set_response_code(simulate_failure ? 404 : 200);
 145   scoped_refptr<net::HttpResponseHeaders> response_headers(
 146       new net::HttpResponseHeaders(""));
 147   response_headers->AddHeader("Content-Type: text/xml");
 148   fetcher->set_response_headers(response_headers);
 149   if (!simulate_failure) {
 150     std::string response(kBrandcodedXmlSettings);
 151     size_t placeholder_index = response.find("$1");
 152     ASSERT_NE(std::string::npos, placeholder_index);
 153     response.replace(placeholder_index, 2, kTestBrandedHomepage);
 154     fetcher->SetResponseString(response);
 155   }
 156   fetcher->delegate()->OnURLFetchComplete(fetcher);
 157 }
 158
 159
 160 // Test fixture --------------------------------------------------------------
 161
 162 // ExtensionServiceTestBase sets up a TestingProfile with the ExtensionService,
 163 // we then add the TemplateURLService, so the ProfileResetter can be exercised.
 164 class AutomaticProfileResetterDelegateTest
 165     : public extensions::ExtensionServiceTestBase {
 166  protected:
 167   AutomaticProfileResetterDelegateTest() {}
 168   ~AutomaticProfileResetterDelegateTest() override {}
 169
 170   void SetUp() override {
 171     extensions::ExtensionServiceTestBase::SetUp();
 172     ExtensionServiceInitParams params = CreateDefaultInitParams();
 173     params.pref_file.clear();  // Prescribes a TestingPrefService to be created.
 174     InitializeExtensionService(params);
 175     template_url_service_test_util_.reset(
 176         new TemplateURLServiceFactoryTestUtil(profile_.get()));
 177     resetter_delegate_.reset(
 178         new AutomaticProfileResetterDelegateUnderTest(profile()));
 179   }
 180
 181   void TearDown() override {
 182     resetter_delegate_.reset();
 183     template_url_service_test_util_.reset();
 184     extensions::ExtensionServiceTestBase::TearDown();
 185   }
 186
 187   scoped_ptr<TemplateURL> CreateTestTemplateURL() {
 188     TemplateURLData data;
 189
 190     data.SetURL("http://example.com/search?q={searchTerms}");
 191     data.suggestions_url = "http://example.com/suggest?q={searchTerms}";
 192     data.instant_url = "http://example.com/instant?q={searchTerms}";
 193     data.image_url = "http://example.com/image?q={searchTerms}";
 194     data.search_url_post_params = "search-post-params";
 195     data.suggestions_url_post_params = "suggest-post-params";
 196     data.instant_url_post_params = "instant-post-params";
 197     data.image_url_post_params = "image-post-params";
 198
 199     data.favicon_url = GURL("http://example.com/favicon.ico");
 200     data.new_tab_url = "http://example.com/newtab.html";
 201     data.alternate_urls.push_back("http://example.com/s?q={searchTerms}");
 202
 203     data.short_name = base::ASCIIToUTF16("name");
 204     data.SetKeyword(base::ASCIIToUTF16("keyword"));
 205     data.search_terms_replacement_key = "search-terms-replacment-key";
 206     data.prepopulate_id = 42;
 207     data.input_encodings.push_back("UTF-8");
 208     data.safe_for_autoreplace = true;
 209
 210     return scoped_ptr<TemplateURL>(new TemplateURL(data));
 211   }
 212
 213   void ExpectNoPendingBrandcodedConfigFetch() {
 214     EXPECT_FALSE(test_url_fetcher_factory_.GetFetcherByID(0));
 215   }
 216
 217   void ExpectAndServicePendingBrandcodedConfigFetch(bool simulate_failure) {
 218     net::TestURLFetcher* fetcher = test_url_fetcher_factory_.GetFetcherByID(0);
 219     ASSERT_TRUE(fetcher);
 220     EXPECT_THAT(fetcher->upload_data(),
 221                 testing::HasSubstr(kTestBrandcode));
 222     ServicePendingBrancodedConfigFetch(fetcher, simulate_failure);
 223   }
 224
 225   void ExpectResetPromptState(bool active) {
 226     GlobalErrorService* global_error_service =
 227         GlobalErrorServiceFactory::GetForProfile(profile());
 228     GlobalError* global_error = global_error_service->
 229         GetGlobalErrorByMenuItemCommandID(IDC_SHOW_SETTINGS_RESET_BUBBLE);
 230     EXPECT_EQ(active, !!global_error);
 231   }
 232
 233   AutomaticProfileResetterDelegateUnderTest* resetter_delegate() {
 234     return resetter_delegate_.get();
 235   }
 236
 237   TemplateURLServiceFactoryTestUtil* template_url_service_test_util() {
 238     return template_url_service_test_util_.get();
 239   }
 240
 241  private:
 242   scoped_ptr<TemplateURLServiceFactoryTestUtil> template_url_service_test_util_;
 243   net::TestURLFetcherFactory test_url_fetcher_factory_;
 244   scoped_ptr<AutomaticProfileResetterDelegateUnderTest> resetter_delegate_;
 245
 246   DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterDelegateTest);
 247 };
 248
 249
 250 // Tests ---------------------------------------------------------------------
 251
 252 TEST_F(AutomaticProfileResetterDelegateTest,
 253        TriggerAndWaitOnModuleEnumeration) {
 254   // Expect ready_callback to be called just after the modules have been
 255   // enumerated. Fail if it is not called. Note: as the EnumerateModulesModel is
 256   // a global singleton, the callback might be invoked immediately if another
 257   // test-case (e.g. the one below) has already performed module enumeration.
 258   testing::StrictMock<MockCallbackTarget> mock_target;
 259   EXPECT_CALL(mock_target, Run());
 260   resetter_delegate()->RequestCallbackWhenLoadedModulesAreEnumerated(
 261       mock_target.CreateClosure());
 262   resetter_delegate()->EnumerateLoadedModulesIfNeeded();
 263   base::RunLoop().RunUntilIdle();
 264
 265   testing::Mock::VerifyAndClearExpectations(&mock_target);
 266
 267   // Expect ready_callback to be posted immediately when the modules have
 268   // already been enumerated.
 269   EXPECT_CALL(mock_target, Run());
 270   resetter_delegate()->RequestCallbackWhenLoadedModulesAreEnumerated(
 271       mock_target.CreateClosure());
 272   base::RunLoop().RunUntilIdle();
 273
 274 #if defined(OS_WIN)
 275   testing::Mock::VerifyAndClearExpectations(&mock_target);
 276
 277   // Expect ready_callback to be posted immediately even when the modules had
 278   // already been enumerated when the delegate was constructed.
 279   scoped_ptr<AutomaticProfileResetterDelegate> late_resetter_delegate(
 280       new AutomaticProfileResetterDelegateImpl(profile(),
 281                                                ProfileResetter::ALL));
 282
 283   EXPECT_CALL(mock_target, Run());
 284   late_resetter_delegate->RequestCallbackWhenLoadedModulesAreEnumerated(
 285       mock_target.CreateClosure());
 286   base::RunLoop().RunUntilIdle();
 287 #endif
 288 }
 289
 290 TEST_F(AutomaticProfileResetterDelegateTest, GetLoadedModuleNameDigests) {
 291   resetter_delegate()->EnumerateLoadedModulesIfNeeded();
 292   base::RunLoop().RunUntilIdle();
 293   scoped_ptr<base::ListValue> module_name_digests(
 294       resetter_delegate()->GetLoadedModuleNameDigests());
 295
 296   // Just verify that each element looks like an MD5 hash in hexadecimal, and
 297   // also that we have at least one element on Win.
 298   ASSERT_TRUE(module_name_digests);
 299   for (base::ListValue::const_iterator it = module_name_digests->begin();
 300        it != module_name_digests->end(); ++it) {
 301     std::string digest_hex;
 302     std::vector<uint8> digest_raw;
 303
 304     ASSERT_TRUE((*it)->GetAsString(&digest_hex));
 305     ASSERT_TRUE(base::HexStringToBytes(digest_hex, &digest_raw));
 306     EXPECT_EQ(16u, digest_raw.size());
 307   }
 308 #if defined(OS_WIN)
 309   EXPECT_LE(1u, module_name_digests->GetSize());
 310 #endif
 311 }
 312
 313 TEST_F(AutomaticProfileResetterDelegateTest, LoadAndWaitOnTemplateURLService) {
 314   // Expect ready_callback to be called just after the template URL service gets
 315   // initialized. Fail if it is not called, or called too early.
 316   testing::StrictMock<MockCallbackTarget> mock_target;
 317   resetter_delegate()->RequestCallbackWhenTemplateURLServiceIsLoaded(
 318       mock_target.CreateClosure());
 319   base::RunLoop().RunUntilIdle();
 320
 321   EXPECT_CALL(mock_target, Run());
 322   resetter_delegate()->LoadTemplateURLServiceIfNeeded();
 323   base::RunLoop().RunUntilIdle();
 324
 325   testing::Mock::VerifyAndClearExpectations(&mock_target);
 326
 327   // Expect ready_callback to be posted immediately when the template URL
 328   // service is already initialized.
 329   EXPECT_CALL(mock_target, Run());
 330   resetter_delegate()->RequestCallbackWhenTemplateURLServiceIsLoaded(
 331       mock_target.CreateClosure());
 332   base::RunLoop().RunUntilIdle();
 333
 334   testing::Mock::VerifyAndClearExpectations(&mock_target);
 335
 336   // Expect ready_callback to be posted immediately even when the template URL
 337   // service had already been initialized when the delegate was constructed.
 338   scoped_ptr<AutomaticProfileResetterDelegate> late_resetter_delegate(
 339       new AutomaticProfileResetterDelegateImpl(profile(),
 340                                                ProfileResetter::ALL));
 341
 342   EXPECT_CALL(mock_target, Run());
 343   late_resetter_delegate->RequestCallbackWhenTemplateURLServiceIsLoaded(
 344       mock_target.CreateClosure());
 345   base::RunLoop().RunUntilIdle();
 346 }
 347
 348 TEST_F(AutomaticProfileResetterDelegateTest,
 349        DefaultSearchProviderDataWhenNotManaged) {
 350   TemplateURLService* template_url_service =
 351       TemplateURLServiceFactory::GetForProfile(profile());
 352   template_url_service_test_util()->VerifyLoad();
 353
 354   // Check that the "managed state" and the details returned by the delegate are
 355   // correct. We verify the details against the data stored by
 356   // TemplateURLService into Prefs.
 357   scoped_ptr<TemplateURL> owned_custom_dsp(CreateTestTemplateURL());
 358   TemplateURL* custom_dsp = owned_custom_dsp.get();
 359   template_url_service->Add(owned_custom_dsp.release());
 360   template_url_service->SetUserSelectedDefaultSearchProvider(custom_dsp);
 361
 362   PrefService* prefs = profile()->GetPrefs();
 363   ASSERT_TRUE(prefs);
 364   scoped_ptr<base::DictionaryValue> dsp_details(
 365       resetter_delegate()->GetDefaultSearchProviderDetails());
 366   const base::DictionaryValue* expected_dsp_details =
 367       GetDefaultSearchProviderDetailsFromPrefs(prefs);
 368
 369   ExpectDetailsMatch(*expected_dsp_details, *dsp_details);
 370   EXPECT_FALSE(resetter_delegate()->IsDefaultSearchProviderManaged());
 371 }
 372
 373 TEST_F(AutomaticProfileResetterDelegateTest,
 374        DefaultSearchProviderDataWhenManaged) {
 375   const char kTestSearchURL[] = "http://example.com/search?q={searchTerms}";
 376   const char kTestName[] = "name";
 377   const char kTestKeyword[] = "keyword";
 378
 379   template_url_service_test_util()->VerifyLoad();
 380
 381   EXPECT_FALSE(resetter_delegate()->IsDefaultSearchProviderManaged());
 382
 383   // Set managed preferences to emulate a default search provider set by policy.
 384   template_url_service_test_util()->SetManagedDefaultSearchPreferences(
 385       true, kTestName, kTestKeyword, kTestSearchURL, std::string(),
 386       std::string(), std::string(), std::string(), std::string());
 387
 388   EXPECT_TRUE(resetter_delegate()->IsDefaultSearchProviderManaged());
 389   scoped_ptr<base::DictionaryValue> dsp_details(
 390       resetter_delegate()->GetDefaultSearchProviderDetails());
 391   // Checking that all details are correct is already done by the above test.
 392   // Just make sure details are reported about the correct engine.
 393   base::ExpectDictStringValue(kTestSearchURL, *dsp_details, "search_url");
 394
 395   // Set managed preferences to emulate that having a default search provider is
 396   // disabled by policy.
 397   template_url_service_test_util()->RemoveManagedDefaultSearchPreferences();
 398   template_url_service_test_util()->SetManagedDefaultSearchPreferences(
 399       false, std::string(), std::string(), std::string(), std::string(),
 400       std::string(), std::string(), std::string(), std::string());
 401
 402   dsp_details = resetter_delegate()->GetDefaultSearchProviderDetails();
 403   EXPECT_TRUE(resetter_delegate()->IsDefaultSearchProviderManaged());
 404   EXPECT_TRUE(dsp_details->empty());
 405 }
 406
 407 TEST_F(AutomaticProfileResetterDelegateTest,
 408        GetPrepopulatedSearchProvidersDetails) {
 409   TemplateURLService* template_url_service =
 410       TemplateURLServiceFactory::GetForProfile(profile());
 411   template_url_service_test_util()->VerifyLoad();
 412
 413   scoped_ptr<base::ListValue> search_engines_details(
 414       resetter_delegate()->GetPrepopulatedSearchProvidersDetails());
 415
 416   // Do the same kind of verification as for GetDefaultSearchEngineDetails:
 417   // subsequently set each pre-populated engine as the default, so we can verify
 418   // that the details returned by the delegate about one particular engine are
 419   // correct in comparison to what has been stored to the Prefs.
 420   std::vector<TemplateURL*> prepopulated_engines =
 421       template_url_service->GetTemplateURLs();
 422
 423   ASSERT_EQ(prepopulated_engines.size(), search_engines_details->GetSize());
 424
 425   for (size_t i = 0; i < search_engines_details->GetSize(); ++i) {
 426     const base::DictionaryValue* details = NULL;
 427     ASSERT_TRUE(search_engines_details->GetDictionary(i, &details));
 428
 429     std::string keyword;
 430     ASSERT_TRUE(details->GetString("keyword", &keyword));
 431     TemplateURL* search_engine =
 432         template_url_service->GetTemplateURLForKeyword(
 433             base::ASCIIToUTF16(keyword));
 434     ASSERT_TRUE(search_engine);
 435     template_url_service->SetUserSelectedDefaultSearchProvider(
 436         prepopulated_engines[i]);
 437
 438     PrefService* prefs = profile()->GetPrefs();
 439     ASSERT_TRUE(prefs);
 440     const base::DictionaryValue* expected_dsp_details =
 441         GetDefaultSearchProviderDetailsFromPrefs(prefs);
 442     ExpectDetailsMatch(*expected_dsp_details, *details);
 443   }
 444 }
 445
 446 TEST_F(AutomaticProfileResetterDelegateTest,
 447        FetchAndWaitOnDefaultSettingsVanilla) {
 448   google_brand::BrandForTesting scoped_brand_for_testing((std::string()));
 449
 450   // Expect ready_callback to be called just after empty brandcoded settings
 451   // are loaded, given this is a vanilla build. Fail if it is not called, or
 452   // called too early.
 453   testing::StrictMock<MockCallbackTarget> mock_target;
 454   resetter_delegate()->RequestCallbackWhenBrandcodedDefaultsAreFetched(
 455       mock_target.CreateClosure());
 456   base::RunLoop().RunUntilIdle();
 457   EXPECT_FALSE(resetter_delegate()->brandcoded_defaults());
 458
 459   EXPECT_CALL(mock_target, Run());
 460   resetter_delegate()->FetchBrandcodedDefaultSettingsIfNeeded();
 461   base::RunLoop().RunUntilIdle();
 462   ExpectNoPendingBrandcodedConfigFetch();
 463
 464   testing::Mock::VerifyAndClearExpectations(&mock_target);
 465   EXPECT_TRUE(resetter_delegate()->brandcoded_defaults());
 466
 467   // Expect ready_callback to be posted immediately when the brandcoded settings
 468   // have already been loaded.
 469   EXPECT_CALL(mock_target, Run());
 470   resetter_delegate()->RequestCallbackWhenBrandcodedDefaultsAreFetched(
 471       mock_target.CreateClosure());
 472   base::RunLoop().RunUntilIdle();
 473
 474   // No test for a new instance of AutomaticProfileResetterDelegate. That will
 475   // need to fetch the brandcoded settings again.
 476 }
 477
 478 TEST_F(AutomaticProfileResetterDelegateTest,
 479        FetchAndWaitOnDefaultSettingsBranded) {
 480   google_brand::BrandForTesting scoped_brand_for_testing(kTestBrandcode);
 481
 482   // Expect ready_callback to be called just after the brandcoded settings are
 483   // downloaded. Fail if it is not called, or called too early.
 484   testing::StrictMock<MockCallbackTarget> mock_target;
 485   resetter_delegate()->RequestCallbackWhenBrandcodedDefaultsAreFetched(
 486       mock_target.CreateClosure());
 487   base::RunLoop().RunUntilIdle();
 488   EXPECT_FALSE(resetter_delegate()->brandcoded_defaults());
 489
 490   EXPECT_CALL(mock_target, Run());
 491   resetter_delegate()->FetchBrandcodedDefaultSettingsIfNeeded();
 492   ExpectAndServicePendingBrandcodedConfigFetch(false /*simulate_failure*/);
 493   base::RunLoop().RunUntilIdle();
 494
 495   testing::Mock::VerifyAndClearExpectations(&mock_target);
 496   const BrandcodedDefaultSettings* brandcoded_defaults =
 497       resetter_delegate()->brandcoded_defaults();
 498   ASSERT_TRUE(brandcoded_defaults);
 499   std::string homepage_url;
 500   EXPECT_TRUE(brandcoded_defaults->GetHomepage(&homepage_url));
 501   EXPECT_EQ(kTestBrandedHomepage, homepage_url);
 502
 503   // Expect ready_callback to be posted immediately when the brandcoded settings
 504   // have already been downloaded.
 505   EXPECT_CALL(mock_target, Run());
 506   resetter_delegate()->RequestCallbackWhenBrandcodedDefaultsAreFetched(
 507       mock_target.CreateClosure());
 508   base::RunLoop().RunUntilIdle();
 509 }
 510
 511 TEST_F(AutomaticProfileResetterDelegateTest,
 512        FetchAndWaitOnDefaultSettingsBrandedFailure) {
 513   google_brand::BrandForTesting scoped_brand_for_testing(kTestBrandcode);
 514
 515   // Expect ready_callback to be called just after the brandcoded settings have
 516   // failed to download. Fail if it is not called, or called too early.
 517   testing::StrictMock<MockCallbackTarget> mock_target;
 518   resetter_delegate()->RequestCallbackWhenBrandcodedDefaultsAreFetched(
 519       mock_target.CreateClosure());
 520   base::RunLoop().RunUntilIdle();
 521
 522   EXPECT_CALL(mock_target, Run());
 523   resetter_delegate()->FetchBrandcodedDefaultSettingsIfNeeded();
 524   ExpectAndServicePendingBrandcodedConfigFetch(true /*simulate_failure*/);
 525   base::RunLoop().RunUntilIdle();
 526
 527   testing::Mock::VerifyAndClearExpectations(&mock_target);
 528   EXPECT_TRUE(resetter_delegate()->brandcoded_defaults());
 529
 530   // Expect ready_callback to be posted immediately when the brandcoded settings
 531   // have already been attempted to be downloaded, but failed.
 532   EXPECT_CALL(mock_target, Run());
 533   resetter_delegate()->RequestCallbackWhenBrandcodedDefaultsAreFetched(
 534       mock_target.CreateClosure());
 535   base::RunLoop().RunUntilIdle();
 536 }
 537
 538 TEST_F(AutomaticProfileResetterDelegateTest, TriggerReset) {
 539   google_brand::BrandForTesting scoped_brand_for_testing(kTestBrandcode);
 540
 541   PrefService* prefs = profile()->GetPrefs();
 542   DCHECK(prefs);
 543   prefs->SetString(prefs::kHomePage, kTestHomepage);
 544
 545   testing::StrictMock<MockCallbackTarget> mock_target;
 546   EXPECT_CALL(mock_target, Run());
 547   EXPECT_CALL(*resetter_delegate(), SendFeedback(testing::_)).Times(0);
 548   resetter_delegate()->TriggerProfileSettingsReset(
 549       false /*send_feedback*/, mock_target.CreateClosure());
 550   ExpectAndServicePendingBrandcodedConfigFetch(false /*simulate_failure*/);
 551   base::RunLoop().RunUntilIdle();
 552
 553   EXPECT_EQ(kTestBrandedHomepage, prefs->GetString(prefs::kHomePage));
 554 }
 555
 556 TEST_F(AutomaticProfileResetterDelegateTest,
 557        TriggerResetWithDefaultSettingsAlreadyLoaded) {
 558   google_brand::BrandForTesting scoped_brand_for_testing(kTestBrandcode);
 559
 560   PrefService* prefs = profile()->GetPrefs();
 561   DCHECK(prefs);
 562   prefs->SetString(prefs::kHomePage, kTestHomepage);
 563
 564   resetter_delegate()->FetchBrandcodedDefaultSettingsIfNeeded();
 565   ExpectAndServicePendingBrandcodedConfigFetch(false /*simulate_failure*/);
 566   base::RunLoop().RunUntilIdle();
 567
 568   testing::StrictMock<MockCallbackTarget> mock_target;
 569   EXPECT_CALL(mock_target, Run());
 570   EXPECT_CALL(*resetter_delegate(), SendFeedback(testing::_)).Times(0);
 571   resetter_delegate()->TriggerProfileSettingsReset(
 572       false /*send_feedback*/, mock_target.CreateClosure());
 573   base::RunLoop().RunUntilIdle();
 574
 575   EXPECT_EQ(kTestBrandedHomepage, prefs->GetString(prefs::kHomePage));
 576 }
 577
 578 TEST_F(AutomaticProfileResetterDelegateTest,
 579        TriggerResetAndSendFeedback) {
 580   google_brand::BrandForTesting scoped_brand_for_testing(kTestBrandcode);
 581
 582   PrefService* prefs = profile()->GetPrefs();
 583   DCHECK(prefs);
 584   prefs->SetString(prefs::kHomePage, kTestHomepage);
 585
 586   testing::StrictMock<MockCallbackTarget> mock_target;
 587   EXPECT_CALL(mock_target, Run());
 588   EXPECT_CALL(*resetter_delegate(),
 589               SendFeedback(testing::HasSubstr(kTestHomepage)));
 590
 591   resetter_delegate()->TriggerProfileSettingsReset(
 592       true /*send_feedback*/, mock_target.CreateClosure());
 593   ExpectAndServicePendingBrandcodedConfigFetch(false /*simulate_failure*/);
 594   base::RunLoop().RunUntilIdle();
 595 }
 596
 597 TEST_F(AutomaticProfileResetterDelegateTest, ShowAndDismissPrompt) {
 598   resetter_delegate()->TriggerPrompt();
 599   if (ProfileResetGlobalError::IsSupportedOnPlatform())
 600     ExpectResetPromptState(true /*active*/);
 601   else
 602     ExpectResetPromptState(false /*active*/);
 603   resetter_delegate()->DismissPrompt();
 604   ExpectResetPromptState(false /*active*/);
 605   resetter_delegate()->DismissPrompt();
 606 }
 607
 608 }  // namespace