src/chrome/browser/profile_resetter/profile_resetter_unittest.cc

   1 // Copyright (c) 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/profile_resetter.h"
   6
   7 #include "base/json/json_string_value_serializer.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/test/scoped_path_override.h"
  11 #include "chrome/browser/content_settings/host_content_settings_map.h"
  12 #include "chrome/browser/extensions/extension_service.h"
  13 #include "chrome/browser/extensions/extension_service_test_base.h"
  14 #include "chrome/browser/extensions/tab_helper.h"
  15 #include "chrome/browser/prefs/session_startup_pref.h"
  16 #include "chrome/browser/profile_resetter/brandcode_config_fetcher.h"
  17 #include "chrome/browser/profile_resetter/profile_resetter_test_base.h"
  18 #include "chrome/browser/profile_resetter/resettable_settings_snapshot.h"
  19 #include "chrome/browser/search_engines/template_url_service_factory.h"
  20 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
  21 #include "chrome/browser/themes/theme_service.h"
  22 #include "chrome/browser/themes/theme_service_factory.h"
  23 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  24 #include "chrome/browser/webdata/web_data_service_factory.h"
  25 #include "chrome/common/pref_names.h"
  26 #include "chrome/test/base/browser_with_test_window_test.h"
  27 #include "components/google/core/browser/google_pref_names.h"
  28 #include "components/search_engines/template_url_service.h"
  29 #include "components/search_engines/template_url_service_client.h"
  30 #include "content/public/browser/web_contents.h"
  31 #include "content/public/test/test_browser_thread.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/manifest_constants.h"
  34 #include "net/http/http_response_headers.h"
  35 #include "net/http/http_status_code.h"
  36 #include "net/url_request/test_url_fetcher_factory.h"
  37 #include "net/url_request/url_request_status.h"
  38 #include "url/gurl.h"
  39
  40 #if defined(OS_WIN)
  41 #include "base/file_util.h"
  42 #include "base/path_service.h"
  43 #include "base/process/process_handle.h"
  44 #include "base/rand_util.h"
  45 #include "base/strings/string_number_conversions.h"
  46 #include "base/win/scoped_com_initializer.h"
  47 #include "base/win/shortcut.h"
  48 #endif
  49
  50
  51 namespace {
  52
  53 const char kDistributionConfig[] = "{"
  54     " \"homepage\" : \"http://www.foo.com\","
  55     " \"homepage_is_newtabpage\" : false,"
  56     " \"browser\" : {"
  57     "   \"show_home_button\" : true"
  58     "  },"
  59     " \"session\" : {"
  60     "   \"restore_on_startup\" : 4,"
  61     "   \"startup_urls\" : [\"http://goo.gl\", \"http://foo.de\"]"
  62     "  },"
  63     " \"search_provider_overrides\" : ["
  64     "    {"
  65     "      \"name\" : \"first\","
  66     "      \"keyword\" : \"firstkey\","
  67     "      \"search_url\" : \"http://www.foo.com/s?q={searchTerms}\","
  68     "      \"favicon_url\" : \"http://www.foo.com/favicon.ico\","
  69     "      \"suggest_url\" : \"http://www.foo.com/s?q={searchTerms}\","
  70     "      \"encoding\" : \"UTF-8\","
  71     "      \"id\" : 1001"
  72     "    }"
  73     "  ],"
  74     " \"extensions\" : {"
  75     "   \"settings\" : {"
  76     "     \"placeholder_for_id\": {"
  77     "      }"
  78     "    }"
  79     "  }"
  80     "}";
  81
  82 const char kXmlConfig[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
  83     "<response protocol=\"3.0\" server=\"prod\">"
  84       "<app appid=\"{8A69D345-D564-463C-AFF1-A69D9E530F96}\" status=\"ok\">"
  85         "<data index=\"skipfirstrunui-importsearch-defaultbrowser\" "
  86           "name=\"install\" status=\"ok\">"
  87           "placeholder_for_data"
  88         "</data>"
  89       "</app>"
  90     "</response>";
  91
  92 using extensions::Extension;
  93 using extensions::Manifest;
  94
  95
  96 // ProfileResetterTest --------------------------------------------------------
  97
  98 // ProfileResetterTest sets up the extension, WebData and TemplateURL services.
  99 class ProfileResetterTest : public extensions::ExtensionServiceTestBase,
 100                             public ProfileResetterTestBase {
 101  public:
 102   ProfileResetterTest();
 103   virtual ~ProfileResetterTest();
 104
 105  protected:
 106   virtual void SetUp() OVERRIDE;
 107
 108   TestingProfile* profile() { return profile_.get(); }
 109
 110   static KeyedService* CreateTemplateURLService(
 111       content::BrowserContext* context);
 112
 113  private:
 114 #if defined(OS_WIN)
 115   base::ScopedPathOverride user_desktop_override_;
 116   base::ScopedPathOverride app_dir_override_;
 117   base::ScopedPathOverride start_menu_override_;
 118   base::ScopedPathOverride taskbar_pins_override_;
 119   base::win::ScopedCOMInitializer com_init_;
 120 #endif
 121 };
 122
 123 ProfileResetterTest::ProfileResetterTest()
 124 #if defined(OS_WIN)
 125     : user_desktop_override_(base::DIR_USER_DESKTOP),
 126       app_dir_override_(base::DIR_APP_DATA),
 127       start_menu_override_(base::DIR_START_MENU),
 128       taskbar_pins_override_(base::DIR_TASKBAR_PINS)
 129 #endif
 130 {}
 131
 132 ProfileResetterTest::~ProfileResetterTest() {
 133 }
 134
 135 void ProfileResetterTest::SetUp() {
 136   extensions::ExtensionServiceTestBase::SetUp();
 137   InitializeEmptyExtensionService();
 138
 139   profile()->CreateWebDataService();
 140   TemplateURLServiceFactory::GetInstance()->SetTestingFactory(
 141       profile(),
 142       &ProfileResetterTest::CreateTemplateURLService);
 143   resetter_.reset(new ProfileResetter(profile()));
 144 }
 145
 146 // static
 147 KeyedService* ProfileResetterTest::CreateTemplateURLService(
 148     content::BrowserContext* context) {
 149   Profile* profile = static_cast<Profile*>(context);
 150   return new TemplateURLService(
 151       profile->GetPrefs(),
 152       scoped_ptr<SearchTermsData>(new UIThreadSearchTermsData(profile)),
 153       WebDataServiceFactory::GetKeywordWebDataForProfile(
 154           profile, Profile::EXPLICIT_ACCESS),
 155       scoped_ptr<TemplateURLServiceClient>(), NULL, NULL, base::Closure());
 156 }
 157
 158
 159 // PinnedTabsResetTest --------------------------------------------------------
 160
 161 class PinnedTabsResetTest : public BrowserWithTestWindowTest,
 162                             public ProfileResetterTestBase {
 163  protected:
 164   virtual void SetUp() OVERRIDE;
 165
 166   content::WebContents* CreateWebContents();
 167 };
 168
 169 void PinnedTabsResetTest::SetUp() {
 170   BrowserWithTestWindowTest::SetUp();
 171   resetter_.reset(new ProfileResetter(profile()));
 172 }
 173
 174 content::WebContents* PinnedTabsResetTest::CreateWebContents() {
 175   return content::WebContents::Create(
 176       content::WebContents::CreateParams(profile()));
 177 }
 178
 179
 180 // ConfigParserTest -----------------------------------------------------------
 181
 182 // URLFetcher delegate that simply records the upload data.
 183 struct URLFetcherRequestListener : net::URLFetcherDelegate {
 184   URLFetcherRequestListener();
 185   virtual ~URLFetcherRequestListener();
 186
 187   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 188
 189   std::string upload_data;
 190   net::URLFetcherDelegate* real_delegate;
 191 };
 192
 193 URLFetcherRequestListener::URLFetcherRequestListener()
 194     : real_delegate(NULL) {
 195 }
 196
 197 URLFetcherRequestListener::~URLFetcherRequestListener() {
 198 }
 199
 200 void URLFetcherRequestListener::OnURLFetchComplete(
 201     const net::URLFetcher* source) {
 202   const net::TestURLFetcher* test_fetcher =
 203       static_cast<const net::TestURLFetcher*>(source);
 204   upload_data = test_fetcher->upload_data();
 205   DCHECK(real_delegate);
 206   real_delegate->OnURLFetchComplete(source);
 207 }
 208
 209 class ConfigParserTest : public testing::Test {
 210  protected:
 211   ConfigParserTest();
 212   virtual ~ConfigParserTest();
 213
 214   scoped_ptr<BrandcodeConfigFetcher> WaitForRequest(const GURL& url);
 215
 216   net::FakeURLFetcherFactory& factory() { return factory_; }
 217
 218  private:
 219   scoped_ptr<net::FakeURLFetcher> CreateFakeURLFetcher(
 220       const GURL& url,
 221       net::URLFetcherDelegate* fetcher_delegate,
 222       const std::string& response_data,
 223       net::HttpStatusCode response_code,
 224       net::URLRequestStatus::Status status);
 225
 226   MOCK_METHOD0(Callback, void(void));
 227
 228   base::MessageLoopForIO loop_;
 229   content::TestBrowserThread ui_thread_;
 230   content::TestBrowserThread io_thread_;
 231   URLFetcherRequestListener request_listener_;
 232   net::FakeURLFetcherFactory factory_;
 233 };
 234
 235 ConfigParserTest::ConfigParserTest()
 236     : ui_thread_(content::BrowserThread::UI, &loop_),
 237       io_thread_(content::BrowserThread::IO, &loop_),
 238       factory_(NULL, base::Bind(&ConfigParserTest::CreateFakeURLFetcher,
 239                                 base::Unretained(this))) {
 240 }
 241
 242 ConfigParserTest::~ConfigParserTest() {}
 243
 244 scoped_ptr<BrandcodeConfigFetcher> ConfigParserTest::WaitForRequest(
 245     const GURL& url) {
 246   EXPECT_CALL(*this, Callback());
 247   scoped_ptr<BrandcodeConfigFetcher> fetcher(
 248       new BrandcodeConfigFetcher(base::Bind(&ConfigParserTest::Callback,
 249                                             base::Unretained(this)),
 250                                  url,
 251                                  "ABCD"));
 252   base::MessageLoop::current()->RunUntilIdle();
 253   EXPECT_FALSE(fetcher->IsActive());
 254   // Look for the brand code in the request.
 255   EXPECT_NE(std::string::npos, request_listener_.upload_data.find("ABCD"));
 256   return fetcher.Pass();
 257 }
 258
 259 scoped_ptr<net::FakeURLFetcher> ConfigParserTest::CreateFakeURLFetcher(
 260     const GURL& url,
 261     net::URLFetcherDelegate* fetcher_delegate,
 262     const std::string& response_data,
 263     net::HttpStatusCode response_code,
 264     net::URLRequestStatus::Status status) {
 265   request_listener_.real_delegate = fetcher_delegate;
 266   scoped_ptr<net::FakeURLFetcher> fetcher(
 267       new net::FakeURLFetcher(
 268           url, &request_listener_, response_data, response_code, status));
 269   scoped_refptr<net::HttpResponseHeaders> download_headers =
 270       new net::HttpResponseHeaders("");
 271   download_headers->AddHeader("Content-Type: text/xml");
 272   fetcher->set_response_headers(download_headers);
 273   return fetcher.Pass();
 274 }
 275
 276 // A helper class to create/delete/check a Chrome desktop shortcut on Windows.
 277 class ShortcutHandler {
 278  public:
 279   ShortcutHandler();
 280   ~ShortcutHandler();
 281
 282   static bool IsSupported();
 283   ShortcutCommand CreateWithArguments(const base::string16& name,
 284                                       const base::string16& args);
 285   void CheckShortcutHasArguments(const base::string16& desired_args) const;
 286   void Delete();
 287
 288  private:
 289 #if defined(OS_WIN)
 290   base::FilePath shortcut_path_;
 291 #endif
 292   DISALLOW_COPY_AND_ASSIGN(ShortcutHandler);
 293 };
 294
 295 #if defined(OS_WIN)
 296 ShortcutHandler::ShortcutHandler() {
 297 }
 298
 299 ShortcutHandler::~ShortcutHandler() {
 300   if (!shortcut_path_.empty())
 301     Delete();
 302 }
 303
 304 // static
 305 bool ShortcutHandler::IsSupported() {
 306   return true;
 307 }
 308
 309 ShortcutCommand ShortcutHandler::CreateWithArguments(
 310     const base::string16& name,
 311     const base::string16& args) {
 312   EXPECT_TRUE(shortcut_path_.empty());
 313   base::FilePath path_to_create;
 314   EXPECT_TRUE(PathService::Get(base::DIR_USER_DESKTOP, &path_to_create));
 315   path_to_create = path_to_create.Append(name);
 316   EXPECT_FALSE(base::PathExists(path_to_create)) << path_to_create.value();
 317
 318   base::FilePath path_exe;
 319   EXPECT_TRUE(PathService::Get(base::FILE_EXE, &path_exe));
 320   base::win::ShortcutProperties shortcut_properties;
 321   shortcut_properties.set_target(path_exe);
 322   shortcut_properties.set_arguments(args);
 323   EXPECT_TRUE(base::win::CreateOrUpdateShortcutLink(
 324       path_to_create, shortcut_properties,
 325       base::win::SHORTCUT_CREATE_ALWAYS)) << path_to_create.value();
 326   shortcut_path_ = path_to_create;
 327   return ShortcutCommand(shortcut_path_, args);
 328 }
 329
 330 void ShortcutHandler::CheckShortcutHasArguments(
 331     const base::string16& desired_args) const {
 332   EXPECT_FALSE(shortcut_path_.empty());
 333   base::string16 args;
 334   EXPECT_TRUE(base::win::ResolveShortcut(shortcut_path_, NULL, &args));
 335   EXPECT_EQ(desired_args, args);
 336 }
 337
 338 void ShortcutHandler::Delete() {
 339   EXPECT_FALSE(shortcut_path_.empty());
 340   EXPECT_TRUE(base::DeleteFile(shortcut_path_, false));
 341   shortcut_path_.clear();
 342 }
 343 #else
 344 ShortcutHandler::ShortcutHandler() {}
 345
 346 ShortcutHandler::~ShortcutHandler() {}
 347
 348 // static
 349 bool ShortcutHandler::IsSupported() {
 350   return false;
 351 }
 352
 353 ShortcutCommand ShortcutHandler::CreateWithArguments(
 354     const base::string16& name,
 355     const base::string16& args) {
 356   return ShortcutCommand();
 357 }
 358
 359 void ShortcutHandler::CheckShortcutHasArguments(
 360     const base::string16& desired_args) const {
 361 }
 362
 363 void ShortcutHandler::Delete() {
 364 }
 365 #endif  // defined(OS_WIN)
 366
 367
 368 // helper functions -----------------------------------------------------------
 369
 370 scoped_refptr<Extension> CreateExtension(const base::string16& name,
 371                                          const base::FilePath& path,
 372                                          Manifest::Location location,
 373                                          extensions::Manifest::Type type,
 374                                          bool installed_by_default) {
 375   base::DictionaryValue manifest;
 376   manifest.SetString(extensions::manifest_keys::kVersion, "1.0.0.0");
 377   manifest.SetString(extensions::manifest_keys::kName, name);
 378   switch (type) {
 379     case extensions::Manifest::TYPE_THEME:
 380       manifest.Set(extensions::manifest_keys::kTheme,
 381                    new base::DictionaryValue);
 382       break;
 383     case extensions::Manifest::TYPE_HOSTED_APP:
 384       manifest.SetString(extensions::manifest_keys::kLaunchWebURL,
 385                          "http://www.google.com");
 386       manifest.SetString(extensions::manifest_keys::kUpdateURL,
 387                          "http://clients2.google.com/service/update2/crx");
 388       break;
 389     case extensions::Manifest::TYPE_EXTENSION:
 390       // do nothing
 391       break;
 392     default:
 393       NOTREACHED();
 394   }
 395   manifest.SetString(extensions::manifest_keys::kOmniboxKeyword, name);
 396   std::string error;
 397   scoped_refptr<Extension> extension = Extension::Create(
 398       path,
 399       location,
 400       manifest,
 401       installed_by_default ? Extension::WAS_INSTALLED_BY_DEFAULT
 402                            : Extension::NO_FLAGS,
 403       &error);
 404   EXPECT_TRUE(extension.get() != NULL) << error;
 405   return extension;
 406 }
 407
 408 void ReplaceString(std::string* str,
 409                    const std::string& placeholder,
 410                    const std::string& substitution) {
 411   ASSERT_NE(static_cast<std::string*>(NULL), str);
 412   size_t placeholder_pos = str->find(placeholder);
 413   ASSERT_NE(std::string::npos, placeholder_pos);
 414   str->replace(placeholder_pos, placeholder.size(), substitution);
 415 }
 416
 417
 418 /********************* Tests *********************/
 419
 420 TEST_F(ProfileResetterTest, ResetNothing) {
 421   // The callback should be called even if there is nothing to reset.
 422   ResetAndWait(0);
 423 }
 424
 425 TEST_F(ProfileResetterTest, ResetDefaultSearchEngineNonOrganic) {
 426   PrefService* prefs = profile()->GetPrefs();
 427   DCHECK(prefs);
 428   prefs->SetString(prefs::kLastPromptedGoogleURL, "http://www.foo.com/");
 429
 430   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE, kDistributionConfig);
 431
 432   TemplateURLService* model =
 433       TemplateURLServiceFactory::GetForProfile(profile());
 434   TemplateURL* default_engine = model->GetDefaultSearchProvider();
 435   ASSERT_NE(static_cast<TemplateURL*>(NULL), default_engine);
 436   EXPECT_EQ(base::ASCIIToUTF16("first"), default_engine->short_name());
 437   EXPECT_EQ(base::ASCIIToUTF16("firstkey"), default_engine->keyword());
 438   EXPECT_EQ("http://www.foo.com/s?q={searchTerms}", default_engine->url());
 439
 440   EXPECT_EQ("", prefs->GetString(prefs::kLastPromptedGoogleURL));
 441 }
 442
 443 TEST_F(ProfileResetterTest, ResetDefaultSearchEnginePartially) {
 444   // Search engine's logic is tested by
 445   // TemplateURLServiceTest.RepairPrepopulatedSearchEngines.
 446   PrefService* prefs = profile()->GetPrefs();
 447   DCHECK(prefs);
 448   prefs->SetString(prefs::kLastPromptedGoogleURL, "http://www.foo.com/");
 449
 450   // Make sure TemplateURLService has loaded.
 451   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE);
 452
 453   TemplateURLService* model =
 454       TemplateURLServiceFactory::GetForProfile(profile());
 455   TemplateURLService::TemplateURLVector urls = model->GetTemplateURLs();
 456
 457   // The second call should produce no effect.
 458   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE);
 459
 460   EXPECT_EQ(urls, model->GetTemplateURLs());
 461   EXPECT_EQ(std::string(), prefs->GetString(prefs::kLastPromptedGoogleURL));
 462 }
 463
 464 TEST_F(ProfileResetterTest, ResetHomepageNonOrganic) {
 465   PrefService* prefs = profile()->GetPrefs();
 466   DCHECK(prefs);
 467   prefs->SetBoolean(prefs::kHomePageIsNewTabPage, true);
 468   prefs->SetString(prefs::kHomePage, "http://google.com");
 469   prefs->SetBoolean(prefs::kShowHomeButton, false);
 470
 471   ResetAndWait(ProfileResetter::HOMEPAGE, kDistributionConfig);
 472
 473   EXPECT_FALSE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage));
 474   EXPECT_EQ("http://www.foo.com", prefs->GetString(prefs::kHomePage));
 475   EXPECT_TRUE(prefs->GetBoolean(prefs::kShowHomeButton));
 476 }
 477
 478 TEST_F(ProfileResetterTest, ResetHomepagePartially) {
 479   PrefService* prefs = profile()->GetPrefs();
 480   DCHECK(prefs);
 481   prefs->SetBoolean(prefs::kHomePageIsNewTabPage, false);
 482   prefs->SetString(prefs::kHomePage, "http://www.foo.com");
 483   prefs->SetBoolean(prefs::kShowHomeButton, true);
 484
 485   ResetAndWait(ProfileResetter::HOMEPAGE);
 486
 487   EXPECT_TRUE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage));
 488   EXPECT_EQ("http://www.foo.com", prefs->GetString(prefs::kHomePage));
 489   EXPECT_FALSE(prefs->GetBoolean(prefs::kShowHomeButton));
 490 }
 491
 492 TEST_F(ProfileResetterTest, ResetContentSettings) {
 493   HostContentSettingsMap* host_content_settings_map =
 494       profile()->GetHostContentSettingsMap();
 495   ContentSettingsPattern pattern =
 496       ContentSettingsPattern::FromString("[*.]example.org");
 497   std::map<ContentSettingsType, ContentSetting> default_settings;
 498
 499   for (int type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
 500     if (type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE ||
 501         type == CONTENT_SETTINGS_TYPE_MIXEDSCRIPT ||
 502         type == CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS) {
 503       // These types are excluded because one can't call
 504       // GetDefaultContentSetting() for them.
 505     } else {
 506       ContentSettingsType content_type = static_cast<ContentSettingsType>(type);
 507       ContentSetting default_setting =
 508           host_content_settings_map->GetDefaultContentSetting(content_type,
 509                                                               NULL);
 510       default_settings[content_type] = default_setting;
 511       ContentSetting wildcard_setting =
 512           default_setting == CONTENT_SETTING_BLOCK ? CONTENT_SETTING_ALLOW
 513                                                    : CONTENT_SETTING_BLOCK;
 514       ContentSetting site_setting =
 515           default_setting == CONTENT_SETTING_ALLOW ? CONTENT_SETTING_ALLOW
 516                                                    : CONTENT_SETTING_BLOCK;
 517       if (HostContentSettingsMap::IsSettingAllowedForType(
 518               profile()->GetPrefs(),
 519               wildcard_setting,
 520               content_type)) {
 521         host_content_settings_map->SetDefaultContentSetting(
 522             content_type,
 523             wildcard_setting);
 524       }
 525       if (!HostContentSettingsMap::ContentTypeHasCompoundValue(content_type) &&
 526           HostContentSettingsMap::IsSettingAllowedForType(
 527               profile()->GetPrefs(),
 528               site_setting,
 529               content_type)) {
 530         host_content_settings_map->SetContentSetting(
 531             pattern,
 532             ContentSettingsPattern::Wildcard(),
 533             content_type,
 534             std::string(),
 535             site_setting);
 536         ContentSettingsForOneType host_settings;
 537         host_content_settings_map->GetSettingsForOneType(
 538             content_type, std::string(), &host_settings);
 539         EXPECT_EQ(2U, host_settings.size());
 540       }
 541     }
 542   }
 543
 544   ResetAndWait(ProfileResetter::CONTENT_SETTINGS);
 545
 546   for (int type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
 547     ContentSettingsType content_type = static_cast<ContentSettingsType>(type);
 548     if (HostContentSettingsMap::ContentTypeHasCompoundValue(content_type) ||
 549         type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE ||
 550         content_type == CONTENT_SETTINGS_TYPE_MIXEDSCRIPT ||
 551         content_type == CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS)
 552       continue;
 553     ContentSetting default_setting =
 554         host_content_settings_map->GetDefaultContentSetting(content_type,
 555                                                               NULL);
 556     EXPECT_TRUE(default_settings.count(content_type));
 557     EXPECT_EQ(default_settings[content_type], default_setting);
 558     if (!HostContentSettingsMap::ContentTypeHasCompoundValue(content_type)) {
 559       ContentSetting site_setting =
 560           host_content_settings_map->GetContentSetting(
 561               GURL("example.org"),
 562               GURL(),
 563               content_type,
 564               std::string());
 565       EXPECT_EQ(default_setting, site_setting);
 566     }
 567
 568     ContentSettingsForOneType host_settings;
 569     host_content_settings_map->GetSettingsForOneType(
 570         content_type, std::string(), &host_settings);
 571     EXPECT_EQ(1U, host_settings.size());
 572   }
 573 }
 574
 575 TEST_F(ProfileResetterTest, ResetExtensionsByDisabling) {
 576   service_->Init();
 577
 578   base::ScopedTempDir temp_dir;
 579   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 580
 581   scoped_refptr<Extension> theme =
 582       CreateExtension(base::ASCIIToUTF16("example1"),
 583                       temp_dir.path(),
 584                       Manifest::INVALID_LOCATION,
 585                       extensions::Manifest::TYPE_THEME,
 586                       false);
 587   service_->FinishInstallationForTest(theme.get());
 588   // Let ThemeService finish creating the theme pack.
 589   base::MessageLoop::current()->RunUntilIdle();
 590
 591   ThemeService* theme_service =
 592       ThemeServiceFactory::GetForProfile(profile());
 593   EXPECT_FALSE(theme_service->UsingDefaultTheme());
 594
 595   scoped_refptr<Extension> ext2 = CreateExtension(
 596       base::ASCIIToUTF16("example2"),
 597       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
 598       Manifest::INVALID_LOCATION,
 599       extensions::Manifest::TYPE_EXTENSION,
 600       false);
 601   service_->AddExtension(ext2.get());
 602   // Component extensions and policy-managed extensions shouldn't be disabled.
 603   scoped_refptr<Extension> ext3 = CreateExtension(
 604       base::ASCIIToUTF16("example3"),
 605       base::FilePath(FILE_PATH_LITERAL("//nonexistent2")),
 606       Manifest::COMPONENT,
 607       extensions::Manifest::TYPE_EXTENSION,
 608       false);
 609   service_->AddExtension(ext3.get());
 610   scoped_refptr<Extension> ext4 =
 611       CreateExtension(base::ASCIIToUTF16("example4"),
 612                       base::FilePath(FILE_PATH_LITERAL("//nonexistent3")),
 613                       Manifest::EXTERNAL_POLICY_DOWNLOAD,
 614                       extensions::Manifest::TYPE_EXTENSION,
 615                       false);
 616   service_->AddExtension(ext4.get());
 617   scoped_refptr<Extension> ext5 = CreateExtension(
 618       base::ASCIIToUTF16("example5"),
 619       base::FilePath(FILE_PATH_LITERAL("//nonexistent4")),
 620       Manifest::EXTERNAL_COMPONENT,
 621       extensions::Manifest::TYPE_EXTENSION,
 622       false);
 623   service_->AddExtension(ext5.get());
 624   scoped_refptr<Extension> ext6 = CreateExtension(
 625       base::ASCIIToUTF16("example6"),
 626       base::FilePath(FILE_PATH_LITERAL("//nonexistent5")),
 627       Manifest::EXTERNAL_POLICY,
 628       extensions::Manifest::TYPE_EXTENSION,
 629       false);
 630   service_->AddExtension(ext6.get());
 631   EXPECT_EQ(6u, service_->extensions()->size());
 632
 633   ResetAndWait(ProfileResetter::EXTENSIONS);
 634   EXPECT_EQ(4u, service_->extensions()->size());
 635   EXPECT_FALSE(service_->extensions()->Contains(theme->id()));
 636   EXPECT_FALSE(service_->extensions()->Contains(ext2->id()));
 637   EXPECT_TRUE(service_->extensions()->Contains(ext3->id()));
 638   EXPECT_TRUE(service_->extensions()->Contains(ext4->id()));
 639   EXPECT_TRUE(service_->extensions()->Contains(ext5->id()));
 640   EXPECT_TRUE(service_->extensions()->Contains(ext6->id()));
 641   EXPECT_TRUE(theme_service->UsingDefaultTheme());
 642 }
 643
 644 TEST_F(ProfileResetterTest, ResetExtensionsByDisablingNonOrganic) {
 645   scoped_refptr<Extension> ext2 = CreateExtension(
 646       base::ASCIIToUTF16("example2"),
 647       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
 648       Manifest::INVALID_LOCATION,
 649       extensions::Manifest::TYPE_EXTENSION,
 650       false);
 651   service_->AddExtension(ext2.get());
 652   // Components and external policy extensions shouldn't be deleted.
 653   scoped_refptr<Extension> ext3 = CreateExtension(
 654       base::ASCIIToUTF16("example3"),
 655       base::FilePath(FILE_PATH_LITERAL("//nonexistent2")),
 656       Manifest::INVALID_LOCATION,
 657       extensions::Manifest::TYPE_EXTENSION,
 658       false);
 659   service_->AddExtension(ext3.get());
 660   EXPECT_EQ(2u, service_->extensions()->size());
 661
 662   std::string master_prefs(kDistributionConfig);
 663   ReplaceString(&master_prefs, "placeholder_for_id", ext3->id());
 664
 665   ResetAndWait(ProfileResetter::EXTENSIONS, master_prefs);
 666
 667   EXPECT_EQ(1u, service_->extensions()->size());
 668   EXPECT_TRUE(service_->extensions()->Contains(ext3->id()));
 669 }
 670
 671 TEST_F(ProfileResetterTest, ResetExtensionsAndDefaultApps) {
 672   service_->Init();
 673
 674   base::ScopedTempDir temp_dir;
 675   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 676
 677   scoped_refptr<Extension> ext1 =
 678       CreateExtension(base::ASCIIToUTF16("example1"),
 679                       temp_dir.path(),
 680                       Manifest::INVALID_LOCATION,
 681                       extensions::Manifest::TYPE_THEME,
 682                       false);
 683   service_->FinishInstallationForTest(ext1.get());
 684   // Let ThemeService finish creating the theme pack.
 685   base::MessageLoop::current()->RunUntilIdle();
 686
 687   ThemeService* theme_service =
 688       ThemeServiceFactory::GetForProfile(profile());
 689   EXPECT_FALSE(theme_service->UsingDefaultTheme());
 690
 691   scoped_refptr<Extension> ext2 =
 692       CreateExtension(base::ASCIIToUTF16("example2"),
 693                       base::FilePath(FILE_PATH_LITERAL("//nonexistent2")),
 694                       Manifest::INVALID_LOCATION,
 695                       extensions::Manifest::TYPE_EXTENSION,
 696                       false);
 697   service_->AddExtension(ext2.get());
 698
 699   scoped_refptr<Extension> ext3 =
 700       CreateExtension(base::ASCIIToUTF16("example2"),
 701                       base::FilePath(FILE_PATH_LITERAL("//nonexistent3")),
 702                       Manifest::INVALID_LOCATION,
 703                       extensions::Manifest::TYPE_HOSTED_APP,
 704                       true);
 705   service_->AddExtension(ext3.get());
 706   EXPECT_EQ(3u, service_->extensions()->size());
 707
 708   ResetAndWait(ProfileResetter::EXTENSIONS);
 709
 710   EXPECT_EQ(1u, service_->extensions()->size());
 711   EXPECT_FALSE(service_->extensions()->Contains(ext1->id()));
 712   EXPECT_FALSE(service_->extensions()->Contains(ext2->id()));
 713   EXPECT_TRUE(service_->extensions()->Contains(ext3->id()));
 714   EXPECT_TRUE(theme_service->UsingDefaultTheme());
 715 }
 716
 717 TEST_F(ProfileResetterTest, ResetStartPageNonOrganic) {
 718   PrefService* prefs = profile()->GetPrefs();
 719   DCHECK(prefs);
 720
 721   SessionStartupPref startup_pref(SessionStartupPref::LAST);
 722   SessionStartupPref::SetStartupPref(prefs, startup_pref);
 723
 724   ResetAndWait(ProfileResetter::STARTUP_PAGES, kDistributionConfig);
 725
 726   startup_pref = SessionStartupPref::GetStartupPref(prefs);
 727   EXPECT_EQ(SessionStartupPref::URLS, startup_pref.type);
 728   const GURL urls[] = {GURL("http://goo.gl"), GURL("http://foo.de")};
 729   EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)), startup_pref.urls);
 730 }
 731
 732
 733 TEST_F(ProfileResetterTest, ResetStartPagePartially) {
 734   PrefService* prefs = profile()->GetPrefs();
 735   DCHECK(prefs);
 736
 737   const GURL urls[] = {GURL("http://foo"), GURL("http://bar")};
 738   SessionStartupPref startup_pref(SessionStartupPref::URLS);
 739   startup_pref.urls.assign(urls, urls + arraysize(urls));
 740   SessionStartupPref::SetStartupPref(prefs, startup_pref);
 741
 742   ResetAndWait(ProfileResetter::STARTUP_PAGES, std::string());
 743
 744   startup_pref = SessionStartupPref::GetStartupPref(prefs);
 745   EXPECT_EQ(SessionStartupPref::GetDefaultStartupType(), startup_pref.type);
 746   EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)), startup_pref.urls);
 747 }
 748
 749 TEST_F(PinnedTabsResetTest, ResetPinnedTabs) {
 750   scoped_refptr<Extension> extension_app = CreateExtension(
 751       base::ASCIIToUTF16("hello!"),
 752       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
 753       Manifest::INVALID_LOCATION,
 754       extensions::Manifest::TYPE_HOSTED_APP,
 755       false);
 756   scoped_ptr<content::WebContents> contents1(CreateWebContents());
 757   extensions::TabHelper::CreateForWebContents(contents1.get());
 758   extensions::TabHelper::FromWebContents(contents1.get())->
 759       SetExtensionApp(extension_app.get());
 760   scoped_ptr<content::WebContents> contents2(CreateWebContents());
 761   scoped_ptr<content::WebContents> contents3(CreateWebContents());
 762   scoped_ptr<content::WebContents> contents4(CreateWebContents());
 763   TabStripModel* tab_strip_model = browser()->tab_strip_model();
 764
 765   tab_strip_model->AppendWebContents(contents4.get(), true);
 766   tab_strip_model->AppendWebContents(contents3.get(), true);
 767   tab_strip_model->AppendWebContents(contents2.get(), true);
 768   tab_strip_model->SetTabPinned(2, true);
 769   tab_strip_model->AppendWebContents(contents1.get(), true);
 770   tab_strip_model->SetTabPinned(3, true);
 771
 772   EXPECT_EQ(contents2, tab_strip_model->GetWebContentsAt(0));
 773   EXPECT_EQ(contents1, tab_strip_model->GetWebContentsAt(1));
 774   EXPECT_EQ(contents3, tab_strip_model->GetWebContentsAt(2));
 775   EXPECT_EQ(contents4, tab_strip_model->GetWebContentsAt(3));
 776   EXPECT_EQ(3, tab_strip_model->IndexOfFirstNonMiniTab());
 777
 778   ResetAndWait(ProfileResetter::PINNED_TABS);
 779
 780   EXPECT_EQ(contents1, tab_strip_model->GetWebContentsAt(0));
 781   EXPECT_EQ(contents2, tab_strip_model->GetWebContentsAt(1));
 782   EXPECT_EQ(contents3, tab_strip_model->GetWebContentsAt(2));
 783   EXPECT_EQ(contents4, tab_strip_model->GetWebContentsAt(3));
 784   EXPECT_EQ(1, tab_strip_model->IndexOfFirstNonMiniTab());
 785 }
 786
 787 TEST_F(ProfileResetterTest, ResetShortcuts) {
 788   ShortcutHandler shortcut;
 789   ShortcutCommand command_line = shortcut.CreateWithArguments(
 790       base::ASCIIToUTF16("chrome.lnk"),
 791       base::ASCIIToUTF16("--profile-directory=Default foo.com"));
 792   shortcut.CheckShortcutHasArguments(base::ASCIIToUTF16(
 793       "--profile-directory=Default foo.com"));
 794
 795   ResetAndWait(ProfileResetter::SHORTCUTS);
 796
 797   shortcut.CheckShortcutHasArguments(base::ASCIIToUTF16(
 798       "--profile-directory=Default"));
 799 }
 800
 801 TEST_F(ProfileResetterTest, ResetFewFlags) {
 802   // mock_object_ is a StrictMock, so we verify that it is called only once.
 803   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE |
 804                ProfileResetter::HOMEPAGE |
 805                ProfileResetter::CONTENT_SETTINGS);
 806 }
 807
 808 // Tries to load unavailable config file.
 809 TEST_F(ConfigParserTest, NoConnectivity) {
 810   const GURL url("http://test");
 811   factory().SetFakeResponse(url, "", net::HTTP_INTERNAL_SERVER_ERROR,
 812                             net::URLRequestStatus::FAILED);
 813
 814   scoped_ptr<BrandcodeConfigFetcher> fetcher = WaitForRequest(GURL(url));
 815   EXPECT_FALSE(fetcher->GetSettings());
 816 }
 817
 818 // Tries to load available config file.
 819 TEST_F(ConfigParserTest, ParseConfig) {
 820   const GURL url("http://test");
 821   std::string xml_config(kXmlConfig);
 822   ReplaceString(&xml_config, "placeholder_for_data", kDistributionConfig);
 823   ReplaceString(&xml_config,
 824                 "placeholder_for_id",
 825                 "abbaabbaabbaabbaabbaabbaabbaabba");
 826   factory().SetFakeResponse(url, xml_config, net::HTTP_OK,
 827                             net::URLRequestStatus::SUCCESS);
 828
 829   scoped_ptr<BrandcodeConfigFetcher> fetcher = WaitForRequest(GURL(url));
 830   scoped_ptr<BrandcodedDefaultSettings> settings = fetcher->GetSettings();
 831   ASSERT_TRUE(settings);
 832
 833   std::vector<std::string> extension_ids;
 834   EXPECT_TRUE(settings->GetExtensions(&extension_ids));
 835   EXPECT_EQ(1u, extension_ids.size());
 836   EXPECT_EQ("abbaabbaabbaabbaabbaabbaabbaabba", extension_ids[0]);
 837
 838   std::string homepage;
 839   EXPECT_TRUE(settings->GetHomepage(&homepage));
 840   EXPECT_EQ("http://www.foo.com", homepage);
 841
 842   scoped_ptr<base::ListValue> startup_list(
 843       settings->GetUrlsToRestoreOnStartup());
 844   EXPECT_TRUE(startup_list);
 845   std::vector<std::string> startup_pages;
 846   for (base::ListValue::iterator i = startup_list->begin();
 847        i != startup_list->end(); ++i) {
 848     std::string url;
 849     EXPECT_TRUE((*i)->GetAsString(&url));
 850     startup_pages.push_back(url);
 851   }
 852   ASSERT_EQ(2u, startup_pages.size());
 853   EXPECT_EQ("http://goo.gl", startup_pages[0]);
 854   EXPECT_EQ("http://foo.de", startup_pages[1]);
 855 }
 856
 857 TEST_F(ProfileResetterTest, CheckSnapshots) {
 858   ResettableSettingsSnapshot empty_snap(profile());
 859   EXPECT_EQ(0, empty_snap.FindDifferentFields(empty_snap));
 860
 861   scoped_refptr<Extension> ext = CreateExtension(
 862       base::ASCIIToUTF16("example"),
 863       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
 864       Manifest::INVALID_LOCATION,
 865       extensions::Manifest::TYPE_EXTENSION,
 866       false);
 867   ASSERT_TRUE(ext);
 868   service_->AddExtension(ext.get());
 869
 870   std::string master_prefs(kDistributionConfig);
 871   std::string ext_id = ext->id();
 872   ReplaceString(&master_prefs, "placeholder_for_id", ext_id);
 873
 874   // Reset to non organic defaults.
 875   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE |
 876                ProfileResetter::HOMEPAGE |
 877                ProfileResetter::STARTUP_PAGES,
 878                master_prefs);
 879   ShortcutHandler shortcut_hijacked;
 880   ShortcutCommand command_line = shortcut_hijacked.CreateWithArguments(
 881       base::ASCIIToUTF16("chrome1.lnk"),
 882       base::ASCIIToUTF16("--profile-directory=Default foo.com"));
 883   shortcut_hijacked.CheckShortcutHasArguments(
 884       base::ASCIIToUTF16("--profile-directory=Default foo.com"));
 885   ShortcutHandler shortcut_ok;
 886   shortcut_ok.CreateWithArguments(
 887       base::ASCIIToUTF16("chrome2.lnk"),
 888       base::ASCIIToUTF16("--profile-directory=Default1"));
 889
 890   ResettableSettingsSnapshot nonorganic_snap(profile());
 891   nonorganic_snap.RequestShortcuts(base::Closure());
 892   // Let it enumerate shortcuts on the FILE thread.
 893   base::MessageLoop::current()->RunUntilIdle();
 894   int diff_fields = ResettableSettingsSnapshot::ALL_FIELDS;
 895   if (!ShortcutHandler::IsSupported())
 896     diff_fields &= ~ResettableSettingsSnapshot::SHORTCUTS;
 897   EXPECT_EQ(diff_fields,
 898             empty_snap.FindDifferentFields(nonorganic_snap));
 899   empty_snap.Subtract(nonorganic_snap);
 900   EXPECT_TRUE(empty_snap.startup_urls().empty());
 901   EXPECT_EQ(SessionStartupPref::GetDefaultStartupType(),
 902             empty_snap.startup_type());
 903   EXPECT_TRUE(empty_snap.homepage().empty());
 904   EXPECT_TRUE(empty_snap.homepage_is_ntp());
 905   EXPECT_FALSE(empty_snap.show_home_button());
 906   EXPECT_NE(std::string::npos, empty_snap.dse_url().find("{google:baseURL}"));
 907   EXPECT_EQ(ResettableSettingsSnapshot::ExtensionList(),
 908             empty_snap.enabled_extensions());
 909   EXPECT_EQ(std::vector<ShortcutCommand>(), empty_snap.shortcuts());
 910
 911   // Reset to organic defaults.
 912   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE |
 913                ProfileResetter::HOMEPAGE |
 914                ProfileResetter::STARTUP_PAGES |
 915                ProfileResetter::EXTENSIONS |
 916                ProfileResetter::SHORTCUTS);
 917
 918   ResettableSettingsSnapshot organic_snap(profile());
 919   organic_snap.RequestShortcuts(base::Closure());
 920   // Let it enumerate shortcuts on the FILE thread.
 921   base::MessageLoop::current()->RunUntilIdle();
 922   EXPECT_EQ(diff_fields, nonorganic_snap.FindDifferentFields(organic_snap));
 923   nonorganic_snap.Subtract(organic_snap);
 924   const GURL urls[] = {GURL("http://foo.de"), GURL("http://goo.gl")};
 925   EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)),
 926             nonorganic_snap.startup_urls());
 927   EXPECT_EQ(SessionStartupPref::URLS, nonorganic_snap.startup_type());
 928   EXPECT_EQ("http://www.foo.com", nonorganic_snap.homepage());
 929   EXPECT_FALSE(nonorganic_snap.homepage_is_ntp());
 930   EXPECT_TRUE(nonorganic_snap.show_home_button());
 931   EXPECT_EQ("http://www.foo.com/s?q={searchTerms}", nonorganic_snap.dse_url());
 932   EXPECT_EQ(ResettableSettingsSnapshot::ExtensionList(
 933       1, std::make_pair(ext_id, "example")),
 934       nonorganic_snap.enabled_extensions());
 935   if (ShortcutHandler::IsSupported()) {
 936     std::vector<ShortcutCommand> shortcuts = nonorganic_snap.shortcuts();
 937     ASSERT_EQ(1u, shortcuts.size());
 938     EXPECT_EQ(command_line.first.value(), shortcuts[0].first.value());
 939     EXPECT_EQ(command_line.second, shortcuts[0].second);
 940   }
 941 }
 942
 943 TEST_F(ProfileResetterTest, FeedbackSerializationTest) {
 944   // Reset to non organic defaults.
 945   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE |
 946                ProfileResetter::HOMEPAGE |
 947                ProfileResetter::STARTUP_PAGES,
 948                kDistributionConfig);
 949
 950   scoped_refptr<Extension> ext = CreateExtension(
 951       base::ASCIIToUTF16("example"),
 952       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
 953       Manifest::INVALID_LOCATION,
 954       extensions::Manifest::TYPE_EXTENSION,
 955       false);
 956   ASSERT_TRUE(ext);
 957   service_->AddExtension(ext.get());
 958
 959   ShortcutHandler shortcut;
 960   ShortcutCommand command_line = shortcut.CreateWithArguments(
 961       base::ASCIIToUTF16("chrome.lnk"),
 962       base::ASCIIToUTF16("--profile-directory=Default foo.com"));
 963
 964   ResettableSettingsSnapshot nonorganic_snap(profile());
 965   nonorganic_snap.RequestShortcuts(base::Closure());
 966   // Let it enumerate shortcuts on the FILE thread.
 967   base::MessageLoop::current()->RunUntilIdle();
 968
 969   COMPILE_ASSERT(ResettableSettingsSnapshot::ALL_FIELDS == 31,
 970                  expand_this_test);
 971   for (int field_mask = 0; field_mask <= ResettableSettingsSnapshot::ALL_FIELDS;
 972        ++field_mask) {
 973     std::string report = SerializeSettingsReport(nonorganic_snap, field_mask);
 974     JSONStringValueSerializer json(report);
 975     std::string error;
 976     scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
 977     ASSERT_TRUE(root) << error;
 978     ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY)) << error;
 979
 980     base::DictionaryValue* dict =
 981         static_cast<base::DictionaryValue*>(root.get());
 982
 983     base::ListValue* startup_urls = NULL;
 984     int startup_type = 0;
 985     std::string homepage;
 986     bool homepage_is_ntp = true;
 987     bool show_home_button = true;
 988     std::string default_search_engine;
 989     base::ListValue* extensions = NULL;
 990     base::ListValue* shortcuts = NULL;
 991
 992     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::STARTUP_MODE),
 993               dict->GetList("startup_urls", &startup_urls));
 994     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::STARTUP_MODE),
 995               dict->GetInteger("startup_type", &startup_type));
 996     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::HOMEPAGE),
 997               dict->GetString("homepage", &homepage));
 998     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::HOMEPAGE),
 999               dict->GetBoolean("homepage_is_ntp", &homepage_is_ntp));
