src/chrome/browser/ui/browser_navigator_browsertest_chromeos.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 "chrome/browser/ui/browser_navigator_browsertest.h"
   6
   7 #include <string>
   8
   9 #include "base/command_line.h"
  10 #include "chrome/browser/chromeos/login/chrome_restart_request.h"
  11 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
  12 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/browser_finder.h"
  15 #include "chrome/browser/ui/browser_navigator.h"
  16 #include "chrome/browser/ui/browser_window.h"
  17 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  18 #include "chrome/common/chrome_switches.h"
  19 #include "chromeos/chromeos_switches.h"
  20 #include "content/public/browser/web_contents.h"
  21
  22 namespace {
  23
  24 // This is a test implementation of a MultiUserWindowManager which allows to
  25 // test a visiting window on another desktop. It will install and remove itself
  26 // from the system upon creation / destruction.
  27 // The creation function gets a |browser| which is shown on |desktop_owner|'s
  28 // desktop.
  29 class TestMultiUserWindowManager : public chrome::MultiUserWindowManager {
  30  public:
  31   TestMultiUserWindowManager(
  32       Browser* visiting_browser,
  33       const std::string& desktop_owner);
  34   virtual ~TestMultiUserWindowManager();
  35
  36   aura::Window* created_window() { return created_window_; }
  37
  38   // MultiUserWindowManager overrides:
  39   virtual void SetWindowOwner(
  40       aura::Window* window, const std::string& user_id) override;
  41   virtual const std::string& GetWindowOwner(
  42       aura::Window* window) const override;
  43   virtual void ShowWindowForUser(
  44       aura::Window* window, const std::string& user_id) override;
  45   virtual bool AreWindowsSharedAmongUsers() const override;
  46   virtual void GetOwnersOfVisibleWindows(
  47       std::set<std::string>* user_ids) const override;
  48   virtual bool IsWindowOnDesktopOfUser(
  49       aura::Window* window,
  50       const std::string& user_id) const override;
  51   virtual const std::string& GetUserPresentingWindow(
  52       aura::Window* window) const override;
  53   virtual void AddUser(content::BrowserContext* profile) override;
  54   virtual void AddObserver(Observer* observer) override;
  55   virtual void RemoveObserver(Observer* observer) override;
  56
  57  private:
  58   // The window of the visiting browser.
  59   aura::Window* browser_window_;
  60   // The owner of the visiting browser.
  61   std::string browser_owner_;
  62   // The owner of the currently shown desktop.
  63   std::string desktop_owner_;
  64   // The created window.
  65   aura::Window* created_window_;
  66   // The location of the window.
  67   std::string created_window_shown_for_;
  68
  69   DISALLOW_COPY_AND_ASSIGN(TestMultiUserWindowManager);
  70 };
  71
  72 TestMultiUserWindowManager::TestMultiUserWindowManager(
  73     Browser* visiting_browser,
  74     const std::string& desktop_owner)
  75     : browser_window_(visiting_browser->window()->GetNativeWindow()),
  76       browser_owner_(multi_user_util::GetUserIDFromProfile(
  77           visiting_browser->profile())),
  78       desktop_owner_(desktop_owner),
  79       created_window_(NULL),
  80       created_window_shown_for_(browser_owner_) {
  81   // Create a window manager for a visiting user.
  82   chrome::MultiUserWindowManager::SetInstanceForTest(
  83       this,
  84       chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED);
  85 }
  86
  87 TestMultiUserWindowManager::~TestMultiUserWindowManager() {
  88   // This object is owned by the MultiUserWindowManager since the
  89   // SetInstanceForTest call. As such no uninstall is required.
  90 }
  91
  92 // MultiUserWindowManager overrides:
  93 void TestMultiUserWindowManager::SetWindowOwner(
  94     aura::Window* window, const std::string& user_id) {
  95   NOTREACHED();
  96 }
  97
  98 const std::string& TestMultiUserWindowManager::GetWindowOwner(
  99     aura::Window* window) const {
 100   // No matter which window will get queried - all browsers belong to the
 101   // original browser's user.
 102   return browser_owner_;
 103 }
 104
 105 void TestMultiUserWindowManager::ShowWindowForUser(
 106     aura::Window* window,
 107     const std::string& user_id) {
 108   // This class is only able to handle one additional window <-> user
 109   // association beside the creation parameters.
 110   // If no association has yet been requested remember it now.
 111   DCHECK(!created_window_);
 112   created_window_ = window;
 113   created_window_shown_for_ = user_id;
 114 }
 115
 116 bool TestMultiUserWindowManager::AreWindowsSharedAmongUsers() const {
 117   return browser_owner_ != desktop_owner_;
 118 }
 119
 120 void TestMultiUserWindowManager::GetOwnersOfVisibleWindows(
 121     std::set<std::string>* user_ids) const {
 122 }
 123
 124 bool TestMultiUserWindowManager::IsWindowOnDesktopOfUser(
 125     aura::Window* window,
 126     const std::string& user_id) const {
 127   return GetUserPresentingWindow(window) == user_id;
 128 }
 129
 130 const std::string& TestMultiUserWindowManager::GetUserPresentingWindow(
 131     aura::Window* window) const {
 132   if (window == browser_window_)
 133     return desktop_owner_;
 134   if (created_window_ && window == created_window_)
 135     return created_window_shown_for_;
 136   // We can come here before the window gets registered.
 137   return browser_owner_;
 138 }
 139
 140 void TestMultiUserWindowManager::AddUser(content::BrowserContext* profile) {
 141 }
 142
 143 void TestMultiUserWindowManager::AddObserver(Observer* observer) {
 144 }
 145
 146 void TestMultiUserWindowManager::RemoveObserver(Observer* observer) {
 147 }
 148
 149 GURL GetGoogleURL() {
 150   return GURL("http://www.google.com/");
 151 }
 152
 153 // Subclass that tests navigation while in the Guest session.
 154 class BrowserGuestSessionNavigatorTest: public BrowserNavigatorTest {
 155  protected:
 156   virtual void SetUpCommandLine(CommandLine* command_line) override {
 157     CommandLine command_line_copy = *command_line;
 158     command_line_copy.AppendSwitchASCII(
 159         chromeos::switches::kLoginProfile, "user");
 160     chromeos::GetOffTheRecordCommandLine(GetGoogleURL(),
 161                                          true,
 162                                          command_line_copy,
 163                                          command_line);
 164   }
 165 };
 166
 167 // This test verifies that the settings page is opened in the incognito window
 168 // in Guest Session (as well as all other windows in Guest session).
 169 IN_PROC_BROWSER_TEST_F(BrowserGuestSessionNavigatorTest,
 170                        Disposition_Settings_UseIncognitoWindow) {
 171   Browser* incognito_browser = CreateIncognitoBrowser();
 172
 173   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 174   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 175   EXPECT_EQ(1, incognito_browser->tab_strip_model()->count());
 176
 177   // Navigate to the settings page.
 178   chrome::NavigateParams params(MakeNavigateParams(incognito_browser));
 179   params.disposition = SINGLETON_TAB;
 180   params.url = GURL("chrome://chrome/settings");
 181   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
 182   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 183   chrome::Navigate(&params);
 184
 185   // Settings page should be opened in incognito window.
 186   EXPECT_NE(browser(), params.browser);
 187   EXPECT_EQ(incognito_browser, params.browser);
 188   EXPECT_EQ(2, incognito_browser->tab_strip_model()->count());
 189   EXPECT_EQ(GURL("chrome://chrome/settings"),
 190             incognito_browser->tab_strip_model()->GetActiveWebContents()->
 191                 GetURL());
 192 }
 193
 194 // Test that in multi user environments a newly created browser gets created
 195 // on the same desktop as the browser is shown on.
 196 IN_PROC_BROWSER_TEST_F(BrowserGuestSessionNavigatorTest,
 197                        Browser_Gets_Created_On_Visiting_Desktop) {
 198   // Test 1: Test that a browser created from a visiting browser will be on the
 199   // same visiting desktop.
 200   {
 201     const std::string desktop_user_id = "desktop_user_id@fake.com";
 202     TestMultiUserWindowManager* manager =
 203         new TestMultiUserWindowManager(browser(), desktop_user_id);
 204
 205     EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 206
 207     // Navigate to the settings page.
 208     chrome::NavigateParams params(MakeNavigateParams(browser()));
 209     params.disposition = NEW_POPUP;
 210     params.url = GURL("chrome://chrome/settings");
 211     params.window_action = chrome::NavigateParams::SHOW_WINDOW;
 212     params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 213     params.browser = browser();
 214     chrome::Navigate(&params);
 215
 216     EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 217
 218     aura::Window* created_window = manager->created_window();
 219     ASSERT_TRUE(created_window);
 220     EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(created_window,
 221                                                  desktop_user_id));
 222   }
 223   // Test 2: Test that a window which is not visiting does not cause an owner
 224   // assignment of a newly created browser.
 225   {
 226     std::string browser_owner =
 227         multi_user_util::GetUserIDFromProfile(browser()->profile());
 228     TestMultiUserWindowManager* manager =
 229         new TestMultiUserWindowManager(browser(), browser_owner);
 230
 231     // Navigate to the settings page.
 232     chrome::NavigateParams params(MakeNavigateParams(browser()));
 233     params.disposition = NEW_POPUP;
 234     params.url = GURL("chrome://chrome/settings");
 235     params.window_action = chrome::NavigateParams::SHOW_WINDOW;
 236     params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 237     params.browser = browser();
 238     chrome::Navigate(&params);
 239
 240     EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
 241
 242     // The ShowWindowForUser should not have been called since the window is
 243     // already on the correct desktop.
 244     ASSERT_FALSE(manager->created_window());
 245   }
 246 }
 247
 248 }  // namespace