Show only the settings pages for new managed users

chrome/browser/ui/startup/startup_browser_creator_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 19 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/web_contents.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::Extension;
 
+namespace {
+
+// Check that there are two browsers. Find the one that is not |browser|.
+void FindOneOtherBrowser(Browser* browser, Browser** out_other_browser) {

[Bernhard Bauer, 2013/04/03 17:55:20]

Could you simply return the other browser here?

[Sergiu, 2013/04/04 09:02:55]

Well, there is a comment below that says:
  // Helper functions return void so that we can ASSERT*().
  // Use ASSERT_NO_FATAL_FAILURE around calls to these functions to stop the
  // test if an assert fails.

I guess it is related to the way assert stops execution that requires void
functions. I also guess I could return NULL when something is wrong and assert
that if you think that is better.

[Bernhard Bauer, 2013/04/04 09:08:40]

Well, yeah, an ASSERT expands to something that returns on failure, so you can
only use it in a void method. OTOH, one of the ASSERTs isn't necessary, and the
other one you can just as well do in the caller (instead of the
ASSERT_NO_FATAL_FAILURE). The one in line 45 can be made an EXPECT (nothing
breaks if you continue).

+  // There should only be one other browser.
+  ASSERT_EQ(2u, chrome::GetBrowserCount(browser->profile(),
+                                        browser->host_desktop_type()));
+
+  // Find the new browser.
+  Browser* other_browser = NULL;
+  for (chrome::BrowserIterator it; !it.done() && !other_browser; it.Next()) {
+    if (*it != browser)
+      other_browser = *it;
+  }
+  ASSERT_TRUE(other_browser);
+  ASSERT_TRUE(other_browser != browser);

[Bernhard Bauer, 2013/04/03 17:55:20]

This check isn't really necessary (that's the exact condition we test above).

[Sergiu, 2013/04/04 09:02:55]

Done.

+  *out_other_browser = other_browser;
+}
+
+}  // namespace
+
 class StartupBrowserCreatorTest : public ExtensionBrowserTest {
  protected:
   virtual bool SetUpUserDataDirectory() OVERRIDE {
     // Make sure the first run sentinel file exists before running these tests,
     // since some of them customize the session startup pref whose value can
     // be different than the default during the first run.
     // TODO(bauerb): set the first run flag instead of creating a sentinel file.
     first_run::CreateSentinel();
     return ExtensionBrowserTest::SetUpUserDataDirectory();
   }
@@ skipping 27 matching lines @@
                                           browser()->host_desktop_type()));
   }
 
   void SetAppLaunchPref(const std::string& app_id,
                         extensions::ExtensionPrefs::LaunchType launch_type) {
     ExtensionService* service = extensions::ExtensionSystem::Get(
         browser()->profile())->extension_service();
     service->extension_prefs()->SetLaunchType(app_id, launch_type);
   }
 
-  // Check that there are two browsers.  Find the one that is not |browser()|.
-  void FindOneOtherBrowser(Browser** out_other_browser) {
-    // There should only be one other browser.
-    ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
-                                          browser()->host_desktop_type()));
-
-    // Find the new browser.
-    Browser* other_browser = NULL;
-  for (chrome::BrowserIterator it; !it.done() && !other_browser; it.Next()) {
-      if (*it != browser())
-        other_browser = *it;
-    }
-    ASSERT_TRUE(other_browser);
-    ASSERT_TRUE(other_browser != browser());
-    *out_other_browser = other_browser;
-  }
-
   Browser* FindOneOtherBrowserForProfile(Profile* profile,
                                          Browser* not_this_browser) {
     for (chrome::BrowserIterator it; !it.done(); it.Next()) {
       if (*it != not_this_browser && it->profile() == profile)
         return *it;
     }
     return NULL;
   }
 };
 
@@ skipping 68 matching lines @@
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.  |browser()| is still
   // around at this point, even though we've closed its window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   // The new browser should have one tab for each URL.
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(static_cast<int>(urls.size()), tab_strip->count());
   for (size_t i=0; i < urls.size(); i++) {
     EXPECT_EQ(urls[i], tab_strip->GetWebContentsAt(i)->GetURL());
   }
 
   // The two tabs, despite having the same site, should be in different
   // SiteInstances.
