Rename StackingClient -> WindowTreeClient

ash/wm/workspace_controller_unittest.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 "ash/wm/workspace_controller.h"
 
 #include <map>
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
@@ skipping 77 matching lines @@
     window->SetType(aura::client::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     return window;
   }
 
   aura::Window* CreateTestWindow() {
     aura::Window* window = new aura::Window(NULL);
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
     window->SetType(aura::client::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
-    SetDefaultParentByPrimaryRootWindow(window);
+    ParentWindowInPrimaryRootWindow(window);
     return window;
   }
 
   aura::Window* CreateBrowserLikeWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindow();
     window->SetBounds(bounds);
     wm::WindowState* window_state = wm::GetWindowState(window);
     window_state->SetTrackedByWorkspace(true);
     window_state->set_window_position_managed(true);
     window->Show();
@@ skipping 125 matching lines @@
   // workspace.
   w1->SetBounds(gfx::Rect(0, 0, 200, 500));
   EXPECT_EQ(200, w1->bounds().width());
   EXPECT_EQ(500, w1->bounds().height());
 }
 
 // Verifies the bounds is not altered when showing and grid is enabled.
 TEST_F(WorkspaceControllerTest, SnapToGrid) {
   scoped_ptr<Window> w1(CreateTestWindowUnparented());
   w1->SetBounds(gfx::Rect(1, 6, 25, 30));
-  SetDefaultParentByPrimaryRootWindow(w1.get());
+  ParentWindowInPrimaryRootWindow(w1.get());
   // We are not aligning this anymore this way. When the window gets shown
   // the window is expected to be handled differently, but this cannot be
   // tested with this test. So the result of this test should be that the
   // bounds are exactly as passed in.
   EXPECT_EQ("1,6 25x30", w1->bounds().ToString());
 }
 
 // Assertions around a fullscreen window.
 TEST_F(WorkspaceControllerTest, SingleFullscreenWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
@@ skipping 399 matching lines @@
   w1_state->Activate();
   w1_state->Maximize();
   w1_state->Minimize();
 
   w1->parent()->RemoveChild(w1.get());
 
   // Do this so that when we Show() the window a resize occurs and we make the
   // window active.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
-  SetDefaultParentByPrimaryRootWindow(w1.get());
+  ParentWindowInPrimaryRootWindow(w1.get());
   delegate.set_window(w1.get());
   w1->Show();
 }
 
 // Verifies a window with a transient parent not managed by workspace works.
 TEST_F(WorkspaceControllerTest, TransientParent) {
   // Normal window with no transient parent.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->Show();
   wm::ActivateWindow(w2.get());
 
   // Window with a transient parent. We set the transient parent to the root,
   // which would never happen but is enough to exercise the bug.
   scoped_ptr<Window> w1(CreateTestWindowUnparented());
   Shell::GetInstance()->GetPrimaryRootWindow()->AddTransientChild(w1.get());
   w1->SetBounds(gfx::Rect(10, 11, 250, 251));
-  SetDefaultParentByPrimaryRootWindow(w1.get());
+  ParentWindowInPrimaryRootWindow(w1.get());
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   // The window with the transient parent should get added to the same parent as
   // the normal window.
   EXPECT_EQ(w2->parent(), w1->parent());
 }
 
 // Verifies changing TrackedByWorkspace works.
 TEST_F(WorkspaceControllerTest, TrackedByWorkspace) {
   // Create a fullscreen window.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->IsVisible());
 
   // Create a second fullscreen window and mark it not tracked by workspace
   // manager.
   scoped_ptr<Window> w2(CreateTestWindowUnparented());
   w2->SetBounds(gfx::Rect(1, 6, 25, 30));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
-  SetDefaultParentByPrimaryRootWindow(w2.get());
+  ParentWindowInPrimaryRootWindow(w2.get());
   w2->Show();
   wm::GetWindowState(w2.get())->SetTrackedByWorkspace(false);
   wm::ActivateWindow(w2.get());
 
   // Activating |w2| should force it to have the same parent as |w1|.
   EXPECT_EQ(w1->parent(), w2->parent());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
 
@@ skipping 439 matching lines @@
 // with a real browser the browser here has a transient child window
 // (corresponds to the status bubble).
 TEST_F(WorkspaceControllerTest, VerifyLayerOrdering) {
   scoped_ptr<Window> browser(
       aura::test::CreateTestWindowWithDelegate(
           NULL,
           aura::client::WINDOW_TYPE_NORMAL,
           gfx::Rect(5, 6, 7, 8),
           NULL));
   browser->SetName("browser");
-  SetDefaultParentByPrimaryRootWindow(browser.get());
+  ParentWindowInPrimaryRootWindow(browser.get());
   browser->Show();
   wm::ActivateWindow(browser.get());
 
   // |status_bubble| is made a transient child of |browser| and as a result
   // owned by |browser|.
   aura::test::TestWindowDelegate* status_bubble_delegate =
       aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate();
   status_bubble_delegate->set_can_focus(false);
   Window* status_bubble =
       aura::test::CreateTestWindowWithDelegate(
           status_bubble_delegate,
           aura::client::WINDOW_TYPE_POPUP,
           gfx::Rect(5, 6, 7, 8),
           NULL);
   browser->AddTransientChild(status_bubble);
-  SetDefaultParentByPrimaryRootWindow(status_bubble);
+  ParentWindowInPrimaryRootWindow(status_bubble);
   status_bubble->SetName("status_bubble");
 
   scoped_ptr<Window> app(
       aura::test::CreateTestWindowWithDelegate(
           NULL,
           aura::client::WINDOW_TYPE_NORMAL,
           gfx::Rect(5, 6, 7, 8),
           NULL));
   app->SetName("app");
-  SetDefaultParentByPrimaryRootWindow(app.get());
+  ParentWindowInPrimaryRootWindow(app.get());
 
   aura::Window* parent = browser->parent();
 
   app->Show();
   wm::ActivateWindow(app.get());
   EXPECT_EQ(GetWindowNames(parent), GetLayerNames(parent));
 
   // Minimize the app, focus should go the browser.
   app->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(browser.get()));
@@ skipping 72 matching lines @@
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(5, 5);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_window_component(HTCAPTION);
   scoped_ptr<Window> w1(
       aura::test::CreateTestWindowWithDelegate(&delegate,
                                                aura::client::WINDOW_TYPE_NORMAL,
                                                gfx::Rect(5, 6, 7, 8),
                                                NULL));
-  SetDefaultParentByPrimaryRootWindow(w1.get());
+  ParentWindowInPrimaryRootWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   w1->Show();
   wm::ActivateWindow(w1.get());
   DragMaximizedNonTrackedWindowObserver observer;
   w1->parent()->parent()->AddObserver(&observer);
   const gfx::Rect max_bounds(w1->bounds());
 
   generator.PressLeftButton();
   generator.MoveMouseTo(100, 100);
   // The bounds shouldn't change (drag should result in nothing happening
@@ skipping 28 matching lines @@
       Shell::GetPrimaryRootWindow(), gfx::Point());
   generator.MoveMouseTo(5, 5);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_window_component(HTCAPTION);
   scoped_ptr<Window> w1(
       aura::test::CreateTestWindowWithDelegate(&delegate,
                                                aura::client::WINDOW_TYPE_NORMAL,
                                                gfx::Rect(5, 6, 7, 8),
                                                NULL));
