[mus+ash] Removes WmWindow from ash (app_list, frame, metrics, session, system, wallpaper)

ash/mus/top_level_window_factory.cc

 // Copyright 2017 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/mus/top_level_window_factory.h"
 
 #include "ash/mus/disconnected_app_handler.h"
 #include "ash/mus/frame/detached_title_area_renderer.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/window_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/shell.h"
 #include "ash/wm/container_finder.h"
 #include "ash/wm/window_state.h"
-#include "ash/wm_window.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/public/interfaces/window_manager_constants.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/property_utils.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
+#include "ui/display/screen.h"
 
 namespace ash {
 namespace mus {
 namespace {
 
 // Returns true if a fullscreen window was requested.
 bool IsFullscreen(aura::PropertyConverter* property_converter,
                   const std::vector<uint8_t>& transport_data) {
   using ui::mojom::WindowManager;
   aura::PropertyConverter::PrimitiveType show_state = 0;
@@ skipping 49 matching lines @@
   const gfx::Size root_size =
       root_window_controller->GetRootWindow()->bounds().size();
   auto show_state_iter =
       properties->find(ui::mojom::WindowManager::kShowState_Property);
   if (show_state_iter != properties->end()) {
     if (IsFullscreen(window_manager->property_converter(),
                      show_state_iter->second)) {
       gfx::Rect bounds(root_size);
       if (!container_window) {
         const display::Display display =
-            root_window_controller->GetWindow()->GetDisplayNearestWindow();
+            display::Screen::GetScreen()->GetDisplayNearestWindow(
+                root_window_controller->GetRootWindow());
         bounds.Offset(display.bounds().OffsetFromOrigin());
       }
       return bounds;
     }
   }
 
   gfx::Size window_size;
   if (GetWindowPreferredSize(*properties, &window_size) &&
       !window_size.IsEmpty()) {
     // TODO(sky): likely want to constrain more than root size.
@@ skipping 62 matching lines @@
   aura::SetWindowType(window, window_type);
   window->SetProperty(aura::client::kEmbedType,
                       aura::client::WindowEmbedType::TOP_LEVEL_IN_WM);
   ApplyProperties(window, property_converter, *properties);
   window->Init(ui::LAYER_TEXTURED);
   window->SetBounds(bounds);
 
   if (container_window) {
     container_window->AddChild(window);
   } else {
-    WmWindow* root = root_window_controller->GetWindow();
-    gfx::Point origin =
-        root->ConvertPointToTarget(root->GetRootWindow(), gfx::Point());
-    origin += root_window_controller->GetWindow()
-                  ->GetDisplayNearestWindow()
-                  .bounds()
-                  .OffsetFromOrigin();
+    aura::Window* root = root_window_controller->GetRootWindow();
+    gfx::Point origin;
+    aura::Window::ConvertPointToTarget(root, root->GetRootWindow(), &origin);
+    const display::Display display =
+        display::Screen::GetScreen()->GetDisplayNearestWindow(
+            root_window_controller->GetRootWindow());
+    origin += display.bounds().OffsetFromOrigin();
     gfx::Rect bounds_in_screen(origin, bounds.size());
     ash::wm::GetDefaultParent(window, bounds_in_screen)->AddChild(window);
   }
   return window;
 }
 
 }  // namespace
 
 aura::Window* CreateAndParentTopLevelWindow(
     WindowManager* window_manager,
     ui::mojom::WindowType window_type,
     std::map<std::string, std::vector<uint8_t>>* properties) {
   RootWindowController* root_window_controller =
       GetRootWindowControllerForNewTopLevelWindow(properties);
   aura::Window* window = CreateAndParentTopLevelWindowInRoot(
       window_manager, root_window_controller, window_type, properties);
   DisconnectedAppHandler::Create(window);
 
   auto ignored_by_shelf_iter = properties->find(
       ui::mojom::WindowManager::kWindowIgnoredByShelf_InitProperty);
   if (ignored_by_shelf_iter != properties->end()) {
-    wm::WindowState* window_state = WmWindow::Get(window)->GetWindowState();
+    wm::WindowState* window_state = wm::GetWindowState(window);
     window_state->set_ignored_by_shelf(
         mojo::ConvertTo<bool>(ignored_by_shelf_iter->second));
     // No need to persist this value.
     properties->erase(ignored_by_shelf_iter);
   }
 
   auto focusable_iter =
       properties->find(ui::mojom::WindowManager::kFocusable_InitProperty);
   if (focusable_iter != properties->end()) {
     bool can_focus = mojo::ConvertTo<bool>(focusable_iter->second);
     window_manager->window_tree_client()->SetCanFocus(window, can_focus);
     NonClientFrameController* non_client_frame_controller =
         NonClientFrameController::Get(window);
     if (non_client_frame_controller)
       non_client_frame_controller->set_can_activate(can_focus);
     // No need to persist this value.
     properties->erase(focusable_iter);
   }
   return window;
 }
 
 }  // namespace mus
 }  // namespace ash