@@ skipping 22 matching lines @@
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   // The new browser should have exactly one tab (not the startup URLs).
   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 }
 
 // App shortcuts are not implemented on mac os.
 #if !defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, OpenAppShortcutNoPref) {
   // Load an app with launch.container = 'tab'.
   const Extension* extension_app = NULL;
   ASSERT_NO_FATAL_FAILURE(LoadApp("app_with_tab_container", &extension_app));
 
   // Add --app-id=<extension->id()> to the command line.
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kAppId, extension_app->id());
 
   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // No pref was set, so the app should have opened in a window.
   // The launch should have created a new browser.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   // Expect an app window.
   EXPECT_TRUE(new_browser->is_app());
 
   // The browser's app_name should include the app's ID.
   EXPECT_NE(
       new_browser->app_name_.find(extension_app->id()),
       std::string::npos) << new_browser->app_name_;
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, OpenAppShortcutWindowPref) {
   const Extension* extension_app = NULL;
   ASSERT_NO_FATAL_FAILURE(LoadApp("app_with_tab_container", &extension_app));
 
   // Set a pref indicating that the user wants to open this app in a window.
   SetAppLaunchPref(extension_app->id(),
                    extensions::ExtensionPrefs::LAUNCH_WINDOW);
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kAppId, extension_app->id());
   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // Pref was set to open in a window, so the app should have opened in a
   // window.  The launch should have created a new browser. Find the new
   // browser.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   // Expect an app window.
   EXPECT_TRUE(new_browser->is_app());
 
   // The browser's app_name should include the app's ID.
   EXPECT_NE(
       new_browser->app_name_.find(extension_app->id()),
       std::string::npos) << new_browser->app_name_;
 }
 
@@ skipping 12 matching lines @@
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // When an app shortcut is open and the pref indicates a tab should
   // open, the tab is open in a new browser window.  Expect a new window.
   ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
                                         browser()->host_desktop_type()));
 
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   // The tab should be in a tabbed window.
   EXPECT_TRUE(new_browser->is_type_tabbed());
 
   // The browser's app_name should not include the app's ID: It is in a
   // normal browser.
   EXPECT_EQ(
       new_browser->app_name_.find(extension_app->id()),
       std::string::npos) << new_browser->app_name_;
 }
@@ skipping 32 matching lines @@
   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title2.html"));
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
                                    chrome::startup::IS_FIRST_RUN);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   EXPECT_EQ(2, tab_strip->count());
 
   EXPECT_EQ("title1.html",
             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
   EXPECT_EQ("title2.html",
             tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
 }
 
 // Test hard-coded special first run tabs (defined in
 // StartupBrowserCreatorImpl::AddStartupURLs()).
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, AddCustomFirstRunTab) {
   StartupBrowserCreator browser_creator;
   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title1.html"));
   browser_creator.AddFirstRunTab(GURL("http://new_tab_page"));
   browser_creator.AddFirstRunTab(test_server()->GetURL("files/title2.html"));
   browser_creator.AddFirstRunTab(GURL("http://welcome_page"));
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
                                    chrome::startup::IS_FIRST_RUN);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   EXPECT_EQ(4, tab_strip->count());
 
   EXPECT_EQ("title1.html",
             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
             tab_strip->GetWebContentsAt(1)->GetURL());
   EXPECT_EQ("title2.html",
             tab_strip->GetWebContentsAt(2)->GetURL().ExtractFileName());
   EXPECT_EQ(internals::GetWelcomePageURL(),
             tab_strip->GetWebContentsAt(3)->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, SyncPromoNoWelcomePage) {
   // Trick this test into thinking the promo has been shown for this profile; so
   // that it will show it again (otherwise it skips showing it since
   // --no-first-run is specified in browser tests).
   SyncPromoUI::DidShowSyncPromoAtStartup(browser()->profile());
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy,
                                    chrome::startup::IS_FIRST_RUN);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   EXPECT_EQ(1, tab_strip->count());
 
   if (SyncPromoUI::ShouldShowSyncPromoAtStartup(browser()->profile(), true)) {
     EXPECT_EQ("signin", tab_strip->GetWebContentsAt(0)->GetURL().host());
   } else {
     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
               tab_strip->GetWebContentsAt(0)->GetURL());
   }
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, SyncPromoWithWelcomePage) {
   // Trick this test into thinking the promo has been shown for this profile; so
   // that it will show it again (otherwise it skips showing it since
   // --no-first-run is specified in browser tests).
   SyncPromoUI::DidShowSyncPromoAtStartup(browser()->profile());
   first_run::SetShouldShowWelcomePage();
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy,
                                    chrome::startup::IS_FIRST_RUN);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   EXPECT_EQ(2, tab_strip->count());
 
   if (SyncPromoUI::ShouldShowSyncPromoAtStartup(browser()->profile(), true)) {
     EXPECT_EQ("signin", tab_strip->GetWebContentsAt(0)->GetURL().host());
   } else {
     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
               tab_strip->GetWebContentsAt(0)->GetURL());
   }