1000     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::HOMEPAGE),
1001               dict->GetBoolean("show_home_button", &show_home_button));
1002     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::DSE_URL),
1003               dict->GetString("default_search_engine", &default_search_engine));
1004     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::EXTENSIONS),
1005               dict->GetList("enabled_extensions", &extensions));
1006     EXPECT_EQ(!!(field_mask & ResettableSettingsSnapshot::SHORTCUTS),
1007               dict->GetList("shortcuts", &shortcuts));
1008   }
1009 }
1010
1011 struct FeedbackCapture {
1012   void SetFeedback(Profile* profile,
1013                    const ResettableSettingsSnapshot& snapshot) {
1014     list_ = GetReadableFeedbackForSnapshot(profile, snapshot).Pass();
1015     OnUpdatedList();
1016   }
1017
1018   void Fail() {
1019     ADD_FAILURE() << "This method shouldn't be called.";
1020   }
1021
1022   MOCK_METHOD0(OnUpdatedList, void(void));
1023
1024   scoped_ptr<base::ListValue> list_;
1025 };
1026
1027 // Make sure GetReadableFeedback handles non-ascii letters.
1028 TEST_F(ProfileResetterTest, GetReadableFeedback) {
1029   scoped_refptr<Extension> ext = CreateExtension(
1030       base::WideToUTF16(L"Tiësto"),
1031       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
1032       Manifest::INVALID_LOCATION,
1033       extensions::Manifest::TYPE_EXTENSION,
1034       false);
1035   ASSERT_TRUE(ext);
1036   service_->AddExtension(ext.get());
1037
1038   PrefService* prefs = profile()->GetPrefs();
1039   DCHECK(prefs);
1040   // The URL is "http://россия.рф".
1041   std::wstring url(L"http://"
1042     L"\u0440\u043e\u0441\u0441\u0438\u044f.\u0440\u0444");
1043   prefs->SetBoolean(prefs::kHomePageIsNewTabPage, false);
1044   prefs->SetString(prefs::kHomePage, base::WideToUTF8(url));
1045
1046   SessionStartupPref startup_pref(SessionStartupPref::URLS);
1047   startup_pref.urls.push_back(GURL(base::WideToUTF8(url)));
1048   SessionStartupPref::SetStartupPref(prefs, startup_pref);
1049
1050   ShortcutHandler shortcut;
1051   ShortcutCommand command_line = shortcut.CreateWithArguments(
1052       base::ASCIIToUTF16("chrome.lnk"),
1053       base::ASCIIToUTF16("--profile-directory=Default foo.com"));
1054
1055   FeedbackCapture capture;
1056   EXPECT_CALL(capture, OnUpdatedList());
1057   ResettableSettingsSnapshot snapshot(profile());
1058   snapshot.RequestShortcuts(base::Bind(&FeedbackCapture::SetFeedback,
1059                                        base::Unretained(&capture),
1060                                        profile(),
1061                                        base::ConstRef(snapshot)));
1062   // Let it enumerate shortcuts on the FILE thread.
1063   base::MessageLoop::current()->RunUntilIdle();
1064   ::testing::Mock::VerifyAndClearExpectations(&capture);
1065   // The homepage and the startup page are in punycode. They are unreadable.
1066   // Trying to find the extension name.
1067   scoped_ptr<base::ListValue> list = capture.list_.Pass();
1068   ASSERT_TRUE(list);
1069   bool checked_extensions = false;
1070   bool checked_shortcuts = false;
1071   for (size_t i = 0; i < list->GetSize(); ++i) {
1072     base::DictionaryValue* dict = NULL;
1073     ASSERT_TRUE(list->GetDictionary(i, &dict));
1074     std::string value;
1075     ASSERT_TRUE(dict->GetString("key", &value));
1076     if (value == "Extensions") {
1077       base::string16 extensions;
1078       EXPECT_TRUE(dict->GetString("value", &extensions));
1079       EXPECT_EQ(base::WideToUTF16(L"Tiësto"), extensions);
1080       checked_extensions = true;
1081     } else if (value == "Shortcut targets") {
1082       base::string16 targets;
1083       EXPECT_TRUE(dict->GetString("value", &targets));
1084       EXPECT_NE(base::string16::npos,
1085                 targets.find(base::ASCIIToUTF16("foo.com"))) << targets;
1086       checked_shortcuts = true;
1087     }
1088   }
1089   EXPECT_TRUE(checked_extensions);
1090   EXPECT_EQ(ShortcutHandler::IsSupported(), checked_shortcuts);
1091 }
1092
1093 TEST_F(ProfileResetterTest, DestroySnapshotFast) {
1094   FeedbackCapture capture;
1095   scoped_ptr<ResettableSettingsSnapshot> deleted_snapshot(
1096       new ResettableSettingsSnapshot(profile()));
1097   deleted_snapshot->RequestShortcuts(base::Bind(&FeedbackCapture::Fail,
1098                                                 base::Unretained(&capture)));
1099   deleted_snapshot.reset();
1100   // Running remaining tasks shouldn't trigger the callback to be called as
1101   // |deleted_snapshot| was deleted before it could run.
1102   base::MessageLoop::current()->RunUntilIdle();
1103 }
1104
1105 }  // namespace