apps/shell_window_interactive_uitest.cc

   1 // Copyright 2013 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 "apps/ui/native_app_window.h"
   6 #include "chrome/browser/apps/app_browsertest_util.h"
   7 #include "chrome/browser/extensions/extension_test_message_listener.h"
   8
   9 using extensions::PlatformAppBrowserTest;
  10 using extensions::Extension;
  11
  12 namespace apps {
  13
  14 namespace {
  15
  16 const char kDefaultTestApp[] = "shell_window/generic";
  17
  18 class ShellWindowTest : public PlatformAppBrowserTest {
  19  protected:
  20   // Load the test app and create a window. The window must be closed by the
  21   // caller in order to terminate the test.
  22   // |app_path| is the name of the test.
  23   // |window_create_options| are the options that will be passed to
  24   // chrome.app.window.create() in the test app.
  25   ShellWindow* OpenWindow(const char* app_path,
  26                           const char* window_create_options) {
  27     ExtensionTestMessageListener launched_listener("launched", true);
  28     ExtensionTestMessageListener loaded_listener("window_loaded", false);
  29
  30     // Load and launch the test app.
  31     const Extension* extension = LoadAndLaunchPlatformApp(app_path);
  32     EXPECT_TRUE(extension);
  33     EXPECT_TRUE(launched_listener.WaitUntilSatisfied());
  34
  35     // Send the options for window creation.
  36     launched_listener.Reply(window_create_options);
  37
  38     // Wait for the window to be opened and loaded.
  39     EXPECT_TRUE(loaded_listener.WaitUntilSatisfied());
  40
  41     EXPECT_EQ(1U, GetShellWindowCount());
  42     ShellWindow* shell_window = GetFirstShellWindow();
  43     return shell_window;
  44   }
  45
  46   void CheckAlwaysOnTopToFullscreen(ShellWindow* window) {
  47     ASSERT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
  48
  49     // The always-on-top property should be temporarily disabled when the window
  50     // enters fullscreen.
  51     window->Fullscreen();
  52     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
  53
  54     // From the API's point of view, the always-on-top property is enabled.
  55     EXPECT_TRUE(window->IsAlwaysOnTop());
  56
  57     // The always-on-top property is restored when the window exits fullscreen.
  58     window->Restore();
  59     EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
  60   }
  61
  62   void CheckNormalToFullscreen(ShellWindow* window) {
  63     // If the always-on-top property is false, it should remain this way when
  64     // entering and exiting fullscreen mode.
  65     ASSERT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
  66     window->Fullscreen();
  67     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
  68     window->Restore();
  69     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
  70   }
  71
  72   void CheckFullscreenToAlwaysOnTop(ShellWindow* window) {
  73     ASSERT_TRUE(window->GetBaseWindow()->IsFullscreenOrPending());
  74
  75     // Now enable always-on-top at runtime and ensure the property does not get
  76     // applied immediately because the window is in fullscreen mode.
  77     window->SetAlwaysOnTop(true);
  78     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
  79
  80     // From the API's point of view, the always-on-top property is enabled.
  81     EXPECT_TRUE(window->IsAlwaysOnTop());
  82
  83     // Ensure the always-on-top property is applied when exiting fullscreen.
  84     window->Restore();
  85     EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
  86   }
  87 };
  88
  89 }  // namespace
  90
  91 // Tests are flaky on Mac as transitioning to fullscreen is not instantaneous
  92 // and throws errors when entering/exiting fullscreen too quickly.
  93 #if defined(OS_MACOSX)
  94 #define MAYBE_InitAlwaysOnTopToFullscreen DISABLED_InitAlwaysOnTopToFullscreen
  95 #else
  96 #define MAYBE_InitAlwaysOnTopToFullscreen InitAlwaysOnTopToFullscreen
  97 #endif
  98
  99 // Tests a window created with always-on-top enabled and ensures that the
 100 // property is temporarily switched off when entering fullscreen mode.
 101 IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_InitAlwaysOnTopToFullscreen) {
 102   ShellWindow* window = OpenWindow(
 103       kDefaultTestApp, "{ \"alwaysOnTop\": true }");
 104   ASSERT_TRUE(window);
 105   CheckAlwaysOnTopToFullscreen(window);
 106
 107   window->SetAlwaysOnTop(false);
 108   CheckNormalToFullscreen(window);
 109
 110   CloseShellWindow(window);
 111 }
 112
 113 #if defined(OS_MACOSX)
 114 #define MAYBE_RuntimeAlwaysOnTopToFullscreen DISABLED_RuntimeAlwaysOnTopToFullscreen
 115 #else
 116 #define MAYBE_RuntimeAlwaysOnTopToFullscreen RuntimeAlwaysOnTopToFullscreen
 117 #endif
 118
 119 // Tests a window with always-on-top enabled at runtime and ensures that the
 120 // property is temporarily switched off when entering fullscreen mode.
 121 IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_RuntimeAlwaysOnTopToFullscreen) {
 122   ShellWindow* window = OpenWindow(
 123       kDefaultTestApp, "{}");
 124   ASSERT_TRUE(window);
 125   CheckNormalToFullscreen(window);
 126
 127   window->SetAlwaysOnTop(true);
 128   CheckAlwaysOnTopToFullscreen(window);
 129
 130   CloseShellWindow(window);
 131 }
 132
 133 #if defined(OS_MACOSX)
 134 #define MAYBE_InitFullscreenToAlwaysOnTop DISABLED_InitFullscreenToAlwaysOnTop
 135 #else
 136 #define MAYBE_InitFullscreenToAlwaysOnTop InitFullscreenToAlwaysOnTop
 137 #endif
 138
 139 // Tests a window created initially in fullscreen mode and ensures that the
 140 // always-on-top property does not get applied until it exits fullscreen.
 141 IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_InitFullscreenToAlwaysOnTop) {
 142   ShellWindow* window = OpenWindow(
 143       kDefaultTestApp, "{ \"state\": \"fullscreen\" }");
 144   ASSERT_TRUE(window);
 145   CheckFullscreenToAlwaysOnTop(window);
 146
 147   CloseShellWindow(window);
 148 }
 149
 150 #if defined(OS_MACOSX)
 151 #define MAYBE_RuntimeFullscreenToAlwaysOnTop DISABLED_RuntimeFullscreenToAlwaysOnTop
 152 #else
 153 #define MAYBE_RuntimeFullscreenToAlwaysOnTop RuntimeFullscreenToAlwaysOnTop
 154 #endif
 155
 156 // Tests a window that enters fullscreen mode at runtime and ensures that the
 157 // always-on-top property does not get applied until it exits fullscreen.
 158 IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_RuntimeFullscreenToAlwaysOnTop) {
 159   ShellWindow* window = OpenWindow(
 160       kDefaultTestApp, "{}");
 161   ASSERT_TRUE(window);
 162
 163   window->Fullscreen();
 164   CheckFullscreenToAlwaysOnTop(window);
 165
 166   CloseShellWindow(window);
 167 }
 168
 169 #if defined(OS_MACOSX)
 170 #define MAYBE_InitFullscreenAndAlwaysOnTop DISABLED_InitFullscreenAndAlwaysOnTop
 171 #else
 172 #define MAYBE_InitFullscreenAndAlwaysOnTop InitFullscreenAndAlwaysOnTop
 173 #endif
 174
 175 // Tests a window created with both fullscreen and always-on-top enabled. Ensure
 176 // that always-on-top is only applied when the window exits fullscreen.
 177 IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_InitFullscreenAndAlwaysOnTop) {
 178   ShellWindow* window = OpenWindow(
 179       kDefaultTestApp, "{ \"alwaysOnTop\": true, \"state\": \"fullscreen\" }");
 180   ASSERT_TRUE(window);
 181
 182   EXPECT_TRUE(window->GetBaseWindow()->IsFullscreenOrPending());
 183   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 184
 185   // From the API's point of view, the always-on-top property is enabled.
 186   EXPECT_TRUE(window->IsAlwaysOnTop());
 187
 188   window->Restore();
 189   EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
 190
 191   CloseShellWindow(window);
 192 }
 193
 194 #if defined(OS_MACOSX)
 195 #define MAYBE_DisableAlwaysOnTopInFullscreen DISABLED_DisableAlwaysOnTopInFullscreen
 196 #else
 197 #define MAYBE_DisableAlwaysOnTopInFullscreen DisableAlwaysOnTopInFullscreen
 198 #endif
 199
 200 // Tests a window created with always-on-top enabled, but then disabled while
 201 // in fullscreen mode. After exiting fullscreen, always-on-top should remain
 202 // disabled.
 203 IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_DisableAlwaysOnTopInFullscreen) {
 204   ShellWindow* window = OpenWindow(
 205       kDefaultTestApp, "{ \"alwaysOnTop\": true }");
 206   ASSERT_TRUE(window);
 207
 208   // Disable always-on-top while in fullscreen mode.
 209   window->Fullscreen();
 210   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 211   window->SetAlwaysOnTop(false);
 212   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 213
 214   // Ensure that always-on-top remains disabled.
 215   window->Restore();
 216   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 217
 218   CloseShellWindow(window);
 219 }
 220
 221 }  // namespace apps