chrome/browser/ui/startup/startup_browser_creator_browsertest.cc

   1 // Copyright (c) 2012 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 <algorithm>
   6 #include <string>
   7
   8 #include "base/command_line.h"
   9 #include "base/files/file_path.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/extensions/extension_browsertest.h"
  14 #include "chrome/browser/extensions/extension_service.h"
  15 #include "chrome/browser/extensions/extension_system.h"
  16 #include "chrome/browser/first_run/first_run.h"
  17 #include "chrome/browser/infobars/infobar_service.h"
  18 #include "chrome/browser/managed_mode/managed_mode_navigation_observer.h"
  19 #include "chrome/browser/managed_mode/managed_user_service.h"
  20 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
  21 #include "chrome/browser/prefs/session_startup_pref.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/browser/profiles/profile_impl.h"
  24 #include "chrome/browser/profiles/profile_manager.h"
  25 #include "chrome/browser/sessions/session_restore.h"
  26 #include "chrome/browser/signin/signin_promo.h"
  27 #include "chrome/browser/ui/browser.h"
  28 #include "chrome/browser/ui/browser_finder.h"
  29 #include "chrome/browser/ui/browser_iterator.h"
  30 #include "chrome/browser/ui/browser_list.h"
  31 #include "chrome/browser/ui/browser_list_observer.h"
  32 #include "chrome/browser/ui/browser_window.h"
  33 #include "chrome/browser/ui/host_desktop.h"
  34 #include "chrome/browser/ui/startup/startup_browser_creator.h"
  35 #include "chrome/browser/ui/startup/startup_browser_creator_impl.h"
  36 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  37 #include "chrome/common/chrome_switches.h"
  38 #include "chrome/common/pref_names.h"
  39 #include "chrome/common/url_constants.h"
  40 #include "chrome/test/base/in_process_browser_test.h"
  41 #include "chrome/test/base/test_switches.h"
  42 #include "chrome/test/base/ui_test_utils.h"
  43 #include "content/public/browser/web_contents.h"
  44 #include "testing/gtest/include/gtest/gtest.h"
  45 #include "url/gurl.h"
  46
  47 #if defined(ENABLE_CONFIGURATION_POLICY) && !defined(OS_CHROMEOS)
  48 #include "base/callback.h"
  49 #include "base/run_loop.h"
  50 #include "base/values.h"
  51 #include "chrome/browser/policy/browser_policy_connector.h"
  52 #include "chrome/browser/policy/external_data_fetcher.h"
  53 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
  54 #include "chrome/browser/policy/policy_map.h"
  55 #include "chrome/browser/policy/policy_types.h"
  56 #include "policy/policy_constants.h"
  57 #include "testing/gmock/include/gmock/gmock.h"
  58
  59 using testing::_;
  60 using testing::AnyNumber;
  61 using testing::Return;
  62 #endif  // defined(ENABLE_CONFIGURATION_POLICY) && !defined(OS_CHROMEOS)
  63
  64 using extensions::Extension;
  65
  66 namespace {
  67
  68 // Check that there are two browsers. Find the one that is not |browser|.
  69 Browser* FindOneOtherBrowser(Browser* browser) {
  70   // There should only be one other browser.
  71   EXPECT_EQ(2u, chrome::GetBrowserCount(browser->profile(),
  72                                         browser->host_desktop_type()));
  73
  74   // Find the new browser.
  75   Browser* other_browser = NULL;
  76   for (chrome::BrowserIterator it; !it.done() && !other_browser; it.Next()) {
  77     if (*it != browser)
  78       other_browser = *it;
  79   }
  80   return other_browser;
  81 }
  82
  83 }  // namespace
  84
  85 class StartupBrowserCreatorTest : public ExtensionBrowserTest {
  86  protected:
  87   virtual bool SetUpUserDataDirectory() OVERRIDE {
  88     return ExtensionBrowserTest::SetUpUserDataDirectory();
  89   }
  90
  91   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  92     ExtensionBrowserTest::SetUpCommandLine(command_line);
  93     command_line->AppendSwitch(switches::kEnablePanels);
  94     command_line->AppendSwitchASCII(switches::kHomePage,
  95                                     content::kAboutBlankURL);
  96 #if defined(OS_CHROMEOS)
  97     // TODO(nkostylev): Investigate if we can remove this switch.
  98     command_line->AppendSwitch(switches::kCreateBrowserOnStartupForTests);
  99 #endif
 100   }
 101
 102   // Helper functions return void so that we can ASSERT*().
 103   // Use ASSERT_NO_FATAL_FAILURE around calls to these functions to stop the
 104   // test if an assert fails.
 105   void LoadApp(const std::string& app_name,
 106                const Extension** out_app_extension) {
 107     ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(app_name.c_str())));
 108
 109     ExtensionService* service = extensions::ExtensionSystem::Get(
 110         browser()->profile())->extension_service();
 111     *out_app_extension = service->GetExtensionById(
 112         last_loaded_extension_id_, false);
 113     ASSERT_TRUE(*out_app_extension);
 114
 115     // Code that opens a new browser assumes we start with exactly one.
 116     ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 117                                           browser()->host_desktop_type()));
 118   }
 119
 120   void SetAppLaunchPref(const std::string& app_id,
 121                         extensions::ExtensionPrefs::LaunchType launch_type) {
 122     ExtensionService* service = extensions::ExtensionSystem::Get(
 123         browser()->profile())->extension_service();
 124     service->extension_prefs()->SetLaunchType(app_id, launch_type);
 125   }
 126
 127   Browser* FindOneOtherBrowserForProfile(Profile* profile,
 128                                          Browser* not_this_browser) {
 129     for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 130       if (*it != not_this_browser && it->profile() == profile)
 131         return *it;
 132     }
 133     return NULL;
 134   }
 135 };
 136
 137 class OpenURLsPopupObserver : public chrome::BrowserListObserver {
 138  public:
 139   OpenURLsPopupObserver() : added_browser_(NULL) { }
 140
 141   virtual void OnBrowserAdded(Browser* browser) OVERRIDE {
 142     added_browser_ = browser;
 143   }
 144
 145   virtual void OnBrowserRemoved(Browser* browser) OVERRIDE { }
 146
 147   Browser* added_browser_;
 148 };
 149
 150 // Test that when there is a popup as the active browser any requests to
 151 // StartupBrowserCreatorImpl::OpenURLsInBrowser don't crash because there's no
 152 // explicit profile given.
 153 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, OpenURLsPopup) {
 154   std::vector<GURL> urls;
 155   urls.push_back(GURL("http://localhost"));
 156
 157   // Note that in our testing we do not ever query the BrowserList for the "last
 158   // active" browser. That's because the browsers are set as "active" by
 159   // platform UI toolkit messages, and those messages are not sent during unit
 160   // testing sessions.
 161
 162   OpenURLsPopupObserver observer;
 163   BrowserList::AddObserver(&observer);
 164
 165   Browser* popup = new Browser(
 166       Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(),
 167                             browser()->host_desktop_type()));
 168   ASSERT_TRUE(popup->is_type_popup());
 169   ASSERT_EQ(popup, observer.added_browser_);
 170
 171   CommandLine dummy(CommandLine::NO_PROGRAM);
 172   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
 173       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
 174   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
 175   // This should create a new window, but re-use the profile from |popup|. If
 176   // it used a NULL or invalid profile, it would crash.
 177   launch.OpenURLsInBrowser(popup, false, urls, chrome::GetActiveDesktop());
 178   ASSERT_NE(popup, observer.added_browser_);
 179   BrowserList::RemoveObserver(&observer);
 180 }
 181
 182 // We don't do non-process-startup browser launches on ChromeOS.
 183 // Session restore for process-startup browser launches is tested
 184 // in session_restore_uitest.
 185 #if !defined(OS_CHROMEOS)
 186 // Verify that startup URLs are honored when the process already exists but has
 187 // no tabbed browser windows (eg. as if the process is running only due to a
 188 // background application.
 189 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
 190                        StartupURLsOnNewWindowWithNoTabbedBrowsers) {
 191   // Use a couple same-site HTTP URLs.
 192   ASSERT_TRUE(test_server()->Start());
 193   std::vector<GURL> urls;
 194   urls.push_back(test_server()->GetURL("files/title1.html"));
 195   urls.push_back(test_server()->GetURL("files/title2.html"));
 196
 197   // Set the startup preference to open these URLs.
 198   SessionStartupPref pref(SessionStartupPref::URLS);
 199   pref.urls = urls;
 200   SessionStartupPref::SetStartupPref(browser()->profile(), pref);
 201
 202   // Close the browser.
 203   browser()->window()->Close();
 204
 205   // Do a simple non-process-startup browser launch.
 206   CommandLine dummy(CommandLine::NO_PROGRAM);
 207   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
 208       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
 209   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
 210   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 211                             browser()->host_desktop_type()));
 212
 213   // This should have created a new browser window.  |browser()| is still
 214   // around at this point, even though we've closed its window.
 215   Browser* new_browser = FindOneOtherBrowser(browser());
 216   ASSERT_TRUE(new_browser);
 217
 218   // The new browser should have one tab for each URL.
 219   TabStripModel* tab_strip = new_browser->tab_strip_model();
 220   ASSERT_EQ(static_cast<int>(urls.size()), tab_strip->count());
 221   for (size_t i=0; i < urls.size(); i++) {
 222     EXPECT_EQ(urls[i], tab_strip->GetWebContentsAt(i)->GetURL());
 223   }
 224
 225   // The two tabs, despite having the same site, should be in different
 226   // SiteInstances.
 227   EXPECT_NE(tab_strip->GetWebContentsAt(0)->GetSiteInstance(),
 228             tab_strip->GetWebContentsAt(1)->GetSiteInstance());
 229 }
 230
 231 // Verify that startup URLs aren't used when the process already exists
 232 // and has other tabbed browser windows.  This is the common case of starting a
 233 // new browser.
 234 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
 235                        StartupURLsOnNewWindow) {
 236   // Use a couple arbitrary URLs.
 237   std::vector<GURL> urls;
 238   urls.push_back(ui_test_utils::GetTestUrl(
 239       base::FilePath(base::FilePath::kCurrentDirectory),
 240       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 241   urls.push_back(ui_test_utils::GetTestUrl(
 242       base::FilePath(base::FilePath::kCurrentDirectory),
 243       base::FilePath(FILE_PATH_LITERAL("title2.html"))));
 244
 245   // Set the startup preference to open these URLs.
 246   SessionStartupPref pref(SessionStartupPref::URLS);
 247   pref.urls = urls;
 248   SessionStartupPref::SetStartupPref(browser()->profile(), pref);
 249
 250   // Do a simple non-process-startup browser launch.
 251   CommandLine dummy(CommandLine::NO_PROGRAM);
 252   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
 253       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
 254   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
 255   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 256                             browser()->host_desktop_type()));
 257
 258   // This should have created a new browser window.
 259   Browser* new_browser = FindOneOtherBrowser(browser());
 260   ASSERT_TRUE(new_browser);
 261
 262   // The new browser should have exactly one tab (not the startup URLs).
 263   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 264 }
 265
 266 // App shortcuts are not implemented on mac os.
 267 #if !defined(OS_MACOSX)
 268 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, OpenAppShortcutNoPref) {
 269   // Load an app with launch.container = 'tab'.
 270   const Extension* extension_app = NULL;
 271   ASSERT_NO_FATAL_FAILURE(LoadApp("app_with_tab_container", &extension_app));
 272
 273   // Add --app-id=<extension->id()> to the command line.
 274   CommandLine command_line(CommandLine::NO_PROGRAM);
 275   command_line.AppendSwitchASCII(switches::kAppId, extension_app->id());
 276
 277   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
 278       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
 279   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
 280   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 281                             browser()->host_desktop_type()));
 282
 283   // No pref was set, so the app should have opened in a window.
 284   // The launch should have created a new browser.
 285   Browser* new_browser = FindOneOtherBrowser(browser());
 286   ASSERT_TRUE(new_browser);
 287
 288   // Expect an app window.
 289   EXPECT_TRUE(new_browser->is_app());
 290
 291   // The browser's app_name should include the app's ID.
 292   EXPECT_NE(
 293       new_browser->app_name_.find(extension_app->id()),
 294       std::string::npos) << new_browser->app_name_;
 295 }
 296
 297 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, OpenAppShortcutWindowPref) {
 298   const Extension* extension_app = NULL;
 299   ASSERT_NO_FATAL_FAILURE(LoadApp("app_with_tab_container", &extension_app));
 300
 301   // Set a pref indicating that the user wants to open this app in a window.
 302   SetAppLaunchPref(extension_app->id(),
 303                    extensions::ExtensionPrefs::LAUNCH_WINDOW);
 304
 305   CommandLine command_line(CommandLine::NO_PROGRAM);
 306   command_line.AppendSwitchASCII(switches::kAppId, extension_app->id());
 307   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
 308       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
 309   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
 310   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 311                             browser()->host_desktop_type()));
 312
 313   // Pref was set to open in a window, so the app should have opened in a
 314   // window.  The launch should have created a new browser. Find the new
 315   // browser.
 316   Browser* new_browser = FindOneOtherBrowser(browser());
 317   ASSERT_TRUE(new_browser);
 318
 319   // Expect an app window.
 320   EXPECT_TRUE(new_browser->is_app());
 321
 322   // The browser's app_name should include the app's ID.
 323   EXPECT_NE(
 324       new_browser->app_name_.find(extension_app->id()),
 325       std::string::npos) << new_browser->app_name_;
 326 }
 327
 328 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, OpenAppShortcutTabPref) {
 329   // Load an app with launch.container = 'tab'.
 330   const Extension* extension_app = NULL;
 331   ASSERT_NO_FATAL_FAILURE(LoadApp("app_with_tab_container", &extension_app));
 332
 333   // Set a pref indicating that the user wants to open this app in a window.
 334   SetAppLaunchPref(extension_app->id(),
 335                    extensions::ExtensionPrefs::LAUNCH_REGULAR);
 336
 337   CommandLine command_line(CommandLine::NO_PROGRAM);
 338   command_line.AppendSwitchASCII(switches::kAppId, extension_app->id());
 339   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
 340       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
 341   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
 342   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 343                             browser()->host_desktop_type()));
 344
 345   // When an app shortcut is open and the pref indicates a tab should
 346   // open, the tab is open in a new browser window.  Expect a new window.
 347   ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
 348                                         browser()->host_desktop_type()));
 349
 350   Browser* new_browser = FindOneOtherBrowser(browser());
 351   ASSERT_TRUE(new_browser);
 352
 353   // The tab should be in a tabbed window.
 354   EXPECT_TRUE(new_browser->is_type_tabbed());
 355
 356   // The browser's app_name should not include the app's ID: It is in a
 357   // normal browser.
 358   EXPECT_EQ(
 359       new_browser->app_name_.find(extension_app->id()),
 360       std::string::npos) << new_browser->app_name_;
 361 }
 362
 363 #endif  // !defined(OS_MACOSX)
 364
 365 #endif  // !defined(OS_CHROMEOS)
 366
 367 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
 368                        ReadingWasRestartedAfterRestart) {
 369   // Tests that StartupBrowserCreator::WasRestarted reads and resets the
 370   // preference kWasRestarted correctly.
 371   StartupBrowserCreator::was_restarted_read_ = false;
 372   PrefService* pref_service = g_browser_process->local_state();
 373   pref_service->SetBoolean(prefs::kWasRestarted, true);
 374   EXPECT_TRUE(StartupBrowserCreator::WasRestarted());
 375   EXPECT_FALSE(pref_service->GetBoolean(prefs::kWasRestarted));
 376   EXPECT_TRUE(StartupBrowserCreator::WasRestarted());
 377 }
 378
 379 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
 380                        ReadingWasRestartedAfterNormalStart) {
 381   // Tests that StartupBrowserCreator::WasRestarted reads and resets the
 382   // preference kWasRestarted correctly.
 383   StartupBrowserCreator::was_restarted_read_ = false;
 384   PrefService* pref_service = g_browser_process->local_state();
 385   pref_service->SetBoolean(prefs::kWasRestarted, false);
 386   EXPECT_FALSE(StartupBrowserCreator::WasRestarted());
 387   EXPECT_FALSE(pref_service->GetBoolean(prefs::kWasRestarted));
 388   EXPECT_FALSE(StartupBrowserCreator::WasRestarted());
 389 }
 390
 391 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, AddFirstRunTab) {
 392   StartupBrowserCreator browser_creator;
 393   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
 394   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title2.html"));
 395
 396   // Do a simple non-process-startup browser launch.
 397   CommandLine dummy(CommandLine::NO_PROGRAM);
 398   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
 399                                    chrome::startup::IS_FIRST_RUN);
 400   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 401                             browser()->host_desktop_type()));
 402
 403   // This should have created a new browser window.
 404   Browser* new_browser = FindOneOtherBrowser(browser());
 405   ASSERT_TRUE(new_browser);
 406
 407   TabStripModel* tab_strip = new_browser->tab_strip_model();
 408   EXPECT_EQ(2, tab_strip->count());
 409
 410   EXPECT_EQ("title1.html",
 411             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
 412   EXPECT_EQ("title2.html",
 413             tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
 414 }
 415
 416 // Test hard-coded special first run tabs (defined in
 417 // StartupBrowserCreatorImpl::AddStartupURLs()).
 418 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, AddCustomFirstRunTab) {
 419   StartupBrowserCreator browser_creator;
 420   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
 421   browser_creator.AddFirstRunTab(GURL("http://new_tab_page"));
 422   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title2.html"));
 423   browser_creator.AddFirstRunTab(GURL("http://welcome_page"));
 424
 425   // Do a simple non-process-startup browser launch.
 426   CommandLine dummy(CommandLine::NO_PROGRAM);
 427   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
 428                                    chrome::startup::IS_FIRST_RUN);
 429   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 430                             browser()->host_desktop_type()));
 431
 432   // This should have created a new browser window.
 433   Browser* new_browser = FindOneOtherBrowser(browser());
 434   ASSERT_TRUE(new_browser);
 435
 436   TabStripModel* tab_strip = new_browser->tab_strip_model();
 437   EXPECT_EQ(4, tab_strip->count());
 438
 439   EXPECT_EQ("title1.html",
 440             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
 441   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
 442             tab_strip->GetWebContentsAt(1)->GetURL());
 443   EXPECT_EQ("title2.html",
 444             tab_strip->GetWebContentsAt(2)->GetURL().ExtractFileName());
 445   EXPECT_EQ(internals::GetWelcomePageURL(),
 446             tab_strip->GetWebContentsAt(3)->GetURL());
 447 }
 448
 449 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, SyncPromoNoWelcomePage) {
 450   // Do a simple non-process-startup browser launch.
 451   CommandLine dummy(CommandLine::NO_PROGRAM);
 452   StartupBrowserCreatorImpl launch(base::FilePath(), dummy,
 453                                    chrome::startup::IS_FIRST_RUN);
 454   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 455                             browser()->host_desktop_type()));
 456
 457   // This should have created a new browser window.
 458   Browser* new_browser = FindOneOtherBrowser(browser());
 459   ASSERT_TRUE(new_browser);
 460
 461   TabStripModel* tab_strip = new_browser->tab_strip_model();
 462   EXPECT_EQ(1, tab_strip->count());
 463
 464   if (signin::ShouldShowPromoAtStartup(browser()->profile(), true)) {
 465     EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
 466               tab_strip->GetWebContentsAt(0)->GetURL());
 467   } else {
 468     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
 469               tab_strip->GetWebContentsAt(0)->GetURL());
 470   }
 471 }
 472
 473 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, SyncPromoWithWelcomePage) {
 474   first_run::SetShouldShowWelcomePage();
 475
 476   // Do a simple non-process-startup browser launch.
 477   CommandLine dummy(CommandLine::NO_PROGRAM);
 478   StartupBrowserCreatorImpl launch(base::FilePath(), dummy,
 479                                    chrome::startup::IS_FIRST_RUN);
 480   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 481                             browser()->host_desktop_type()));
 482
 483   // This should have created a new browser window.
 484   Browser* new_browser = FindOneOtherBrowser(browser());
 485   ASSERT_TRUE(new_browser);
 486
 487   TabStripModel* tab_strip = new_browser->tab_strip_model();
 488   EXPECT_EQ(2, tab_strip->count());
 489
 490   if (signin::ShouldShowPromoAtStartup(browser()->profile(), true)) {
 491     EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
 492               tab_strip->GetWebContentsAt(0)->GetURL());
 493   } else {
 494     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
 495               tab_strip->GetWebContentsAt(0)->GetURL());
 496   }
 497   EXPECT_EQ(internals::GetWelcomePageURL(),
 498             tab_strip->GetWebContentsAt(1)->GetURL());
 499 }
 500
 501 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, SyncPromoWithFirstRunTabs) {
 502   StartupBrowserCreator browser_creator;
 503   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
 504
 505   // The welcome page should not be shown, even if
 506   // first_run::ShouldShowWelcomePage() says so, when there are already
 507   // more than 2 first run tabs.
 508   first_run::SetShouldShowWelcomePage();
 509
 510   // Do a simple non-process-startup browser launch.
 511   CommandLine dummy(CommandLine::NO_PROGRAM);
 512   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
 513                                    chrome::startup::IS_FIRST_RUN);
 514   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 515                             browser()->host_desktop_type()));
 516
 517   // This should have created a new browser window.
 518   Browser* new_browser = FindOneOtherBrowser(browser());
 519   ASSERT_TRUE(new_browser);
 520
 521   TabStripModel* tab_strip = new_browser->tab_strip_model();
 522   if (signin::ShouldShowPromoAtStartup(browser()->profile(), true)) {
 523     EXPECT_EQ(2, tab_strip->count());
 524     EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
 525               tab_strip->GetWebContentsAt(0)->GetURL());
 526     EXPECT_EQ("title1.html",
 527               tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
 528   } else {
 529     EXPECT_EQ(1, tab_strip->count());
 530     EXPECT_EQ("title1.html",
 531               tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
 532   }
 533 }
 534
 535 // The welcome page should still be shown if there are more than 2 first run
 536 // tabs, but the welcome page was explcitly added to the first run tabs.
 537 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
 538                        SyncPromoWithFirstRunTabsIncludingWelcomePage) {
 539   StartupBrowserCreator browser_creator;
 540   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
 541   browser_creator.AddFirstRunTab(GURL("http://welcome_page"));
 542
 543   // Do a simple non-process-startup browser launch.
 544   CommandLine dummy(CommandLine::NO_PROGRAM);
 545   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
 546                                    chrome::startup::IS_FIRST_RUN);
 547   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 548                             browser()->host_desktop_type()));
 549
 550   // This should have created a new browser window.
 551   Browser* new_browser = FindOneOtherBrowser(browser());
 552   ASSERT_TRUE(new_browser);
 553
 554   TabStripModel* tab_strip = new_browser->tab_strip_model();
 555   if (signin::ShouldShowPromoAtStartup(browser()->profile(), true)) {
 556     EXPECT_EQ(3, tab_strip->count());
 557     EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
 558               tab_strip->GetWebContentsAt(0)->GetURL());
 559     EXPECT_EQ("title1.html",
 560               tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
 561     EXPECT_EQ(internals::GetWelcomePageURL(),
 562               tab_strip->GetWebContentsAt(2)->GetURL());
 563   } else {
 564     EXPECT_EQ(2, tab_strip->count());
 565     EXPECT_EQ("title1.html",
 566               tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
 567     EXPECT_EQ(internals::GetWelcomePageURL(),
 568               tab_strip->GetWebContentsAt(1)->GetURL());
 569   }
 570 }
 571
 572 #if !defined(OS_CHROMEOS)
 573 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, StartupURLsForTwoProfiles) {
 574 #if defined(OS_WIN) && defined(USE_ASH)
 575   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 576   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 577     return;
 578 #endif
 579
 580   Profile* default_profile = browser()->profile();
 581
 582   ProfileManager* profile_manager = g_browser_process->profile_manager();
 583   // Create another profile.
 584   base::FilePath dest_path = profile_manager->user_data_dir();
 585   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile 1"));
 586
 587   Profile* other_profile = profile_manager->GetProfile(dest_path);
 588   ASSERT_TRUE(other_profile);
 589
 590   // Use a couple arbitrary URLs.
 591   std::vector<GURL> urls1;
 592   urls1.push_back(ui_test_utils::GetTestUrl(
 593       base::FilePath(base::FilePath::kCurrentDirectory),
 594       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 595   std::vector<GURL> urls2;
 596   urls2.push_back(ui_test_utils::GetTestUrl(
 597       base::FilePath(base::FilePath::kCurrentDirectory),
 598       base::FilePath(FILE_PATH_LITERAL("title2.html"))));
 599
 600   // Set different startup preferences for the 2 profiles.
 601   SessionStartupPref pref1(SessionStartupPref::URLS);
 602   pref1.urls = urls1;
 603   SessionStartupPref::SetStartupPref(default_profile, pref1);
 604   SessionStartupPref pref2(SessionStartupPref::URLS);
 605   pref2.urls = urls2;
 606   SessionStartupPref::SetStartupPref(other_profile, pref2);
 607
 608   // Close the browser.
 609   browser()->window()->Close();
 610
 611   // Do a simple non-process-startup browser launch.
 612   CommandLine dummy(CommandLine::NO_PROGRAM);
 613
 614   int return_code;
 615   StartupBrowserCreator browser_creator;
 616   std::vector<Profile*> last_opened_profiles;
 617   last_opened_profiles.push_back(default_profile);
 618   last_opened_profiles.push_back(other_profile);
 619   browser_creator.Start(dummy, profile_manager->user_data_dir(),
 620                         default_profile, last_opened_profiles, &return_code);
 621
 622   // urls1 were opened in a browser for default_profile, and urls2 were opened
 623   // in a browser for other_profile.
 624   Browser* new_browser = NULL;
 625   // |browser()| is still around at this point, even though we've closed its
 626   // window. Thus the browser count for default_profile is 2.
 627   ASSERT_EQ(2u, chrome::GetBrowserCount(default_profile,
 628                                         browser()->host_desktop_type()));
 629   new_browser = FindOneOtherBrowserForProfile(default_profile, browser());
 630   ASSERT_TRUE(new_browser);
 631   TabStripModel* tab_strip = new_browser->tab_strip_model();
 632   ASSERT_EQ(1, tab_strip->count());
 633   EXPECT_EQ(urls1[0], tab_strip->GetWebContentsAt(0)->GetURL());
 634
 635   ASSERT_EQ(1u, chrome::GetBrowserCount(other_profile,
 636                                         browser()->host_desktop_type()));
 637   new_browser = FindOneOtherBrowserForProfile(other_profile, NULL);
 638   ASSERT_TRUE(new_browser);
 639   tab_strip = new_browser->tab_strip_model();
 640   ASSERT_EQ(1, tab_strip->count());
 641   EXPECT_EQ(urls2[0], tab_strip->GetWebContentsAt(0)->GetURL());
 642 }
 643
 644 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, PRE_UpdateWithTwoProfiles) {
 645   // Simulate a browser restart by creating the profiles in the PRE_ part.
 646   ProfileManager* profile_manager = g_browser_process->profile_manager();
 647
 648   // Create two profiles.
 649   base::FilePath dest_path = profile_manager->user_data_dir();
 650
 651   Profile* profile1 = profile_manager->GetProfile(
 652       dest_path.Append(FILE_PATH_LITERAL("New Profile 1")));
 653   ASSERT_TRUE(profile1);
 654
 655   Profile* profile2 = profile_manager->GetProfile(
 656       dest_path.Append(FILE_PATH_LITERAL("New Profile 2")));
 657   ASSERT_TRUE(profile2);
 658
 659   // Use a couple arbitrary URLs.
 660   std::vector<GURL> urls1;
 661   urls1.push_back(ui_test_utils::GetTestUrl(
 662       base::FilePath(base::FilePath::kCurrentDirectory),
 663       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 664   std::vector<GURL> urls2;
 665   urls2.push_back(ui_test_utils::GetTestUrl(
 666       base::FilePath(base::FilePath::kCurrentDirectory),
 667       base::FilePath(FILE_PATH_LITERAL("title2.html"))));
 668
 669   // Set different startup preferences for the 2 profiles.
 670   SessionStartupPref pref1(SessionStartupPref::URLS);
 671   pref1.urls = urls1;
 672   SessionStartupPref::SetStartupPref(profile1, pref1);
 673   SessionStartupPref pref2(SessionStartupPref::URLS);
 674   pref2.urls = urls2;
 675   SessionStartupPref::SetStartupPref(profile2, pref2);
 676
 677   profile1->GetPrefs()->CommitPendingWrite();
 678   profile2->GetPrefs()->CommitPendingWrite();
 679 }
 680
 681 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, UpdateWithTwoProfiles) {
 682 #if defined(OS_WIN) && defined(USE_ASH)
 683   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 684   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 685     return;
 686 #endif
 687
 688   // Make StartupBrowserCreator::WasRestarted() return true.
 689   StartupBrowserCreator::was_restarted_read_ = false;
 690   PrefService* pref_service = g_browser_process->local_state();
 691   pref_service->SetBoolean(prefs::kWasRestarted, true);
 692
 693   ProfileManager* profile_manager = g_browser_process->profile_manager();
 694
 695   // Open the two profiles.
 696   base::FilePath dest_path = profile_manager->user_data_dir();
 697
 698   Profile* profile1 = profile_manager->GetProfile(
 699       dest_path.Append(FILE_PATH_LITERAL("New Profile 1")));
 700   ASSERT_TRUE(profile1);
 701
 702   Profile* profile2 = profile_manager->GetProfile(
 703       dest_path.Append(FILE_PATH_LITERAL("New Profile 2")));
 704   ASSERT_TRUE(profile2);
 705
 706   // Simulate a launch after a browser update.
 707   CommandLine dummy(CommandLine::NO_PROGRAM);
 708   int return_code;
 709   StartupBrowserCreator browser_creator;
 710   std::vector<Profile*> last_opened_profiles;
 711   last_opened_profiles.push_back(profile1);
 712   last_opened_profiles.push_back(profile2);
 713   browser_creator.Start(dummy, profile_manager->user_data_dir(), profile1,
 714                         last_opened_profiles, &return_code);
 715
 716   while (SessionRestore::IsRestoring(profile1) ||
 717          SessionRestore::IsRestoring(profile2))
 718     base::MessageLoop::current()->RunUntilIdle();
 719
 720   // The startup URLs are ignored, and instead the last open sessions are
 721   // restored.
 722   EXPECT_TRUE(profile1->restored_last_session());
 723   EXPECT_TRUE(profile2->restored_last_session());
 724
 725   Browser* new_browser = NULL;
 726   ASSERT_EQ(1u, chrome::GetBrowserCount(profile1,
 727                                         browser()->host_desktop_type()));
 728   new_browser = FindOneOtherBrowserForProfile(profile1, NULL);
 729   ASSERT_TRUE(new_browser);
 730   TabStripModel* tab_strip = new_browser->tab_strip_model();
 731   ASSERT_EQ(1, tab_strip->count());
 732   EXPECT_EQ(GURL(content::kAboutBlankURL),
 733             tab_strip->GetWebContentsAt(0)->GetURL());
 734
 735   ASSERT_EQ(1u, chrome::GetBrowserCount(profile2,
 736                                         browser()->host_desktop_type()));
 737   new_browser = FindOneOtherBrowserForProfile(profile2, NULL);
 738   ASSERT_TRUE(new_browser);
 739   tab_strip = new_browser->tab_strip_model();
 740   ASSERT_EQ(1, tab_strip->count());
 741   EXPECT_EQ(GURL(content::kAboutBlankURL),
 742             tab_strip->GetWebContentsAt(0)->GetURL());
 743 }
 744
 745 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
 746                        ProfilesWithoutPagesNotLaunched) {
 747 #if defined(OS_WIN) && defined(USE_ASH)
 748   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 749   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 750     return;
 751 #endif
 752
 753   Profile* default_profile = browser()->profile();
 754
 755   ProfileManager* profile_manager = g_browser_process->profile_manager();
 756
 757   // Create 4 more profiles.
 758   base::FilePath dest_path1 = profile_manager->user_data_dir().Append(
 759       FILE_PATH_LITERAL("New Profile 1"));
 760   base::FilePath dest_path2 = profile_manager->user_data_dir().Append(
 761       FILE_PATH_LITERAL("New Profile 2"));
 762   base::FilePath dest_path3 = profile_manager->user_data_dir().Append(
 763       FILE_PATH_LITERAL("New Profile 3"));
 764   base::FilePath dest_path4 = profile_manager->user_data_dir().Append(
 765       FILE_PATH_LITERAL("New Profile 4"));
 766
 767   Profile* profile_home1 = profile_manager->GetProfile(dest_path1);
 768   ASSERT_TRUE(profile_home1);
 769   Profile* profile_home2 = profile_manager->GetProfile(dest_path2);
 770   ASSERT_TRUE(profile_home2);
 771   Profile* profile_last = profile_manager->GetProfile(dest_path3);
 772   ASSERT_TRUE(profile_last);
 773   Profile* profile_urls = profile_manager->GetProfile(dest_path4);
 774   ASSERT_TRUE(profile_urls);
 775
 776   // Set the profiles to open urls, open last visited pages or display the home
 777   // page.
 778   SessionStartupPref pref_home(SessionStartupPref::DEFAULT);
 779   SessionStartupPref::SetStartupPref(profile_home1, pref_home);
 780   SessionStartupPref::SetStartupPref(profile_home2, pref_home);
 781
 782   SessionStartupPref pref_last(SessionStartupPref::LAST);
 783   SessionStartupPref::SetStartupPref(profile_last, pref_last);
 784
 785   std::vector<GURL> urls;
 786   urls.push_back(ui_test_utils::GetTestUrl(
 787       base::FilePath(base::FilePath::kCurrentDirectory),
 788       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 789
 790   SessionStartupPref pref_urls(SessionStartupPref::URLS);
 791   pref_urls.urls = urls;
 792   SessionStartupPref::SetStartupPref(profile_urls, pref_urls);
 793
 794   // Close the browser.
 795   chrome::HostDesktopType original_desktop_type =
 796       browser()->host_desktop_type();
 797   browser()->window()->Close();
 798
 799   // Do a simple non-process-startup browser launch.
 800   CommandLine dummy(CommandLine::NO_PROGRAM);
 801
 802   int return_code;
 803   StartupBrowserCreator browser_creator;
 804   std::vector<Profile*> last_opened_profiles;
 805   last_opened_profiles.push_back(profile_home1);
 806   last_opened_profiles.push_back(profile_home2);
 807   last_opened_profiles.push_back(profile_last);
 808   last_opened_profiles.push_back(profile_urls);
 809   browser_creator.Start(dummy, profile_manager->user_data_dir(), profile_home1,
 810                         last_opened_profiles, &return_code);
 811
 812   while (SessionRestore::IsRestoring(default_profile) ||
 813          SessionRestore::IsRestoring(profile_home1) ||
 814          SessionRestore::IsRestoring(profile_home2) ||
 815          SessionRestore::IsRestoring(profile_last) ||
 816          SessionRestore::IsRestoring(profile_urls))
 817     base::MessageLoop::current()->RunUntilIdle();
 818
 819   Browser* new_browser = NULL;
 820   // The last open profile (the profile_home1 in this case) will always be
 821   // launched, even if it will open just the home page.
 822   ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home1, original_desktop_type));
 823   new_browser = FindOneOtherBrowserForProfile(profile_home1, NULL);
 824   ASSERT_TRUE(new_browser);
 825   TabStripModel* tab_strip = new_browser->tab_strip_model();
 826   ASSERT_EQ(1, tab_strip->count());
 827   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
 828             tab_strip->GetWebContentsAt(0)->GetURL());
 829
 830   // profile_urls opened the urls.
 831   ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls, original_desktop_type));
 832   new_browser = FindOneOtherBrowserForProfile(profile_urls, NULL);
 833   ASSERT_TRUE(new_browser);
 834   tab_strip = new_browser->tab_strip_model();
 835   ASSERT_EQ(1, tab_strip->count());
 836   EXPECT_EQ(urls[0], tab_strip->GetWebContentsAt(0)->GetURL());
 837
 838   // profile_last opened the last open pages.
 839   ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last, original_desktop_type));
 840   new_browser = FindOneOtherBrowserForProfile(profile_last, NULL);
 841   ASSERT_TRUE(new_browser);
 842   tab_strip = new_browser->tab_strip_model();
 843   ASSERT_EQ(1, tab_strip->count());
 844   EXPECT_EQ(GURL(content::kAboutBlankURL),
 845             tab_strip->GetWebContentsAt(0)->GetURL());
 846
 847   // profile_home2 was not launched since it would've only opened the home page.
 848   ASSERT_EQ(0u, chrome::GetBrowserCount(profile_home2, original_desktop_type));
 849 }
 850
 851 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, ProfilesLaunchedAfterCrash) {
 852 #if defined(OS_WIN) && defined(USE_ASH)
 853   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 854   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 855     return;
 856 #endif
 857
 858   // After an unclean exit, all profiles will be launched. However, they won't
 859   // open any pages automatically.
 860
 861   ProfileManager* profile_manager = g_browser_process->profile_manager();
 862
 863   // Create 3 profiles.
 864   base::FilePath dest_path1 = profile_manager->user_data_dir().Append(
 865       FILE_PATH_LITERAL("New Profile 1"));
 866   base::FilePath dest_path2 = profile_manager->user_data_dir().Append(
 867       FILE_PATH_LITERAL("New Profile 2"));
 868   base::FilePath dest_path3 = profile_manager->user_data_dir().Append(
 869       FILE_PATH_LITERAL("New Profile 3"));
 870
 871   Profile* profile_home = profile_manager->GetProfile(dest_path1);
 872   ASSERT_TRUE(profile_home);
 873   Profile* profile_last = profile_manager->GetProfile(dest_path2);
 874   ASSERT_TRUE(profile_last);
 875   Profile* profile_urls = profile_manager->GetProfile(dest_path3);
 876   ASSERT_TRUE(profile_urls);
 877
 878   // Set the profiles to open the home page, last visited pages or URLs.
 879   SessionStartupPref pref_home(SessionStartupPref::DEFAULT);
 880   SessionStartupPref::SetStartupPref(profile_home, pref_home);
 881
 882   SessionStartupPref pref_last(SessionStartupPref::LAST);
 883   SessionStartupPref::SetStartupPref(profile_last, pref_last);
 884
 885   std::vector<GURL> urls;
 886   urls.push_back(ui_test_utils::GetTestUrl(
 887       base::FilePath(base::FilePath::kCurrentDirectory),
 888       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 889
 890   SessionStartupPref pref_urls(SessionStartupPref::URLS);
 891   pref_urls.urls = urls;
 892   SessionStartupPref::SetStartupPref(profile_urls, pref_urls);
 893
 894   // Simulate a launch after an unclear exit.
 895   browser()->window()->Close();
 896   static_cast<ProfileImpl*>(profile_home)->last_session_exit_type_ =
 897       Profile::EXIT_CRASHED;
 898   static_cast<ProfileImpl*>(profile_last)->last_session_exit_type_ =
 899       Profile::EXIT_CRASHED;
 900   static_cast<ProfileImpl*>(profile_urls)->last_session_exit_type_ =
 901       Profile::EXIT_CRASHED;
 902
 903   CommandLine dummy(CommandLine::NO_PROGRAM);
 904   dummy.AppendSwitchASCII(switches::kTestType, "browser");
 905   int return_code;
 906   StartupBrowserCreator browser_creator;
 907   std::vector<Profile*> last_opened_profiles;
 908   last_opened_profiles.push_back(profile_home);
 909   last_opened_profiles.push_back(profile_last);
 910   last_opened_profiles.push_back(profile_urls);
 911   browser_creator.Start(dummy, profile_manager->user_data_dir(), profile_home,
 912                         last_opened_profiles, &return_code);
 913
 914   // No profiles are getting restored, since they all display the crash info
 915   // bar.
 916   EXPECT_FALSE(SessionRestore::IsRestoring(profile_home));
 917   EXPECT_FALSE(SessionRestore::IsRestoring(profile_last));
 918   EXPECT_FALSE(SessionRestore::IsRestoring(profile_urls));
 919
 920   // The profile which normally opens the home page displays the new tab page.
 921   Browser* new_browser = NULL;
 922   ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home,
 923                                         browser()->host_desktop_type()));
 924   new_browser = FindOneOtherBrowserForProfile(profile_home, NULL);
 925   ASSERT_TRUE(new_browser);
 926   TabStripModel* tab_strip = new_browser->tab_strip_model();
 927   ASSERT_EQ(1, tab_strip->count());
 928   content::WebContents* web_contents = tab_strip->GetWebContentsAt(0);
 929   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
 930   EXPECT_EQ(1U,
 931             InfoBarService::FromWebContents(web_contents)->infobar_count());
 932
 933   // The profile which normally opens last open pages displays the new tab page.
 934   ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last,
 935                                         browser()->host_desktop_type()));
 936   new_browser = FindOneOtherBrowserForProfile(profile_last, NULL);
 937   ASSERT_TRUE(new_browser);
 938   tab_strip = new_browser->tab_strip_model();
 939   ASSERT_EQ(1, tab_strip->count());
 940   web_contents = tab_strip->GetWebContentsAt(0);
 941   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
 942   EXPECT_EQ(1U,
 943             InfoBarService::FromWebContents(web_contents)->infobar_count());
 944
 945   // The profile which normally opens URLs displays the new tab page.
 946   ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls,
 947                                         browser()->host_desktop_type()));
 948   new_browser = FindOneOtherBrowserForProfile(profile_urls, NULL);
 949   ASSERT_TRUE(new_browser);
 950   tab_strip = new_browser->tab_strip_model();
 951   ASSERT_EQ(1, tab_strip->count());
 952   web_contents = tab_strip->GetWebContentsAt(0);
 953   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
 954   EXPECT_EQ(1U,
 955             InfoBarService::FromWebContents(web_contents)->infobar_count());
 956 }
 957
 958 class ManagedModeBrowserCreatorTest : public InProcessBrowserTest {
 959  protected:
 960   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 961     InProcessBrowserTest::SetUpCommandLine(command_line);
 962     command_line->AppendSwitch(switches::kEnableManagedUsers);
 963   }
 964 };
 965
 966 IN_PROC_BROWSER_TEST_F(ManagedModeBrowserCreatorTest,
 967                        StartupManagedModeProfile) {
 968   // Make this a managed profile.
 969   ManagedUserService* managed_user_service =
 970       ManagedUserServiceFactory::GetForProfile(browser()->profile());
 971   managed_user_service->InitForTesting();
 972
 973   StartupBrowserCreator browser_creator;
 974
 975   // Do a simple non-process-startup browser launch.
 976   CommandLine dummy(CommandLine::NO_PROGRAM);
 977   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
 978                                    chrome::startup::IS_FIRST_RUN);
 979   content::WindowedNotificationObserver observer(
 980       content::NOTIFICATION_LOAD_STOP,
 981       content::NotificationService::AllSources());
 982   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
 983                             browser()->host_desktop_type()));
 984
 985   // This should have created a new browser window.
 986   Browser* new_browser = FindOneOtherBrowser(browser());
 987   ASSERT_TRUE(new_browser);
 988
 989   TabStripModel* tab_strip = new_browser->tab_strip_model();
 990   // There should be only one tab.
 991   EXPECT_EQ(1, tab_strip->count());
 992 }
 993
 994 #endif  // !defined(OS_CHROMEOS)
 995
 996 // These tests are not applicable to Chrome OS as neither master_preferences nor
 997 // the sync promo exist there.
 998 #if !defined(OS_CHROMEOS)
 999
