Removes WmShell::NewWindow()

ash/common/wm/workspace/workspace_layout_manager_unittest.cc

 // Copyright (c) 2012 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/common/wm/workspace/workspace_layout_manager.h"
 
 #include <string>
 #include <utility>
 
 #include "ash/common/session/session_state_delegate.h"
@@ skipping 10 matching lines @@
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm/workspace/workspace_window_resizer.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "ui/aura/env.h"
+#include "ui/aura/window.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_base_types.h"
+#include "ui/compositor/layer_type.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 namespace {
 
@@ skipping 282 matching lines @@
   WmWindow* window_;
 
   DISALLOW_COPY_AND_ASSIGN(DontClobberRestoreBoundsWindowObserver);
 };
 
 // Creates a window, maximized the window and from within the maximized
 // notification sets the bounds of a window to overlap the shelf. Verifies this
 // doesn't effect the restore bounds.
 TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) {
   DontClobberRestoreBoundsWindowObserver window_observer;
-  WindowOwner window_owner(WmShell::Get()->NewWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                                     ui::LAYER_TEXTURED));
-  WmWindow* window = window_owner.window();
+  std::unique_ptr<aura::Window> window(
+      base::MakeUnique<aura::Window>(nullptr, ui::wm::WINDOW_TYPE_NORMAL));
+  window->Init(ui::LAYER_TEXTURED);
   window->SetBounds(gfx::Rect(10, 20, 30, 40));
   // NOTE: for this test to exercise the failure the observer needs to be added
   // before the parent set. This mimics what BrowserFrameAsh does.
-  window->aura_window()->AddObserver(&window_observer);
-  ParentWindowInPrimaryRootWindow(window);
+  window->AddObserver(&window_observer);
+  ParentWindowInPrimaryRootWindow(WmWindow::Get(window.get()));
   window->Show();
 
-  wm::WindowState* window_state = window->GetWindowState();
+  wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
 
   std::unique_ptr<WindowOwner> window2_owner(
       CreateTestWindow(gfx::Rect(12, 20, 30, 40)));
   WmWindow* window2 = window2_owner->window();
-  AddTransientChild(window, window2);
+  AddTransientChild(WmWindow::Get(window.get()), window2);
   window2->Show();
 
   window_observer.set_window(window2);
   window_state->Maximize();
   EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInScreen().ToString());
-  window->aura_window()->RemoveObserver(&window_observer);
+  window->RemoveObserver(&window_observer);
 }
 
 // Verifies when a window is maximized all descendant windows have a size.
 TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) {
   std::unique_ptr<WindowOwner> window_owner(
       CreateTestWindow(gfx::Rect(10, 20, 30, 40)));
   WmWindow* window = window_owner->window();
   window->Show();
   wm::WindowState* window_state = window->GetWindowState();
   window_state->Activate();
   std::unique_ptr<WindowOwner> child_window_owner(
       CreateChildWindow(window, gfx::Rect(5, 6, 7, 8)));
   WmWindow* child_window = child_window_owner->window();
   window_state->Maximize();
   EXPECT_EQ("5,6 7x8", child_window->GetBounds().ToString());
 }
 
 // Verifies a window created with maximized state has the maximized
 // bounds.
 TEST_F(WorkspaceLayoutManagerTest, MaximizeWithEmptySize) {
-  WindowOwner window_owner(WmShell::Get()->NewWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                                     ui::LAYER_TEXTURED));
-  WmWindow* window = window_owner.window();
-  window->GetWindowState()->Maximize();
+  std::unique_ptr<aura::Window> window(
+      base::MakeUnique<aura::Window>(nullptr, ui::wm::WINDOW_TYPE_NORMAL));
+  window->Init(ui::LAYER_TEXTURED);
+  wm::GetWindowState(window.get())->Maximize();
   WmWindow* default_container =
       WmShell::Get()->GetPrimaryRootWindowController()->GetWmContainer(
           kShellWindowId_DefaultContainer);
-  default_container->AddChild(window);
+  default_container->aura_window()->AddChild(window.get());
   window->Show();
   gfx::Rect work_area(
       display::Screen::GetScreen()->GetPrimaryDisplay().work_area());
   EXPECT_EQ(work_area.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) {
   // TODO: fix. This test verifies that when a window is added the bounds are
   // adjusted. CreateTestWindow() for mus adds, then sets the bounds (this comes
   // from NativeWidgetAura), which means this test now fails for aura-mus.
@@ skipping 169 matching lines @@
   animator->StopAnimating();
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(expected_bounds.ToString(), window->GetBounds().ToString());
 }
 
 // Do not adjust window bounds to ensure minimum visibility for transient
 // windows (crbug.com/624806).
 TEST_F(WorkspaceLayoutManagerTest,
        DoNotAdjustTransientWindowBoundsToEnsureMinimumVisibility) {
   UpdateDisplay("300x400");
-  WindowOwner window_owner(WmShell::Get()->NewWindow(ui::wm::WINDOW_TYPE_NORMAL,
-                                                     ui::LAYER_TEXTURED));
-  WmWindow* window = window_owner.window();
+  std::unique_ptr<aura::Window> window(
+      base::MakeUnique<aura::Window>(nullptr, ui::wm::WINDOW_TYPE_NORMAL));
+  window->Init(ui::LAYER_TEXTURED);
   window->SetBounds(gfx::Rect(10, 0, 100, 200));
-  ParentWindowInPrimaryRootWindow(window);
+  ParentWindowInPrimaryRootWindow(WmWindow::Get(window.get()));
   window->Show();
 
   std::unique_ptr<WindowOwner> window2_owner(
       CreateTestWindow(gfx::Rect(10, 0, 40, 20)));
   WmWindow* window2 = window2_owner->window();
-  AddTransientChild(window, window2);
+  AddTransientChild(WmWindow::Get(window.get()), window2);
   window2->Show();
 
   gfx::Rect expected_bounds = window2->GetBounds();
-  WmShell::Get()->SetDisplayWorkAreaInsets(window, gfx::Insets(50, 0, 0, 0));
+  WmShell::Get()->SetDisplayWorkAreaInsets(WmWindow::Get(window.get()),
+                                           gfx::Insets(50, 0, 0, 0));
   EXPECT_EQ(expected_bounds.ToString(), window2->GetBounds().ToString());
 }
 
 // Following "Solo" tests were originally written for BaseLayoutManager.
 using WorkspaceLayoutManagerSoloTest = AshTest;
 
 // Tests normal->maximize->normal.
 TEST_F(WorkspaceLayoutManagerSoloTest, Maximize) {
   gfx::Rect bounds(100, 100, 200, 200);
   std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds));
@@ skipping 659 matching lines @@
   window->SetBounds(keyboard_bounds());
   window->GetWindowState()->set_ignore_keyboard_bounds_change(true);
   window->Activate();
 
   EXPECT_EQ(keyboard_bounds(), window->GetBounds());
   ShowKeyboard();
   EXPECT_EQ(keyboard_bounds(), window->GetBounds());
 }
 
 }  // namespace ash