@@ skipping 16 matching lines @@
   first_run::SetShouldShowWelcomePage();
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
                                    chrome::startup::IS_FIRST_RUN);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   if (SyncPromoUI::ShouldShowSyncPromoAtStartup(browser()->profile(), true)) {
     EXPECT_EQ(2, tab_strip->count());
     EXPECT_EQ("signin", tab_strip->GetWebContentsAt(0)->GetURL().host());
     EXPECT_EQ("title1.html",
               tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
   } else {
     EXPECT_EQ(1, tab_strip->count());
     EXPECT_EQ("title1.html",
@@ skipping 15 matching lines @@
   SyncPromoUI::DidShowSyncPromoAtStartup(browser()->profile());
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
                                    chrome::startup::IS_FIRST_RUN);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
 
   // This should have created a new browser window.
   Browser* new_browser = NULL;
-  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&new_browser));
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
 
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   if (SyncPromoUI::ShouldShowSyncPromoAtStartup(browser()->profile(), true)) {
     EXPECT_EQ(3, tab_strip->count());
     EXPECT_EQ("signin", tab_strip->GetWebContentsAt(0)->GetURL().host());
     EXPECT_EQ("title1.html",
               tab_strip->GetWebContentsAt(1)->GetURL().ExtractFileName());
     EXPECT_EQ(internals::GetWelcomePageURL(),
               tab_strip->GetWebContentsAt(2)->GetURL());
   } else {
@@ skipping 340 matching lines @@
                                         browser()->host_desktop_type()));
   new_browser = FindOneOtherBrowserForProfile(profile_urls, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   web_contents = tab_strip->GetWebContentsAt(0);
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
   EXPECT_EQ(1U,
             InfoBarService::FromWebContents(web_contents)->GetInfoBarCount());
 }
+
+class ManagedModeBrowserCreatorTest : public InProcessBrowserTest {
+ protected:
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    InProcessBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(switches::kEnableManagedUsers);
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(ManagedModeBrowserCreatorTest,
+                       StartupManagedModeProfile) {
+  // Make this a managed profile.
+  browser()->profile()->GetPrefs()->SetBoolean(prefs::kProfileIsManaged, true);
+  StartupBrowserCreator browser_creator;
+
+  // Do a simple non-process-startup browser launch.
+  CommandLine dummy(CommandLine::NO_PROGRAM);
+  StartupBrowserCreatorImpl launch(base::FilePath(), dummy, &browser_creator,
+                                   chrome::startup::IS_FIRST_RUN);
+  ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false));
+
+  // This should have created a new browser window.
+  Browser* new_browser = NULL;
+  ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(browser(), &new_browser));
+
+  TabStripModel* tab_strip = new_browser->tab_strip_model();
+  // There should be only one tab.
+  EXPECT_EQ(1, tab_strip->count());
+
+  // And it should point to the managed user settings page.
+  content::WebContents* web_contents = tab_strip->GetWebContentsAt(0);
+  GURL expected(GURL(std::string(chrome::kChromeUISettingsURL) +
+                     chrome::kManagedUserSettingsSubPage));
+  EXPECT_EQ(GURL(expected), web_contents->GetURL());
+}

[Bernhard Bauer, 2013/04/03 17:55:20]

Nit: a newline after this line would be nice.

[Sergiu, 2013/04/04 09:02:55]

Done.

 #endif  // !OS_CHROMEOS