chrome/browser/apps/app_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 "chrome/browser/apps/app_browsertest_util.h"
   6 #include "chrome/browser/lifetime/application_lifetime.h"
   7 #include "chrome/browser/ui/browser_iterator.h"
   8 #include "chrome/browser/ui/browser_window.h"
   9 #include "chrome/test/base/interactive_test_utils.h"
  10 #include "extensions/browser/app_window/native_app_window.h"
  11 #include "extensions/test/extension_test_message_listener.h"
  12 #include "extensions/test/result_catcher.h"
  13
  14 #if defined(OS_MACOSX) && !defined(OS_IOS)
  15 #include "base/mac/mac_util.h"
  16 #endif
  17
  18 #if defined(OS_WIN)
  19 #include <windows.h>
  20 #include "ui/aura/window.h"
  21 #include "ui/aura/window_tree_host.h"
  22 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
  23 #include "ui/views/win/hwnd_message_handler_delegate.h"
  24 #include "ui/views/win/hwnd_util.h"
  25 #endif
  26
  27 using extensions::AppWindow;
  28 using extensions::NativeAppWindow;
  29
  30 // Helper class that has to be created in the stack to check if the fullscreen
  31 // setting of a NativeWindow has changed since the creation of the object.
  32 class FullscreenChangeWaiter {
  33  public:
  34   explicit FullscreenChangeWaiter(NativeAppWindow* window)
  35       : window_(window),
  36         initial_fullscreen_state_(window_->IsFullscreen()) {}
  37
  38   void Wait() {
  39     while (initial_fullscreen_state_ == window_->IsFullscreen())
  40       content::RunAllPendingInMessageLoop();
  41   }
  42
  43  private:
  44   NativeAppWindow* window_;
  45   bool initial_fullscreen_state_;
  46
  47   DISALLOW_COPY_AND_ASSIGN(FullscreenChangeWaiter);
  48 };
  49
  50 class AppWindowInteractiveTest : public extensions::PlatformAppBrowserTest {
  51  public:
  52   bool RunAppWindowInteractiveTest(const char* testName) {
  53     ExtensionTestMessageListener launched_listener("Launched", true);
  54     LoadAndLaunchPlatformApp("window_api_interactive", &launched_listener);
  55
  56     extensions::ResultCatcher catcher;
  57     launched_listener.Reply(testName);
  58
  59     if (!catcher.GetNextResult()) {
  60       message_ = catcher.message();
  61       return false;
  62     }
  63
  64     return true;
  65   }
  66
  67   bool SimulateKeyPress(ui::KeyboardCode key) {
  68     return ui_test_utils::SendKeyPressToWindowSync(
  69         GetFirstAppWindow()->GetNativeWindow(),
  70         key,
  71         false,
  72         false,
  73         false,
  74         false);
  75   }
  76
  77   // This method will wait until the application is able to ack a key event.
  78   void WaitUntilKeyFocus() {
  79     ExtensionTestMessageListener key_listener("KeyReceived", false);
  80
  81     while (!key_listener.was_satisfied()) {
  82       ASSERT_TRUE(SimulateKeyPress(ui::VKEY_Z));
  83       content::RunAllPendingInMessageLoop();
  84     }
  85   }
  86
  87   // This test is a method so that we can test with each frame type.
  88   void TestOuterBoundsHelper(const std::string& frame_type);
  89 };
  90
  91 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, ESCLeavesFullscreenWindow) {
  92 // This test is flaky on MacOS 10.6 and 10.9.
  93 #if defined(OS_MACOSX) && !defined(OS_IOS)
  94   if (base::mac::IsOSSnowLeopard() || base::mac::IsOSMavericks())
  95     return;
  96 #endif
  97
  98   ExtensionTestMessageListener launched_listener("Launched", true);
  99   LoadAndLaunchPlatformApp("leave_fullscreen", &launched_listener);
 100
 101   // We start by making sure the window is actually focused.
 102   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
 103       GetFirstAppWindow()->GetNativeWindow()));
 104
 105   // When receiving the reply, the application will try to go fullscreen using
 106   // the Window API but there is no synchronous way to know if that actually
 107   // succeeded. Also, failure will not be notified. A failure case will only be
 108   // known with a timeout.
 109   {
 110     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 111
 112     launched_listener.Reply("window");
 113
 114     fs_changed.Wait();
 115   }
 116
 117   // Depending on the platform, going fullscreen might create an animation.
 118   // We want to make sure that the ESC key we will send next is actually going
 119   // to be received and the application might not receive key events during the
 120   // animation so we should wait for the key focus to be back.
 121   WaitUntilKeyFocus();
 122
 123   // Same idea as above but for leaving fullscreen. Fullscreen mode should be
 124   // left when ESC is received.
 125   {
 126     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 127
 128     ASSERT_TRUE(SimulateKeyPress(ui::VKEY_ESCAPE));
 129
 130     fs_changed.Wait();
 131   }
 132 }
 133
 134 #if defined(OS_MACOSX)
 135 // http://crbug.com/406009
 136 #define MAYBE_ESCLeavesFullscreenDOM DISABLED_ESCLeavesFullscreenDOM
 137 #else
 138 #define MAYBE_ESCLeavesFullscreenDOM ESCLeavesFullscreenDOM
 139 #endif
 140 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_ESCLeavesFullscreenDOM) {
 141 // This test is flaky on MacOS 10.6.
 142 #if defined(OS_MACOSX) && !defined(OS_IOS)
 143   if (base::mac::IsOSSnowLeopard())
 144     return;
 145 #endif
 146
 147   ExtensionTestMessageListener launched_listener("Launched", true);
 148   LoadAndLaunchPlatformApp("leave_fullscreen", &launched_listener);
 149
 150   // We start by making sure the window is actually focused.
 151   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
 152       GetFirstAppWindow()->GetNativeWindow()));
 153
 154   launched_listener.Reply("dom");
 155
 156   // Because the DOM way to go fullscreen requires user gesture, we simulate a
 157   // key event to get the window entering in fullscreen mode. The reply will
 158   // make the window listen for the key event. The reply will be sent to the
 159   // renderer process before the keypress and should be received in that order.
 160   // When receiving the key event, the application will try to go fullscreen
 161   // using the Window API but there is no synchronous way to know if that
 162   // actually succeeded. Also, failure will not be notified. A failure case will
 163   // only be known with a timeout.
 164   {
 165     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 166
 167     WaitUntilKeyFocus();
 168     ASSERT_TRUE(SimulateKeyPress(ui::VKEY_A));
 169
 170     fs_changed.Wait();
 171   }
 172
 173   // Depending on the platform, going fullscreen might create an animation.
 174   // We want to make sure that the ESC key we will send next is actually going
 175   // to be received and the application might not receive key events during the
 176   // animation so we should wait for the key focus to be back.
 177   WaitUntilKeyFocus();
 178
 179   // Same idea as above but for leaving fullscreen. Fullscreen mode should be
 180   // left when ESC is received.
 181   {
 182     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 183
 184     ASSERT_TRUE(SimulateKeyPress(ui::VKEY_ESCAPE));
 185
 186     fs_changed.Wait();
 187   }
 188 }
 189
 190 #if defined(OS_MACOSX)
 191 // http://crbug.com/406009
 192 #define MAYBE_ESCDoesNotLeaveFullscreenWindow DISABLED_ESCDoesNotLeaveFullscreenWindow
 193 #else
 194 #define MAYBE_ESCDoesNotLeaveFullscreenWindow ESCDoesNotLeaveFullscreenWindow
 195 #endif
 196 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest,
 197                        MAYBE_ESCDoesNotLeaveFullscreenWindow) {
 198 // This test is flaky on MacOS 10.6.
 199 #if defined(OS_MACOSX) && !defined(OS_IOS)
 200   if (base::mac::IsOSSnowLeopard())
 201     return;
 202 #endif
 203
 204   ExtensionTestMessageListener launched_listener("Launched", true);
 205   LoadAndLaunchPlatformApp("prevent_leave_fullscreen", &launched_listener);
 206
 207   // We start by making sure the window is actually focused.
 208   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
 209       GetFirstAppWindow()->GetNativeWindow()));
 210
 211   // When receiving the reply, the application will try to go fullscreen using
 212   // the Window API but there is no synchronous way to know if that actually
 213   // succeeded. Also, failure will not be notified. A failure case will only be
 214   // known with a timeout.
 215   {
 216     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 217
 218     launched_listener.Reply("window");
 219
 220     fs_changed.Wait();
 221   }
 222
 223   // Depending on the platform, going fullscreen might create an animation.
 224   // We want to make sure that the ESC key we will send next is actually going
 225   // to be received and the application might not receive key events during the
 226   // animation so we should wait for the key focus to be back.
 227   WaitUntilKeyFocus();
 228
 229   ASSERT_TRUE(SimulateKeyPress(ui::VKEY_ESCAPE));
 230
 231   ExtensionTestMessageListener second_key_listener("B_KEY_RECEIVED", false);
 232
 233   ASSERT_TRUE(SimulateKeyPress(ui::VKEY_B));
 234
 235   ASSERT_TRUE(second_key_listener.WaitUntilSatisfied());
 236
 237   // We assume that at that point, if we had to leave fullscreen, we should be.
 238   // However, by nature, we can not guarantee that and given that we do test
 239   // that nothing happens, we might end up with random-success when the feature
 240   // is broken.
 241   EXPECT_TRUE(GetFirstAppWindow()->GetBaseWindow()->IsFullscreen());
 242 }
 243
 244 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest,
 245                        ESCDoesNotLeaveFullscreenDOM) {
 246 // This test is flaky on MacOS 10.6 and 10.9.
 247 #if defined(OS_MACOSX) && !defined(OS_IOS)
 248   if (base::mac::IsOSSnowLeopard() || base::mac::IsOSMavericks())
 249     return;
 250 #endif
 251
 252   ExtensionTestMessageListener launched_listener("Launched", true);
 253   LoadAndLaunchPlatformApp("prevent_leave_fullscreen", &launched_listener);
 254
 255   // We start by making sure the window is actually focused.
 256   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
 257       GetFirstAppWindow()->GetNativeWindow()));
 258
 259   launched_listener.Reply("dom");
 260
 261   // Because the DOM way to go fullscreen requires user gesture, we simulate a
 262   // key event to get the window entering in fullscreen mode. The reply will
 263   // make the window listen for the key event. The reply will be sent to the
 264   // renderer process before the keypress and should be received in that order.
 265   // When receiving the key event, the application will try to go fullscreen
 266   // using the Window API but there is no synchronous way to know if that
 267   // actually succeeded. Also, failure will not be notified. A failure case will
 268   // only be known with a timeout.
 269   {
 270     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 271
 272     WaitUntilKeyFocus();
 273     ASSERT_TRUE(SimulateKeyPress(ui::VKEY_A));
 274
 275     fs_changed.Wait();
 276   }
 277
 278   // Depending on the platform, going fullscreen might create an animation.
 279   // We want to make sure that the ESC key we will send next is actually going
 280   // to be received and the application might not receive key events during the
 281   // animation so we should wait for the key focus to be back.
 282   WaitUntilKeyFocus();
 283
 284   ASSERT_TRUE(SimulateKeyPress(ui::VKEY_ESCAPE));
 285
 286   ExtensionTestMessageListener second_key_listener("B_KEY_RECEIVED", false);
 287
 288   ASSERT_TRUE(SimulateKeyPress(ui::VKEY_B));
 289
 290   ASSERT_TRUE(second_key_listener.WaitUntilSatisfied());
 291
 292   // We assume that at that point, if we had to leave fullscreen, we should be.
 293   // However, by nature, we can not guarantee that and given that we do test
 294   // that nothing happens, we might end up with random-success when the feature
 295   // is broken.
 296   EXPECT_TRUE(GetFirstAppWindow()->GetBaseWindow()->IsFullscreen());
 297 }
 298
 299 // This test is duplicated from ESCDoesNotLeaveFullscreenWindow.
 300 // It runs the same test, but uses the old permission names: 'fullscreen'
 301 // and 'overrideEscFullscreen'.
 302 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest,
 303                        ESCDoesNotLeaveFullscreenOldPermission) {
 304 // This test is flaky on MacOS 10.6 and 10.9.
 305 #if defined(OS_MACOSX) && !defined(OS_IOS)
 306   if (base::mac::IsOSSnowLeopard() || base::mac::IsOSMavericks())
 307     return;
 308 #endif
 309
 310   ExtensionTestMessageListener launched_listener("Launched", true);
 311   LoadAndLaunchPlatformApp("prevent_leave_fullscreen_old", &launched_listener);
 312
 313   // We start by making sure the window is actually focused.
 314   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
 315       GetFirstAppWindow()->GetNativeWindow()));
 316
 317   // When receiving the reply, the application will try to go fullscreen using
 318   // the Window API but there is no synchronous way to know if that actually
 319   // succeeded. Also, failure will not be notified. A failure case will only be
 320   // known with a timeout.
 321   {
 322     FullscreenChangeWaiter fs_changed(GetFirstAppWindow()->GetBaseWindow());
 323
 324     launched_listener.Reply("window");
 325
 326     fs_changed.Wait();
 327   }
 328
 329   // Depending on the platform, going fullscreen might create an animation.
 330   // We want to make sure that the ESC key we will send next is actually going
 331   // to be received and the application might not receive key events during the
 332   // animation so we should wait for the key focus to be back.
 333   WaitUntilKeyFocus();
 334
 335   ASSERT_TRUE(SimulateKeyPress(ui::VKEY_ESCAPE));
 336
 337   ExtensionTestMessageListener second_key_listener("B_KEY_RECEIVED", false);
 338
 339   ASSERT_TRUE(SimulateKeyPress(ui::VKEY_B));
 340
 341   ASSERT_TRUE(second_key_listener.WaitUntilSatisfied());
 342
 343   // We assume that at that point, if we had to leave fullscreen, we should be.
 344   // However, by nature, we can not guarantee that and given that we do test
 345   // that nothing happens, we might end up with random-success when the feature
 346   // is broken.
 347   EXPECT_TRUE(GetFirstAppWindow()->GetBaseWindow()->IsFullscreen());
 348 }
 349
 350 #if defined(OS_MACOSX) || defined(OS_WIN)
 351 // http://crbug.com/404081
 352 #define MAYBE_TestInnerBounds DISABLED_TestInnerBounds
 353 #else
 354 #define MAYBE_TestInnerBounds TestInnerBounds
 355 #endif
 356 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_TestInnerBounds) {
 357   ASSERT_TRUE(RunAppWindowInteractiveTest("testInnerBounds")) << message_;
 358 }
 359
 360 void AppWindowInteractiveTest::TestOuterBoundsHelper(
 361     const std::string& frame_type) {
 362   ExtensionTestMessageListener launched_listener("Launched", true);
 363   const extensions::Extension* app =
 364       LoadAndLaunchPlatformApp("outer_bounds", &launched_listener);
 365
 366   launched_listener.Reply(frame_type);
 367   launched_listener.Reset();
 368   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
 369
 370   AppWindow* window = GetFirstAppWindowForApp(app->id());
 371   gfx::Rect window_bounds;
 372   gfx::Size min_size, max_size;
 373
 374 #if defined(OS_WIN)
 375   // Get the bounds from the HWND.
 376   HWND hwnd = views::HWNDForNativeWindow(window->GetNativeWindow());
 377   RECT rect;
 378   ::GetWindowRect(hwnd, &rect);
 379   window_bounds = gfx::Rect(
 380       rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
 381
 382   // HWNDMessageHandler calls this when responding to WM_GETMINMAXSIZE, so it's
 383   // the closest to what the window will see.
 384   views::HWNDMessageHandlerDelegate* host =
 385       static_cast<views::HWNDMessageHandlerDelegate*>(
 386           static_cast<views::DesktopWindowTreeHostWin*>(
 387               aura::WindowTreeHost::GetForAcceleratedWidget(hwnd)));
 388   host->GetMinMaxSize(&min_size, &max_size);
 389   // Note that this does not include the the client area insets so we need to
 390   // add them.
 391   gfx::Insets insets;
 392   host->GetClientAreaInsets(&insets);
 393   min_size = gfx::Size(min_size.width() + insets.left() + insets.right(),
 394                        min_size.height() + insets.top() + insets.bottom());
 395   max_size = gfx::Size(
 396       max_size.width() ? max_size.width() + insets.left() + insets.right() : 0,
 397       max_size.height() ? max_size.height() + insets.top() + insets.bottom()
 398                         : 0);
 399 #endif  // defined(OS_WIN)
 400
 401   // These match the values in the outer_bounds/test.js
 402   EXPECT_EQ(gfx::Rect(10, 11, 300, 301), window_bounds);
 403   EXPECT_EQ(window->GetBaseWindow()->GetBounds(), window_bounds);
 404   EXPECT_EQ(200, min_size.width());
 405   EXPECT_EQ(201, min_size.height());
 406   EXPECT_EQ(400, max_size.width());
 407   EXPECT_EQ(401, max_size.height());
 408 }
 409
 410 // TODO(jackhou): Make this test work for other OSes.
 411 #if !defined(OS_WIN)
 412 #define MAYBE_TestOuterBoundsFrameChrome DISABLED_TestOuterBoundsFrameChrome
 413 #define MAYBE_TestOuterBoundsFrameNone DISABLED_TestOuterBoundsFrameNone
 414 #define MAYBE_TestOuterBoundsFrameColor DISABLED_TestOuterBoundsFrameColor
 415 #else
 416 #define MAYBE_TestOuterBoundsFrameChrome TestOuterBoundsFrameChrome
 417 #define MAYBE_TestOuterBoundsFrameNone TestOuterBoundsFrameNone
 418 #define MAYBE_TestOuterBoundsFrameColor TestOuterBoundsFrameColor
 419 #endif
 420
 421 // Test that the outer bounds match that of the native window.
 422 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest,
 423                        MAYBE_TestOuterBoundsFrameChrome) {
 424   TestOuterBoundsHelper("chrome");
 425 }
 426 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest,
 427                        MAYBE_TestOuterBoundsFrameNone) {
 428   TestOuterBoundsHelper("none");
 429 }
 430 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest,
 431                        MAYBE_TestOuterBoundsFrameColor) {
 432   TestOuterBoundsHelper("color");
 433 }
 434
 435 // This test does not work on Linux Aura because ShowInactive() is not
 436 // implemented. See http://crbug.com/325142
 437 // It also does not work on Windows because of the document being focused even
 438 // though the window is not activated. See http://crbug.com/326986
 439 // It also does not work on MacOS because ::ShowInactive() ends up behaving like
 440 // ::Show() because of Cocoa conventions. See http://crbug.com/326987
 441 // Those tests should be disabled on Linux GTK when they are enabled on the
 442 // other platforms, see http://crbug.com/328829
 443 #if (defined(OS_LINUX) && defined(USE_AURA)) || \
 444     defined(OS_WIN) || defined(OS_MACOSX)
 445 #define MAYBE_TestCreate DISABLED_TestCreate
 446 #define MAYBE_TestShow DISABLED_TestShow
 447 #else
 448 #define MAYBE_TestCreate TestCreate
 449 #define MAYBE_TestShow TestShow
 450 #endif
 451
 452 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_TestCreate) {
 453   ASSERT_TRUE(RunAppWindowInteractiveTest("testCreate")) << message_;
 454 }
 455
 456 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_TestShow) {
 457   ASSERT_TRUE(RunAppWindowInteractiveTest("testShow")) << message_;
 458 }
 459
 460 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, TestDrawAttention) {
 461   ASSERT_TRUE(RunAppWindowInteractiveTest("testDrawAttention")) << message_;
 462 }
 463
 464 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, TestCreateHidden) {
 465   // Created hidden both times.
 466   {
 467     ExtensionTestMessageListener launched_listener("Launched", true);
 468     LoadAndLaunchPlatformApp("hidden_with_id", &launched_listener);
 469     EXPECT_TRUE(launched_listener.WaitUntilSatisfied());
 470     ExtensionTestMessageListener create_listener_1("Launched", true);
 471     launched_listener.Reply("createHidden");
 472     EXPECT_TRUE(create_listener_1.WaitUntilSatisfied());
 473     AppWindow* app_window = GetFirstAppWindow();
 474     EXPECT_TRUE(app_window->is_hidden());
 475     ExtensionTestMessageListener create_listener_2("Launched", false);
 476     create_listener_1.Reply("createHidden");
 477     EXPECT_TRUE(create_listener_2.WaitUntilSatisfied());
 478     EXPECT_TRUE(app_window->is_hidden());
 479     app_window->GetBaseWindow()->Close();
 480   }
 481
 482   // Created hidden, then visible. The second create should show the window.
 483   {
 484     ExtensionTestMessageListener launched_listener("Launched", true);
 485     LoadAndLaunchPlatformApp("hidden_with_id", &launched_listener);
 486     EXPECT_TRUE(launched_listener.WaitUntilSatisfied());
 487     ExtensionTestMessageListener create_listener_1("Launched", true);
 488     launched_listener.Reply("createHidden");
 489     EXPECT_TRUE(create_listener_1.WaitUntilSatisfied());
 490     AppWindow* app_window = GetFirstAppWindow();
 491     EXPECT_TRUE(app_window->is_hidden());
 492     ExtensionTestMessageListener create_listener_2("Launched", false);
 493     create_listener_1.Reply("createVisible");
 494     EXPECT_TRUE(create_listener_2.WaitUntilSatisfied());
 495     EXPECT_FALSE(app_window->is_hidden());
 496     app_window->GetBaseWindow()->Close();
 497   }
 498 }
 499
 500 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, TestFullscreen) {
 501   ASSERT_TRUE(RunAppWindowInteractiveTest("testFullscreen")) << message_;
 502 }
 503
 504 // Only Linux and Windows use keep-alive to determine when to shut down.
 505 #if defined(OS_LINUX) || defined(OS_WIN)
 506
 507 // In general, hidden windows should not keep Chrome alive. The exception is
 508 // when windows are created hidden, we allow the app some time to show the
 509 // the window.
 510 class AppWindowHiddenKeepAliveTest : public extensions::PlatformAppBrowserTest {
 511  protected:
 512   AppWindowHiddenKeepAliveTest() {}
 513
 514  private:
 515   DISALLOW_COPY_AND_ASSIGN(AppWindowHiddenKeepAliveTest);
 516 };
 517
 518 // A window that becomes hidden should not keep Chrome alive.
 519 IN_PROC_BROWSER_TEST_F(AppWindowHiddenKeepAliveTest, ShownThenHidden) {
 520   LoadAndLaunchPlatformApp("minimal", "Launched");
 521   for (chrome::BrowserIterator it; !it.done(); it.Next())
 522     it->window()->Close();
 523
 524   EXPECT_TRUE(chrome::WillKeepAlive());
 525   GetFirstAppWindow()->Hide();
 526   EXPECT_FALSE(chrome::WillKeepAlive());
 527 }
 528
 529 // A window that is hidden but re-shown should still keep Chrome alive.
 530 IN_PROC_BROWSER_TEST_F(AppWindowHiddenKeepAliveTest, ShownThenHiddenThenShown) {
 531   LoadAndLaunchPlatformApp("minimal", "Launched");
 532   AppWindow* app_window = GetFirstAppWindow();
 533   app_window->Hide();
 534   app_window->Show(AppWindow::SHOW_ACTIVE);
 535
 536   EXPECT_TRUE(chrome::WillKeepAlive());
 537   for (chrome::BrowserIterator it; !it.done(); it.Next())
 538     it->window()->Close();
 539   EXPECT_TRUE(chrome::WillKeepAlive());
 540   app_window->GetBaseWindow()->Close();
 541 }
 542
 543 // A window that is created hidden and stays hidden should not keep Chrome
 544 // alive.
 545 IN_PROC_BROWSER_TEST_F(AppWindowHiddenKeepAliveTest, StaysHidden) {
 546   LoadAndLaunchPlatformApp("hidden", "Launched");
 547   AppWindow* app_window = GetFirstAppWindow();
 548   EXPECT_TRUE(app_window->is_hidden());
 549
 550   for (chrome::BrowserIterator it; !it.done(); it.Next())
 551     it->window()->Close();
 552   // This will time out if the command above does not terminate Chrome.
 553   content::RunMessageLoop();
 554 }
 555
 556 // A window that is created hidden but shown soon after should keep Chrome
 557 // alive.
 558 IN_PROC_BROWSER_TEST_F(AppWindowHiddenKeepAliveTest, HiddenThenShown) {
 559   ExtensionTestMessageListener launched_listener("Launched", true);
 560   LoadAndLaunchPlatformApp("hidden_then_shown", &launched_listener);
 561   AppWindow* app_window = GetFirstAppWindow();
 562   EXPECT_TRUE(app_window->is_hidden());
 563
 564   // Close all browser windows.
 565   for (chrome::BrowserIterator it; !it.done(); it.Next())
 566     it->window()->Close();
 567
 568   // The app window will show after 3 seconds.
 569   ExtensionTestMessageListener shown_listener("Shown", false);
 570   launched_listener.Reply("");
 571   EXPECT_TRUE(shown_listener.WaitUntilSatisfied());
 572   EXPECT_FALSE(app_window->is_hidden());
 573   EXPECT_TRUE(chrome::WillKeepAlive());
 574   app_window->GetBaseWindow()->Close();
 575 }
 576
 577 #endif