1000 // On a branded Linux build, policy is required to suppress the first-run
1001 // dialog.
1002 #if !defined(OS_LINUX) || !defined(GOOGLE_CHROME_BUILD) || \
1003     defined(ENABLE_CONFIGURATION_POLICY)
1004
1005 class StartupBrowserCreatorFirstRunTest : public InProcessBrowserTest {
1006  protected:
1007   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
1008   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
1009
1010 #if defined(ENABLE_CONFIGURATION_POLICY)
1011   policy::MockConfigurationPolicyProvider provider_;
1012   policy::PolicyMap policy_map_;
1013 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
1014 };
1015
1016 void StartupBrowserCreatorFirstRunTest::SetUpCommandLine(
1017     CommandLine* command_line) {
1018   command_line->AppendSwitch(switches::kForceFirstRun);
1019 }
1020
1021 void StartupBrowserCreatorFirstRunTest::SetUpInProcessBrowserTestFixture() {
1022 #if defined(ENABLE_CONFIGURATION_POLICY)
1023 #if defined(OS_LINUX) && defined(GOOGLE_CHROME_BUILD)
1024   // Set a policy that prevents the first-run dialog from being shown.
1025   policy_map_.Set(policy::key::kMetricsReportingEnabled,
1026                   policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
1027                   base::Value::CreateBooleanValue(false), NULL);
1028   provider_.UpdateChromePolicy(policy_map_);
1029 #endif  // defined(OS_LINUX) && defined(GOOGLE_CHROME_BUILD)
1030
1031   EXPECT_CALL(provider_, IsInitializationComplete(_))
1032       .WillRepeatedly(Return(true));
1033   EXPECT_CALL(provider_, RegisterPolicyDomain(_)).Times(AnyNumber());
1034   policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
1035 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
1036 }
1037
1038 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest, SyncPromoForbidden) {
1039   // Consistently enable the welcome page on all platforms.
1040   first_run::SetShouldShowWelcomePage();
1041
1042   // Simulate the following master_preferences:
1043   // {
1044   //  "sync_promo": {
1045   //    "show_on_first_run_allowed": false
1046   //  }
1047   // }
1048   StartupBrowserCreator browser_creator;
1049   browser()->profile()->GetPrefs()->SetBoolean(
1050       prefs::kSignInPromoShowOnFirstRunAllowed, false);
1051
1052   // Do a process-startup browser launch.
1053   CommandLine dummy(CommandLine::NO_PROGRAM);
1054   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1055                                    chrome::startup::IS_FIRST_RUN);
1056   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1057                             browser()->host_desktop_type()));
1058
1059   // This should have created a new browser window.
1060   Browser* new_browser = FindOneOtherBrowser(browser());
1061   ASSERT_TRUE(new_browser);
1062
1063   // Verify that the NTP and the welcome page are shown.
1064   TabStripModel* tab_strip = new_browser->tab_strip_model();
1065   ASSERT_EQ(2, tab_strip->count());
1066   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
1067             tab_strip->GetWebContentsAt(0)->GetURL());
1068   EXPECT_EQ(internals::GetWelcomePageURL(),
1069             tab_strip->GetWebContentsAt(1)->GetURL());
1070 }
1071
1072 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest, SyncPromoAllowed) {
1073   // Consistently enable the welcome page on all platforms.
1074   first_run::SetShouldShowWelcomePage();
1075
1076   // Simulate the following master_preferences:
1077   // {
1078   //  "sync_promo": {
1079   //    "show_on_first_run_allowed": true
1080   //  }
1081   // }
1082   StartupBrowserCreator browser_creator;
1083   browser()->profile()->GetPrefs()->SetBoolean(
1084       prefs::kSignInPromoShowOnFirstRunAllowed, true);
1085
1086   // Do a process-startup browser launch.
1087   CommandLine dummy(CommandLine::NO_PROGRAM);
1088   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1089                                    chrome::startup::IS_FIRST_RUN);
1090   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1091                             browser()->host_desktop_type()));
1092
1093   // This should have created a new browser window.
1094   Browser* new_browser = FindOneOtherBrowser(browser());
1095   ASSERT_TRUE(new_browser);
1096
1097   // Verify that the sync promo and the welcome page are shown.
1098   TabStripModel* tab_strip = new_browser->tab_strip_model();
1099   ASSERT_EQ(2, tab_strip->count());
1100   EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
1101             tab_strip->GetWebContentsAt(0)->GetURL());
1102   EXPECT_EQ(internals::GetWelcomePageURL(),
1103             tab_strip->GetWebContentsAt(1)->GetURL());
1104 }
1105
1106 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest,
1107                        FirstRunTabsPromoAllowed) {
1108   // Simulate the following master_preferences:
1109   // {
1110   //  "first_run_tabs" : [
1111   //    "files/title1.html"
1112   //  ],
1113   //  "sync_promo": {
1114   //    "show_on_first_run_allowed": true
1115   //  }
1116   // }
1117   StartupBrowserCreator browser_creator;
1118   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
1119   browser()->profile()->GetPrefs()->SetBoolean(
1120       prefs::kSignInPromoShowOnFirstRunAllowed, true);
1121
1122   // Do a process-startup browser launch.
1123   CommandLine dummy(CommandLine::NO_PROGRAM);
1124   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1125                                    chrome::startup::IS_FIRST_RUN);
1126   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1127                             browser()->host_desktop_type()));
1128
1129   // This should have created a new browser window.
1130   Browser* new_browser = FindOneOtherBrowser(browser());
1131   ASSERT_TRUE(new_browser);
1132
1133   // Verify that the first-run tab is shown and the sync promo has been added.
1134   TabStripModel* tab_strip = new_browser->tab_strip_model();
1135   ASSERT_EQ(2, tab_strip->count());
1136   EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
1137             tab_strip->GetWebContentsAt(0)->GetURL());
1138   EXPECT_EQ("title1.html",
1139             tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
1140 }
1141
1142 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest,
1143                        FirstRunTabsContainSyncPromo) {
1144   // Simulate the following master_preferences:
1145   // {
1146   //  "first_run_tabs" : [
1147   //    "files/title1.html",
1148   //    "chrome://signin/?source=0&next_page=chrome%3A%2F%2Fnewtab%2F"
1149   //  ],
1150   //  "sync_promo": {
1151   //    "show_on_first_run_allowed": true
1152   //  }
1153   // }
1154   StartupBrowserCreator browser_creator;
1155   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
1156   browser_creator.AddFirstRunTab(signin::GetPromoURL(signin::SOURCE_START_PAGE,
1157                                                      false));
1158   browser()->profile()->GetPrefs()->SetBoolean(
1159       prefs::kSignInPromoShowOnFirstRunAllowed, true);
1160
1161   // Do a process-startup browser launch.
1162   CommandLine dummy(CommandLine::NO_PROGRAM);
1163   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1164                                    chrome::startup::IS_FIRST_RUN);
1165   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1166                             browser()->host_desktop_type()));
1167
1168   // This should have created a new browser window.
1169   Browser* new_browser = FindOneOtherBrowser(browser());
1170   ASSERT_TRUE(new_browser);
1171
1172   // Verify that the first-run tabs are shown and no sync promo has been added
1173   // as the first-run tabs contain it already.
1174   TabStripModel* tab_strip = new_browser->tab_strip_model();
1175   ASSERT_EQ(2, tab_strip->count());
1176   EXPECT_EQ("title1.html",
1177             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
1178   EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
1179             tab_strip->GetWebContentsAt(1)->GetURL());
1180 }
1181
1182 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest,
1183                        FirstRunTabsContainNTPSyncPromoAllowed) {
1184   // Simulate the following master_preferences:
1185   // {
1186   //  "first_run_tabs" : [
1187   //    "new_tab_page",
1188   //    "files/title1.html"
1189   //  ],
1190   //  "sync_promo": {
1191   //    "show_on_first_run_allowed": true
1192   //  }
1193   // }
1194   StartupBrowserCreator browser_creator;
1195   browser_creator.AddFirstRunTab(GURL("new_tab_page"));
1196   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
1197   browser()->profile()->GetPrefs()->SetBoolean(
1198       prefs::kSignInPromoShowOnFirstRunAllowed, true);
1199
1200   // Do a process-startup browser launch.
1201   CommandLine dummy(CommandLine::NO_PROGRAM);
1202   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1203                                    chrome::startup::IS_FIRST_RUN);
1204   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1205                             browser()->host_desktop_type()));
1206
1207   // This should have created a new browser window.
1208   Browser* new_browser = FindOneOtherBrowser(browser());
1209   ASSERT_TRUE(new_browser);
1210
1211   // Verify that the first-run tabs are shown but the NTP that they contain has
1212   // been replaced by the sync promo.
1213   TabStripModel* tab_strip = new_browser->tab_strip_model();
1214   ASSERT_EQ(2, tab_strip->count());
1215   EXPECT_EQ(signin::GetPromoURL(signin::SOURCE_START_PAGE, false),
1216             tab_strip->GetWebContentsAt(0)->GetURL());
1217   EXPECT_EQ("title1.html",
1218             tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
1219 }
1220
1221 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest,
1222                        FirstRunTabsContainNTPSyncPromoForbidden) {
1223   // Simulate the following master_preferences:
1224   // {
1225   //  "first_run_tabs" : [
1226   //    "new_tab_page",
1227   //    "files/title1.html"
1228   //  ],
1229   //  "sync_promo": {
1230   //    "show_on_first_run_allowed": false
1231   //  }
1232   // }
1233   StartupBrowserCreator browser_creator;
1234   browser_creator.AddFirstRunTab(GURL("new_tab_page"));
1235   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
1236   browser()->profile()->GetPrefs()->SetBoolean(
1237       prefs::kSignInPromoShowOnFirstRunAllowed, false);
1238
1239   // Do a process-startup browser launch.
1240   CommandLine dummy(CommandLine::NO_PROGRAM);
1241   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1242                                    chrome::startup::IS_FIRST_RUN);
1243   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1244                             browser()->host_desktop_type()));
1245
1246   // This should have created a new browser window.
1247   Browser* new_browser = FindOneOtherBrowser(browser());
1248   ASSERT_TRUE(new_browser);
1249
1250   // Verify that the first-run tabs are shown, the NTP that they contain has not
1251   // not been replaced by the sync promo and no sync promo has been added.
1252   TabStripModel* tab_strip = new_browser->tab_strip_model();
1253   ASSERT_EQ(2, tab_strip->count());
1254   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
1255             tab_strip->GetWebContentsAt(0)->GetURL());
1256   EXPECT_EQ("title1.html",
1257             tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
1258 }
1259
1260 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest,
1261                        FirstRunTabsSyncPromoForbidden) {
1262   // Simulate the following master_preferences:
1263   // {
1264   //  "first_run_tabs" : [
1265   //    "files/title1.html"
1266   //  ],
1267   //  "sync_promo": {
1268   //    "show_on_first_run_allowed": false
1269   //  }
1270   // }
1271   StartupBrowserCreator browser_creator;
1272   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
1273   browser()->profile()->GetPrefs()->SetBoolean(
1274       prefs::kSignInPromoShowOnFirstRunAllowed, false);
1275
1276   // Do a process-startup browser launch.
1277   CommandLine dummy(CommandLine::NO_PROGRAM);
1278   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1279                                    chrome::startup::IS_FIRST_RUN);
1280   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1281                             browser()->host_desktop_type()));
1282
1283   // This should have created a new browser window.
1284   Browser* new_browser = FindOneOtherBrowser(browser());
1285   ASSERT_TRUE(new_browser);
1286
1287   // Verify that the first-run tab is shown and no sync promo has been added.
1288   TabStripModel* tab_strip = new_browser->tab_strip_model();
1289   ASSERT_EQ(1, tab_strip->count());
1290   EXPECT_EQ("title1.html",
1291             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
1292 }
1293
1294 #if defined(ENABLE_CONFIGURATION_POLICY)
1295 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorFirstRunTest,
1296                        RestoreOnStartupURLsPolicySpecified) {
1297   // Simulate the following master_preferences:
1298   // {
1299   //  "sync_promo": {
1300   //    "show_on_first_run_allowed": true
1301   //  }
1302   // }
1303   StartupBrowserCreator browser_creator;
1304   browser()->profile()->GetPrefs()->SetBoolean(
1305       prefs::kSignInPromoShowOnFirstRunAllowed, true);
1306
1307   // Set the following user policies:
1308   // * RestoreOnStartup = RestoreOnStartupIsURLs
1309   // * RestoreOnStartupURLs = [ "files/title1.html" ]
1310   policy_map_.Set(policy::key::kRestoreOnStartup,
1311                   policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
1312                   base::Value::CreateIntegerValue(
1313                       SessionStartupPref::kPrefValueURLs),
1314                   NULL);
1315   base::ListValue startup_urls;
1316   startup_urls.Append(base::Value::CreateStringValue(
1317       test_server()->GetURL("files/title1.html").spec()));
1318   policy_map_.Set(policy::key::kRestoreOnStartupURLs,
1319                   policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
1320                   startup_urls.DeepCopy(), NULL);
1321   provider_.UpdateChromePolicy(policy_map_);
1322   base::RunLoop().RunUntilIdle();
1323
1324   // Do a process-startup browser launch.
1325   CommandLine dummy(CommandLine::NO_PROGRAM);
1326   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
1327                                    chrome::startup::IS_FIRST_RUN);
1328   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), true,
1329                             browser()->host_desktop_type()));
1330
1331   // This should have created a new browser window.
1332   Browser* new_browser = FindOneOtherBrowser(browser());
1333   ASSERT_TRUE(new_browser);
1334
1335   // Verify that the URL specified through policy is shown and no sync promo has
1336   // been added.
1337   TabStripModel* tab_strip = new_browser->tab_strip_model();
1338   ASSERT_EQ(1, tab_strip->count());
1339   EXPECT_EQ("title1.html",
1340             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
1341 }
1342 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
1343
1344 #endif  // !defined(OS_LINUX) || !defined(GOOGLE_CHROME_BUILD) ||
1345         // defined(ENABLE_CONFIGURATION_POLICY)
1346
1347 #endif  // !defined(OS_CHROMEOS)