Home | History | Annotate | Download | only in apps 
      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
    222