Rename apps::ShellWindow to apps::AppWindow

apps/app_window_interactive_uitest.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 "apps/ui/native_app_window.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 
 using extensions::PlatformAppBrowserTest;
 using extensions::Extension;
 
 namespace apps {
 
 namespace {
 
 const char kDefaultTestApp[] = "shell_window/generic";

[scheib, 2014/02/15 00:02:15]

I think it is reasonable to leave this as is vs moving the test -- but just
drawing it out to your attention.

 
-class ShellWindowTest : public PlatformAppBrowserTest {
+class AppWindowTest : public PlatformAppBrowserTest {
  protected:
   // Load the test app and create a window. The window must be closed by the
   // caller in order to terminate the test.
   // |app_path| is the name of the test.
   // |window_create_options| are the options that will be passed to
   // chrome.app.window.create() in the test app.
-  ShellWindow* OpenWindow(const char* app_path,
-                          const char* window_create_options) {
+  AppWindow* OpenWindow(const char* app_path,
+                        const char* window_create_options) {
     ExtensionTestMessageListener launched_listener("launched", true);
     ExtensionTestMessageListener loaded_listener("window_loaded", false);
 
     // Load and launch the test app.
     const Extension* extension = LoadAndLaunchPlatformApp(app_path);
     EXPECT_TRUE(extension);
     EXPECT_TRUE(launched_listener.WaitUntilSatisfied());
 
     // Send the options for window creation.
     launched_listener.Reply(window_create_options);
 
     // Wait for the window to be opened and loaded.
     EXPECT_TRUE(loaded_listener.WaitUntilSatisfied());
 
-    EXPECT_EQ(1U, GetShellWindowCount());
-    ShellWindow* shell_window = GetFirstShellWindow();
-    return shell_window;
+    EXPECT_EQ(1U, GetAppWindowCount());
+    AppWindow* app_window = GetFirstAppWindow();
+    return app_window;
   }
 
-  void CheckAlwaysOnTopToFullscreen(ShellWindow* window) {
+  void CheckAlwaysOnTopToFullscreen(AppWindow* window) {
     ASSERT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
 
     // The always-on-top property should be temporarily disabled when the window
     // enters fullscreen.
     window->Fullscreen();
     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 
     // From the API's point of view, the always-on-top property is enabled.
     EXPECT_TRUE(window->IsAlwaysOnTop());
 
     // The always-on-top property is restored when the window exits fullscreen.
     window->Restore();
     EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
   }
 
-  void CheckNormalToFullscreen(ShellWindow* window) {
+  void CheckNormalToFullscreen(AppWindow* window) {
     // If the always-on-top property is false, it should remain this way when
     // entering and exiting fullscreen mode.
     ASSERT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
     window->Fullscreen();
     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
     window->Restore();
     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
   }
 
-  void CheckFullscreenToAlwaysOnTop(ShellWindow* window) {
+  void CheckFullscreenToAlwaysOnTop(AppWindow* window) {
     ASSERT_TRUE(window->GetBaseWindow()->IsFullscreenOrPending());
 
     // Now enable always-on-top at runtime and ensure the property does not get
     // applied immediately because the window is in fullscreen mode.
     window->SetAlwaysOnTop(true);
     EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 
     // From the API's point of view, the always-on-top property is enabled.
     EXPECT_TRUE(window->IsAlwaysOnTop());
 
     // Ensure the always-on-top property is applied when exiting fullscreen.
     window->Restore();
     EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
   }
 };
 
 }  // namespace
 
 // Tests are flaky on Mac as transitioning to fullscreen is not instantaneous
 // and throws errors when entering/exiting fullscreen too quickly.
 #if defined(OS_MACOSX)
 #define MAYBE_InitAlwaysOnTopToFullscreen DISABLED_InitAlwaysOnTopToFullscreen
 #else
 #define MAYBE_InitAlwaysOnTopToFullscreen InitAlwaysOnTopToFullscreen
 #endif
 
 // Tests a window created with always-on-top enabled and ensures that the
 // property is temporarily switched off when entering fullscreen mode.
-IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_InitAlwaysOnTopToFullscreen) {
-  ShellWindow* window = OpenWindow(
-      kDefaultTestApp, "{ \"alwaysOnTop\": true }");
+IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_InitAlwaysOnTopToFullscreen) {
+  AppWindow* window = OpenWindow(kDefaultTestApp, "{ \"alwaysOnTop\": true }");
   ASSERT_TRUE(window);
   CheckAlwaysOnTopToFullscreen(window);
 
   window->SetAlwaysOnTop(false);
   CheckNormalToFullscreen(window);
 
-  CloseShellWindow(window);
+  CloseAppWindow(window);
 }
 
 #if defined(OS_MACOSX)
-#define MAYBE_RuntimeAlwaysOnTopToFullscreen DISABLED_RuntimeAlwaysOnTopToFullscreen
+#define MAYBE_RuntimeAlwaysOnTopToFullscreen \
+  DISABLED_RuntimeAlwaysOnTopToFullscreen
 #else
 #define MAYBE_RuntimeAlwaysOnTopToFullscreen RuntimeAlwaysOnTopToFullscreen
 #endif
 
 // Tests a window with always-on-top enabled at runtime and ensures that the
 // property is temporarily switched off when entering fullscreen mode.
-IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_RuntimeAlwaysOnTopToFullscreen) {
-  ShellWindow* window = OpenWindow(
-      kDefaultTestApp, "{}");
+IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_RuntimeAlwaysOnTopToFullscreen) {
+  AppWindow* window = OpenWindow(kDefaultTestApp, "{}");
   ASSERT_TRUE(window);
   CheckNormalToFullscreen(window);
 
   window->SetAlwaysOnTop(true);
   CheckAlwaysOnTopToFullscreen(window);
 
-  CloseShellWindow(window);
+  CloseAppWindow(window);
 }
 
 #if defined(OS_MACOSX)
 #define MAYBE_InitFullscreenToAlwaysOnTop DISABLED_InitFullscreenToAlwaysOnTop
 #else
 #define MAYBE_InitFullscreenToAlwaysOnTop InitFullscreenToAlwaysOnTop
 #endif
 
 // Tests a window created initially in fullscreen mode and ensures that the
 // always-on-top property does not get applied until it exits fullscreen.
-IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_InitFullscreenToAlwaysOnTop) {
-  ShellWindow* window = OpenWindow(
-      kDefaultTestApp, "{ \"state\": \"fullscreen\" }");
+IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_InitFullscreenToAlwaysOnTop) {
+  AppWindow* window =
+      OpenWindow(kDefaultTestApp, "{ \"state\": \"fullscreen\" }");
   ASSERT_TRUE(window);
   CheckFullscreenToAlwaysOnTop(window);
 
-  CloseShellWindow(window);
+  CloseAppWindow(window);
 }
 
 #if defined(OS_MACOSX)
-#define MAYBE_RuntimeFullscreenToAlwaysOnTop DISABLED_RuntimeFullscreenToAlwaysOnTop
+#define MAYBE_RuntimeFullscreenToAlwaysOnTop \
+  DISABLED_RuntimeFullscreenToAlwaysOnTop
 #else
 #define MAYBE_RuntimeFullscreenToAlwaysOnTop RuntimeFullscreenToAlwaysOnTop
 #endif
 
 // Tests a window that enters fullscreen mode at runtime and ensures that the
 // always-on-top property does not get applied until it exits fullscreen.
-IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_RuntimeFullscreenToAlwaysOnTop) {
-  ShellWindow* window = OpenWindow(
-      kDefaultTestApp, "{}");
+IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_RuntimeFullscreenToAlwaysOnTop) {
+  AppWindow* window = OpenWindow(kDefaultTestApp, "{}");
   ASSERT_TRUE(window);
 
   window->Fullscreen();
   CheckFullscreenToAlwaysOnTop(window);
 
-  CloseShellWindow(window);
+  CloseAppWindow(window);
 }
 
 #if defined(OS_MACOSX)
 #define MAYBE_InitFullscreenAndAlwaysOnTop DISABLED_InitFullscreenAndAlwaysOnTop
 #else
 #define MAYBE_InitFullscreenAndAlwaysOnTop InitFullscreenAndAlwaysOnTop
 #endif
 
 // Tests a window created with both fullscreen and always-on-top enabled. Ensure
 // that always-on-top is only applied when the window exits fullscreen.
-IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_InitFullscreenAndAlwaysOnTop) {
-  ShellWindow* window = OpenWindow(
+IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_InitFullscreenAndAlwaysOnTop) {
+  AppWindow* window = OpenWindow(
       kDefaultTestApp, "{ \"alwaysOnTop\": true, \"state\": \"fullscreen\" }");
   ASSERT_TRUE(window);
 
   EXPECT_TRUE(window->GetBaseWindow()->IsFullscreenOrPending());
   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 
   // From the API's point of view, the always-on-top property is enabled.
   EXPECT_TRUE(window->IsAlwaysOnTop());
 
   window->Restore();
   EXPECT_TRUE(window->GetBaseWindow()->IsAlwaysOnTop());
 
-  CloseShellWindow(window);
+  CloseAppWindow(window);
 }
 
 #if defined(OS_MACOSX)
-#define MAYBE_DisableAlwaysOnTopInFullscreen DISABLED_DisableAlwaysOnTopInFullscreen
+#define MAYBE_DisableAlwaysOnTopInFullscreen \
+  DISABLED_DisableAlwaysOnTopInFullscreen
 #else
 #define MAYBE_DisableAlwaysOnTopInFullscreen DisableAlwaysOnTopInFullscreen
 #endif
 
 // Tests a window created with always-on-top enabled, but then disabled while
 // in fullscreen mode. After exiting fullscreen, always-on-top should remain
 // disabled.
-IN_PROC_BROWSER_TEST_F(ShellWindowTest, MAYBE_DisableAlwaysOnTopInFullscreen) {
-  ShellWindow* window = OpenWindow(
-      kDefaultTestApp, "{ \"alwaysOnTop\": true }");
+IN_PROC_BROWSER_TEST_F(AppWindowTest, MAYBE_DisableAlwaysOnTopInFullscreen) {
+  AppWindow* window = OpenWindow(kDefaultTestApp, "{ \"alwaysOnTop\": true }");
   ASSERT_TRUE(window);
 
   // Disable always-on-top while in fullscreen mode.
   window->Fullscreen();
   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
   window->SetAlwaysOnTop(false);
   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 
   // Ensure that always-on-top remains disabled.
   window->Restore();
   EXPECT_FALSE(window->GetBaseWindow()->IsAlwaysOnTop());
 
-  CloseShellWindow(window);
+  CloseAppWindow(window);
 }
 
 }  // namespace apps