Home | History | Annotate | Download | only in startup 
      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)
   1348