Enable immersive fullscreen for hosted apps part 2

chrome/browser/ui/ash/accelerator_commands_browsertest.cc

 // Copyright 2013 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 "ash/accelerators/accelerator_commands.h"
 
 #include "apps/shell_window.h"
 #include "apps/ui/native_app_window.h"
+#include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/wm/window_state.h"
 #include "base/command_line.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "ui/aura/client/aura_constants.h"
 
 namespace {
 
 // Returns true if |window| is in immersive fullscreen. Infer whether |window|
 // is in immersive fullscreen based on whether the shelf is hidden when
-// |window| is fullscreen because DEPS does not allow the test to use
-// BrowserView. (This is not quite right because the shelf is hidden if a window
-// is in both immersive fullscreen and tab fullscreen.)
-bool IsInImmersiveFullscreen(BrowserWindow* browser_window) {
-  ash::wm::WindowState* window_state = ash::wm::GetWindowState(
-      browser_window->GetNativeWindow());
+// |window| is fullscreen. (This is not quite right because the shelf is hidden
+// if a window is in both immersive fullscreen and tab fullscreen.)
+bool IsInImmersiveFullscreen(aura::Window* window) {
+  ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
   return window_state->IsFullscreen() &&
       !window_state->hide_shelf_when_fullscreen();
 }
 
 }  // namespace
 
 typedef InProcessBrowserTest AcceleratorCommandsBrowserTest;
 
 // Confirm that toggling window miximized works properly
 IN_PROC_BROWSER_TEST_F(AcceleratorCommandsBrowserTest, ToggleMaximized) {
@@ skipping 17 matching lines @@
   ash::accelerators::ToggleMaximized();
   EXPECT_FALSE(window_state->IsFullscreen());
   EXPECT_FALSE(window_state->IsMaximized());
   ash::accelerators::ToggleMaximized();
   EXPECT_FALSE(window_state->IsFullscreen());
   EXPECT_TRUE(window_state->IsMaximized());
 }
 
 // Confirm that toggling window fullscren works properly.
 IN_PROC_BROWSER_TEST_F(AcceleratorCommandsBrowserTest, ToggleFullscreen) {
+  bool put_all_windows_in_immersive = CommandLine::ForCurrentProcess()->
+      HasSwitch(ash::switches::kAshEnableImmersiveFullscreenForAllWindows);
+
   ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
-  // 1) ToggleFullscreen() should toggle whether a tabbed browser window is in
-  // immersive fullscreen.
+  // 1) ToggleFullscreen() should always toggle whether a tabbed browser window
+  // is in immersive fullscreen.
   ASSERT_TRUE(browser()->is_type_tabbed());
   BrowserWindow* browser_window = browser()->window();
   ASSERT_TRUE(browser_window->IsActive());
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 
   ash::accelerators::ToggleFullscreen();
   EXPECT_TRUE(browser_window->IsFullscreen());
-  EXPECT_TRUE(IsInImmersiveFullscreen(browser_window));
+  EXPECT_TRUE(IsInImmersiveFullscreen(browser_window->GetNativeWindow()));
 
   ash::accelerators::ToggleFullscreen();
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 
   // 2) ToggleFullscreen() should have no effect on windows which cannot be
   // maximized.
   browser_window->GetNativeWindow()->SetProperty(aura::client::kCanMaximizeKey,
                                                  false);
   ash::accelerators::ToggleFullscreen();
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 
-  // 3) ToggleFullscreen() should put v1 apps into non-immersive fullscreen.
+  // 3) ToggleFullscreen() should put v1 apps into immersive fullscreen only if
+  // the kAshEnableImmersiveFullscreenForAllWindows command line flag is set.
   Browser::CreateParams browser_create_params(Browser::TYPE_POPUP,
       browser()->profile(), chrome::HOST_DESKTOP_TYPE_NATIVE);
 #if defined(OS_WIN)
   browser_create_params.host_desktop_type = chrome::HOST_DESKTOP_TYPE_ASH;
 #endif  // OS_WIN
   browser_create_params.app_name = "Test";
 
   Browser* app_host_browser = new Browser(browser_create_params);
   ASSERT_TRUE(app_host_browser->is_app());
   AddBlankTabAndShow(app_host_browser);
   browser_window = app_host_browser->window();
   ASSERT_TRUE(browser_window->IsActive());
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 
   ash::accelerators::ToggleFullscreen();
   EXPECT_TRUE(browser_window->IsFullscreen());
-  EXPECT_FALSE(IsInImmersiveFullscreen(browser_window));
+  EXPECT_EQ(put_all_windows_in_immersive,
+            IsInImmersiveFullscreen(browser_window->GetNativeWindow()));
 
   ash::accelerators::ToggleFullscreen();
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 
-  // 4) ToggleFullscreen() should put popup browser windows into non-immersive
-  // fullscreen.
+  // 4) ToggleFullscreen() should put popup browser windows into immersive
+  // fullscreen only if the kAshEnableImmersiveFullscreenForAllWindows command
+  // line flag is set.
   browser_create_params.app_name = "";
   Browser* popup_browser = new Browser(browser_create_params);
   ASSERT_TRUE(popup_browser->is_type_popup());
   ASSERT_FALSE(popup_browser->is_app());
   AddBlankTabAndShow(popup_browser);
   browser_window = popup_browser->window();
   ASSERT_TRUE(browser_window->IsActive());
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 
   ash::accelerators::ToggleFullscreen();
   EXPECT_TRUE(browser_window->IsFullscreen());
-  EXPECT_FALSE(IsInImmersiveFullscreen(browser_window));
+  EXPECT_EQ(put_all_windows_in_immersive,
+            IsInImmersiveFullscreen(browser_window->GetNativeWindow()));
 
   ash::accelerators::ToggleFullscreen();
-  EXPECT_FALSE(browser_window->IsMaximized());
   EXPECT_FALSE(browser_window->IsFullscreen());
 }
 
 typedef extensions::PlatformAppBrowserTest
     AcceleratorCommandsPlatformAppBrowserTest;
 
-// Test that ToggleFullscreen() toggles the platform app's fullscreen state.
+// Test the behavior of platform apps when ToggleFullscreen() is called.
 IN_PROC_BROWSER_TEST_F(AcceleratorCommandsPlatformAppBrowserTest,
                        ToggleFullscreenPlatformApp) {
   ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
   const extensions::Extension* extension = LoadAndLaunchPlatformApp("minimal");
-  apps::ShellWindow* shell_window = CreateShellWindow(extension);
-  apps::NativeAppWindow* app_window = shell_window->GetBaseWindow();
-  ASSERT_TRUE(shell_window->GetBaseWindow()->IsActive());
-  EXPECT_FALSE(app_window->IsMaximized());
-  EXPECT_FALSE(app_window->IsFullscreen());
 
-  ash::accelerators::ToggleFullscreen();
-  EXPECT_TRUE(app_window->IsFullscreen());
+  {
+    // Test that ToggleFullscreen() toggles a platform's app's fullscreen
+    // state and that it additonally puts the app into immersive fullscreen
+    // if the kAshEnableImmersiveFullscreenForAllWindows command line flag
+    // is set.
+    bool put_all_windows_in_immersive = CommandLine::ForCurrentProcess()->
+        HasSwitch(ash::switches::kAshEnableImmersiveFullscreenForAllWindows);
+    apps::ShellWindow::CreateParams params;
+    params.frame = apps::ShellWindow::FRAME_CHROME;
+    apps::ShellWindow* shell_window = CreateShellWindowFromParams(
+        extension, params);
+    apps::NativeAppWindow* app_window = shell_window->GetBaseWindow();
+    ASSERT_TRUE(shell_window->GetBaseWindow()->IsActive());
+    EXPECT_FALSE(app_window->IsFullscreen());
 
-  ash::accelerators::ToggleFullscreen();
-  EXPECT_FALSE(app_window->IsMaximized());
-  EXPECT_FALSE(app_window->IsFullscreen());
+    ash::accelerators::ToggleFullscreen();
+    EXPECT_TRUE(app_window->IsFullscreen());
+    EXPECT_EQ(put_all_windows_in_immersive,
+              IsInImmersiveFullscreen(app_window->GetNativeWindow()));
 
-  CloseShellWindow(shell_window);
+    ash::accelerators::ToggleFullscreen();
+    EXPECT_FALSE(app_window->IsFullscreen());
+
+    CloseShellWindow(shell_window);
+  }
+
+  {
+    // Repeat the test, but make sure that frameless platform apps are never put
+    // into immersive fullscreen.
+    apps::ShellWindow::CreateParams params;
+    params.frame = apps::ShellWindow::FRAME_NONE;
+    apps::ShellWindow* shell_window = CreateShellWindowFromParams(
+        extension, params);
+    apps::NativeAppWindow* app_window = shell_window->GetBaseWindow();
+    ASSERT_TRUE(shell_window->GetBaseWindow()->IsActive());
+    EXPECT_FALSE(app_window->IsFullscreen());
+
+    ash::accelerators::ToggleFullscreen();
+    EXPECT_TRUE(app_window->IsFullscreen());
+    EXPECT_FALSE(IsInImmersiveFullscreen(app_window->GetNativeWindow()));
+
+    ash::accelerators::ToggleFullscreen();
+    EXPECT_FALSE(app_window->IsFullscreen());
+
+    CloseShellWindow(shell_window);
+  }

[James Cook, 2013/11/25 19:09:20]

Nice test.

 }