-  SetDefaultParentByPrimaryRootWindow(w1.get());
+  ParentWindowInPrimaryRootWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->Show();
   wm::ActivateWindow(w1.get());
   DragMaximizedNonTrackedWindowObserver observer;
   w1->parent()->parent()->AddObserver(&observer);
   const gfx::Rect max_bounds(w1->bounds());
 
   generator.PressLeftButton();
   generator.MoveMouseTo(100, 100);
   // The bounds shouldn't change (drag should result in nothing happening
@@ skipping 21 matching lines @@
   w1->parent()->parent()->RemoveObserver(&observer);
 }
 
 // Verifies that a new maximized window becomes visible after its activation
 // is requested, even though it does not become activated because a system
 // modal window is active.
 TEST_F(WorkspaceControllerTest, SwitchFromModal) {
   scoped_ptr<Window> modal_window(CreateTestWindowUnparented());
   modal_window->SetBounds(gfx::Rect(10, 11, 21, 22));
   modal_window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
-  SetDefaultParentByPrimaryRootWindow(modal_window.get());
+  ParentWindowInPrimaryRootWindow(modal_window.get());
   modal_window->Show();
   wm::ActivateWindow(modal_window.get());
 
   scoped_ptr<Window> maximized_window(CreateTestWindow());
   maximized_window->SetProperty(
       aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   maximized_window->Show();
   wm::ActivateWindow(maximized_window.get());
   EXPECT_TRUE(maximized_window->IsVisible());
 }
 
 }  // namespace internal
 }  // namespace ash