OLD | NEW |
| (Empty) |
1 // Copyright 2014 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/apps/app_browsertest_util.h" | |
6 #include "extensions/browser/app_window/native_app_window.h" | |
7 | |
8 using extensions::PlatformAppBrowserTest; | |
9 using extensions::Extension; | |
10 | |
11 namespace apps { | |
12 | |
13 namespace { | |
14 | |
15 class AppWindowTest : public PlatformAppBrowserTest { | |
16 protected: | |
17 void CheckAlwaysOnTopToFullscreen(AppWindow* window) { | |
18 ASSERT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
19 | |
20 // The always-on-top property should be temporarily disabled when the window | |
21 // enters fullscreen. | |
22 window->Fullscreen(); | |
23 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
24 | |
25 // From the API's point of view, the always-on-top property is enabled. | |
26 EXPECT_TRUE(window->IsAlwaysOnTop()); | |
27 | |
28 // The always-on-top property is restored when the window exits fullscreen. | |
29 window->Restore(); | |
30 EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
31 } | |
32 | |
33 void CheckNormalToFullscreen(AppWindow* window) { | |
34 // If the always-on-top property is false, it should remain this way when | |
35 // entering and exiting fullscreen mode. | |
36 ASSERT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
37 window->Fullscreen(); | |
38 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
39 window->Restore(); | |
40 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
41 } | |
42 | |
43 void CheckFullscreenToAlwaysOnTop(AppWindow* window) { | |
44 ASSERT_TRUE(window->GetBaseWindow()->IsFullscreenOrPending()); | |
45 | |
46 // Now enable always-on-top at runtime and ensure the property does not get | |
47 // applied immediately because the window is in fullscreen mode. | |
48 window->SetAlwaysOnTop(true); | |
49 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
50 | |
51 // From the API's point of view, the always-on-top property is enabled. | |
52 EXPECT_TRUE(window->IsAlwaysOnTop()); | |
53 | |
54 // Ensure the always-on-top property is applied when exiting fullscreen. | |
55 window->Restore(); | |
56 EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
57 } | |
58 }; | |
59 | |
60 } // namespace | |
61 | |
62 // Tests are flaky on Mac as transitioning to fullscreen is not instantaneous | |
63 // and throws errors when entering/exiting fullscreen too quickly. | |
64 #if defined(OS_MACOSX) | |
65 #define MAYBE_InitAlwaysOnTopToFullscreen DISABLED_InitAlwaysOnTopToFullscreen | |
66 #else | |
67 #define MAYBE_InitAlwaysOnTopToFullscreen InitAlwaysOnTopToFullscreen | |
68 #endif | |
69 | |
70 // Tests a window created with always-on-top enabled and ensures that the | |
71 // property is temporarily switched off when entering fullscreen mode. | |
72 IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_InitAlwaysOnTopToFullscreen) { | |
73 AppWindow* window = CreateTestAppWindow("{ \"alwaysOnTop\": true }"); | |
74 ASSERT_TRUE(window); | |
75 CheckAlwaysOnTopToFullscreen(window); | |
76 | |
77 window->SetAlwaysOnTop(false); | |
78 CheckNormalToFullscreen(window); | |
79 | |
80 CloseAppWindow(window); | |
81 } | |
82 | |
83 #if defined(OS_MACOSX) | |
84 #define MAYBE_RuntimeAlwaysOnTopToFullscreen \ | |
85 DISABLED_RuntimeAlwaysOnTopToFullscreen | |
86 #else | |
87 #define MAYBE_RuntimeAlwaysOnTopToFullscreen RuntimeAlwaysOnTopToFullscreen | |
88 #endif | |
89 | |
90 // Tests a window with always-on-top enabled at runtime and ensures that the | |
91 // property is temporarily switched off when entering fullscreen mode. | |
92 IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_RuntimeAlwaysOnTopToFullscreen) { | |
93 AppWindow* window = CreateTestAppWindow("{}"); | |
94 ASSERT_TRUE(window); | |
95 CheckNormalToFullscreen(window); | |
96 | |
97 window->SetAlwaysOnTop(true); | |
98 CheckAlwaysOnTopToFullscreen(window); | |
99 | |
100 CloseAppWindow(window); | |
101 } | |
102 | |
103 #if defined(OS_MACOSX) | |
104 #define MAYBE_InitFullscreenToAlwaysOnTop DISABLED_InitFullscreenToAlwaysOnTop | |
105 #else | |
106 #define MAYBE_InitFullscreenToAlwaysOnTop InitFullscreenToAlwaysOnTop | |
107 #endif | |
108 | |
109 // Tests a window created initially in fullscreen mode and ensures that the | |
110 // always-on-top property does not get applied until it exits fullscreen. | |
111 IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_InitFullscreenToAlwaysOnTop) { | |
112 AppWindow* window = CreateTestAppWindow("{ \"state\": \"fullscreen\" }"); | |
113 ASSERT_TRUE(window); | |
114 CheckFullscreenToAlwaysOnTop(window); | |
115 | |
116 CloseAppWindow(window); | |
117 } | |
118 | |
119 #if defined(OS_MACOSX) | |
120 #define MAYBE_RuntimeFullscreenToAlwaysOnTop \ | |
121 DISABLED_RuntimeFullscreenToAlwaysOnTop | |
122 #else | |
123 #define MAYBE_RuntimeFullscreenToAlwaysOnTop RuntimeFullscreenToAlwaysOnTop | |
124 #endif | |
125 | |
126 // Tests a window that enters fullscreen mode at runtime and ensures that the | |
127 // always-on-top property does not get applied until it exits fullscreen. | |
128 IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_RuntimeFullscreenToAlwaysOnTop) { | |
129 AppWindow* window = CreateTestAppWindow("{}"); | |
130 ASSERT_TRUE(window); | |
131 | |
132 window->Fullscreen(); | |
133 CheckFullscreenToAlwaysOnTop(window); | |
134 | |
135 CloseAppWindow(window); | |
136 } | |
137 | |
138 #if defined(OS_MACOSX) | |
139 #define MAYBE_InitFullscreenAndAlwaysOnTop DISABLED_InitFullscreenAndAlwaysOnTop | |
140 #else | |
141 #define MAYBE_InitFullscreenAndAlwaysOnTop InitFullscreenAndAlwaysOnTop | |
142 #endif | |
143 | |
144 // Tests a window created with both fullscreen and always-on-top enabled. Ensure | |
145 // that always-on-top is only applied when the window exits fullscreen. | |
146 IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_InitFullscreenAndAlwaysOnTop) { | |
147 AppWindow* window = CreateTestAppWindow( | |
148 "{ \"alwaysOnTop\": true, \"state\": \"fullscreen\" }"); | |
149 ASSERT_TRUE(window); | |
150 | |
151 EXPECT_TRUE(window->GetBaseWindow()->IsFullscreenOrPending()); | |
152 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
153 | |
154 // From the API's point of view, the always-on-top property is enabled. | |
155 EXPECT_TRUE(window->IsAlwaysOnTop()); | |
156 | |
157 window->Restore(); | |
158 EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
159 | |
160 CloseAppWindow(window); | |
161 } | |
162 | |
163 #if defined(OS_MACOSX) | |
164 #define MAYBE_DisableAlwaysOnTopInFullscreen \ | |
165 DISABLED_DisableAlwaysOnTopInFullscreen | |
166 #else | |
167 #define MAYBE_DisableAlwaysOnTopInFullscreen DisableAlwaysOnTopInFullscreen | |
168 #endif | |
169 | |
170 // Tests a window created with always-on-top enabled, but then disabled while | |
171 // in fullscreen mode. After exiting fullscreen, always-on-top should remain | |
172 // disabled. | |
173 IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_DisableAlwaysOnTopInFullscreen) { | |
174 AppWindow* window = CreateTestAppWindow("{ \"alwaysOnTop\": true }"); | |
175 ASSERT_TRUE(window); | |
176 | |
177 // Disable always-on-top while in fullscreen mode. | |
178 window->Fullscreen(); | |
179 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
180 window->SetAlwaysOnTop(false); | |
181 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
182 | |
183 // Ensure that always-on-top remains disabled. | |
184 window->Restore(); | |
185 EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop()); | |
186 | |
187 CloseAppWindow(window); | |
188 } | |
189 | |
190 } // namespace apps | |
OLD | NEW |