chromeos: converts ash devtools to aura::Window

ash/devtools/ash_devtools_dom_agent.cc

 // Copyright 2016 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/devtools/ash_devtools_dom_agent.h"
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
-#include "ash/wm_window.h"
 #include "components/ui_devtools/devtools_server.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "ui/aura/window.h"
 #include "ui/display/display.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
+#include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace devtools {
 
 namespace {
 using namespace ui::devtools::protocol;
 // TODO(mhashmi): Make ids reusable
 DOM::NodeId node_ids = 1;
 
 std::unique_ptr<DOM::Node> BuildNode(
     const std::string& name,
     std::unique_ptr<Array<std::string>> attributes,
     std::unique_ptr<Array<DOM::Node>> children) {
   constexpr int kDomElementNodeType = 1;
   std::unique_ptr<DOM::Node> node = DOM::Node::create()
                                         .setNodeId(node_ids++)
                                         .setNodeName(name)
                                         .setNodeType(kDomElementNodeType)
                                         .setAttributes(std::move(attributes))
                                         .build();
   node->setChildNodeCount(children->length());
   node->setChildren(std::move(children));
   return node;
 }
 
-std::unique_ptr<Array<std::string>> GetAttributes(const ash::WmWindow* window) {
+std::unique_ptr<Array<std::string>> GetAttributes(const aura::Window* window) {
   std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create();
   attributes->addItem("name");
-  attributes->addItem(window->aura_window()->GetName());
+  attributes->addItem(window->GetName());
   attributes->addItem("active");
-  attributes->addItem(window->IsActive() ? "true" : "false");
+  attributes->addItem(::wm::IsActiveWindow(window) ? "true" : "false");
   return attributes;
 }
 
 std::unique_ptr<Array<std::string>> GetAttributes(const views::Widget* widget) {
   std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create();
   attributes->addItem("name");
   attributes->addItem(widget->GetName());
   attributes->addItem("active");
   attributes->addItem(widget->IsActive() ? "true" : "false");
   return attributes;
 }
 
 std::unique_ptr<Array<std::string>> GetAttributes(const views::View* view) {
   std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create();
   attributes->addItem("name");
   attributes->addItem(view->GetClassName());
   return attributes;
 }
 
-WmWindow* FindPreviousSibling(WmWindow* window) {
-  std::vector<WmWindow*> siblings = window->GetParent()->GetChildren();
-  std::vector<WmWindow*>::iterator it =
-      std::find(siblings.begin(), siblings.end(), window);
+aura::Window* FindPreviousSibling(aura::Window* window) {
+  const aura::Window::Windows& siblings = window->parent()->children();
+  auto it = std::find(siblings.begin(), siblings.end(), window);
   DCHECK(it != siblings.end());
   // If this is the first child of its parent, the previous sibling is null
   return it == siblings.begin() ? nullptr : *std::prev(it);
 }
 
 views::View* FindPreviousSibling(views::View* view) {
   views::View* parent = view->parent();
   int view_index = -1;
   for (int i = 0, count = parent->child_count(); i < count; i++) {
     if (view == parent->child_at(i)) {
@@ skipping 12 matching lines @@
 SkColor RGBAToSkColor(DOM::RGBA* rgba) {
   if (!rgba)
     return SkColorSetARGB(0, 0, 0, 0);
   // Default alpha value is 0 (not visible) and need to convert alpha decimal
   // percentage value to hex
   return SkColorSetARGB(MaskColor(static_cast<int>(rgba->getA(0) * 255)),
                         MaskColor(rgba->getR()), MaskColor(rgba->getG()),
                         MaskColor(rgba->getB()));
 }
 
-views::Widget* GetWidgetFromWmWindow(WmWindow* window) {
-  return views::Widget::GetWidgetForNativeView(window->aura_window());
+views::Widget* GetWidgetFromWindow(aura::Window* window) {
+  return views::Widget::GetWidgetForNativeView(window);
 }
 
 }  // namespace
 
 AshDevToolsDOMAgent::AshDevToolsDOMAgent() {}
 
 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() {
   RemoveObservers();
 }
 
@@ skipping 25 matching lines @@
 void AshDevToolsDOMAgent::OnWindowHierarchyChanging(
     const HierarchyChangeParams& params) {
   // Only trigger this when params.receiver == params.old_parent.
   // Only removals are handled here. Removing a node can occur as a result of
   // reorganizing a window or just destroying it. OnWindowHierarchyChanged
   // is only called if there is a new_parent. The only case this method isn't
   // called is when adding a node because old_parent is then null.
   // Finally, We only trigger this  0 or 1 times as an old_parent will
   // either exist and only call this callback once, or not at all.
   if (params.receiver == params.old_parent)
-    RemoveWindowTree(WmWindow::Get(params.target), true);
+    RemoveWindowTree(params.target, true);
 }
 
 // Handles adding windows.
 void AshDevToolsDOMAgent::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   // Only trigger this when params.receiver == params.new_parent.
   // If there is an old_parent + new_parent, then this window's node was
   // removed in OnWindowHierarchyChanging and will now be added to the
   // new_parent. If there is only a new_parent, OnWindowHierarchyChanging is
   // never called and the window is only added here.
   if (params.receiver == params.new_parent)
-    AddWindowTree(WmWindow::Get(params.target));
+    AddWindowTree(params.target);
 }
 
 void AshDevToolsDOMAgent::OnWindowStackingChanged(aura::Window* window) {
-  RemoveWindowTree(WmWindow::Get(window), false);
-  AddWindowTree(WmWindow::Get(window));
+  RemoveWindowTree(window, false);
+  AddWindowTree(window);
 }
 
 void AshDevToolsDOMAgent::OnWindowBoundsChanged(aura::Window* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds) {
   for (auto& observer : observers_)
-    observer.OnWindowBoundsChanged(WmWindow::Get(window));
+    observer.OnWindowBoundsChanged(window);
 }
 
 void AshDevToolsDOMAgent::OnWillRemoveView(views::Widget* widget,
                                            views::View* view) {
   if (view == widget->GetRootView())
     RemoveViewTree(view, nullptr, true);
 }
 
 void AshDevToolsDOMAgent::OnWidgetBoundsChanged(views::Widget* widget,
                                                 const gfx::Rect& new_bounds) {
@@ skipping 15 matching lines @@
                                                views::View* view) {
   RemoveViewTree(view, parent, false);
   AddViewTree(view);
 }
 
 void AshDevToolsDOMAgent::OnViewBoundsChanged(views::View* view) {
   for (auto& observer : observers_)
     observer.OnViewBoundsChanged(view);
 }
 
-WmWindow* AshDevToolsDOMAgent::GetWindowFromNodeId(int nodeId) {
+aura::Window* AshDevToolsDOMAgent::GetWindowFromNodeId(int nodeId) {
   return node_id_to_window_map_.count(nodeId) ? node_id_to_window_map_[nodeId]
                                               : nullptr;
 }
 
 views::Widget* AshDevToolsDOMAgent::GetWidgetFromNodeId(int nodeId) {
   return node_id_to_widget_map_.count(nodeId) ? node_id_to_widget_map_[nodeId]
                                               : nullptr;
 }
 
 views::View* AshDevToolsDOMAgent::GetViewFromNodeId(int nodeId) {
   return node_id_to_view_map_.count(nodeId) ? node_id_to_view_map_[nodeId]
                                             : nullptr;
 }
 
-int AshDevToolsDOMAgent::GetNodeIdFromWindow(WmWindow* window) {
+int AshDevToolsDOMAgent::GetNodeIdFromWindow(aura::Window* window) {
   DCHECK(window_to_node_id_map_.count(window));
   return window_to_node_id_map_[window];
 }
 
 int AshDevToolsDOMAgent::GetNodeIdFromWidget(views::Widget* widget) {
   DCHECK(widget_to_node_id_map_.count(widget));
   return widget_to_node_id_map_[widget];
 }
 
 int AshDevToolsDOMAgent::GetNodeIdFromView(views::View* view) {
   DCHECK(view_to_node_id_map_.count(view));
   return view_to_node_id_map_[view];
 }
 
 void AshDevToolsDOMAgent::AddObserver(AshDevToolsDOMAgentObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void AshDevToolsDOMAgent::RemoveObserver(
     AshDevToolsDOMAgentObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::unique_ptr<ui::devtools::protocol::DOM::Node>
 AshDevToolsDOMAgent::BuildInitialTree() {
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
   for (aura::Window* window : Shell::GetAllRootWindows())
-    children->addItem(BuildTreeForWindow(WmWindow::Get(window)));
+    children->addItem(BuildTreeForWindow(window));
   return BuildNode("root", nullptr, std::move(children));
 }
 
 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow(
-    ash::WmWindow* window) {
+    aura::Window* window) {
   DCHECK(!window_to_node_id_map_.count(window));
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
-  views::Widget* widget = GetWidgetFromWmWindow(window);
+  views::Widget* widget = GetWidgetFromWindow(window);
   if (widget)
     children->addItem(BuildTreeForRootWidget(widget));
-  for (ash::WmWindow* child : window->GetChildren()) {
+  for (aura::Window* child : window->children()) {
     if (!IsHighlightingWindow(child))
       children->addItem(BuildTreeForWindow(child));
   }
 
   std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
       BuildNode("Window", GetAttributes(window), std::move(children));
-  if (!window->aura_window()->HasObserver(this))
-    window->aura_window()->AddObserver(this);
+  if (!window->HasObserver(this))
+    window->AddObserver(this);
   window_to_node_id_map_[window] = node->getNodeId();
   node_id_to_window_map_[node->getNodeId()] = window;
   return node;
 }
 
 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForRootWidget(
     views::Widget* widget) {
   DCHECK(!widget_to_node_id_map_.count(widget));
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
   children->addItem(BuildTreeForView(widget->GetRootView()));
@@ skipping 14 matching lines @@
     children->addItem(BuildTreeForView(view->child_at(i)));
   std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
       BuildNode("View", GetAttributes(view), std::move(children));
   if (!view->HasObserver(this))
     view->AddObserver(this);
   view_to_node_id_map_[view] = node->getNodeId();
   node_id_to_view_map_[node->getNodeId()] = view;
   return node;
 }
 
-void AshDevToolsDOMAgent::AddWindowTree(WmWindow* window) {
+void AshDevToolsDOMAgent::AddWindowTree(aura::Window* window) {
   if (IsHighlightingWindow(window))
     return;
 
-  DCHECK(window_to_node_id_map_.count(window->GetParent()));
-  WmWindow* prev_sibling = FindPreviousSibling(window);
+  DCHECK(window_to_node_id_map_.count(window->parent()));
+  aura::Window* prev_sibling = FindPreviousSibling(window);
   frontend()->childNodeInserted(
-      window_to_node_id_map_[window->GetParent()],
+      window_to_node_id_map_[window->parent()],
       prev_sibling ? window_to_node_id_map_[prev_sibling] : 0,
       BuildTreeForWindow(window));
 }
 
-void AshDevToolsDOMAgent::RemoveWindowTree(WmWindow* window,
+void AshDevToolsDOMAgent::RemoveWindowTree(aura::Window* window,
                                            bool remove_observer) {
   DCHECK(window);
   if (IsHighlightingWindow(window))
     return;
 
-  if (GetWidgetFromWmWindow(window))
-    RemoveWidgetTree(GetWidgetFromWmWindow(window), remove_observer);
+  if (GetWidgetFromWindow(window))
+    RemoveWidgetTree(GetWidgetFromWindow(window), remove_observer);
 
-  for (ash::WmWindow* child : window->GetChildren())
+  for (aura::Window* child : window->children())
     RemoveWindowTree(child, remove_observer);
 
   RemoveWindowNode(window, remove_observer);
 }
 
-void AshDevToolsDOMAgent::RemoveWindowNode(WmWindow* window,
+void AshDevToolsDOMAgent::RemoveWindowNode(aura::Window* window,
                                            bool remove_observer) {
   WindowToNodeIdMap::iterator window_to_node_id_it =
       window_to_node_id_map_.find(window);
   DCHECK(window_to_node_id_it != window_to_node_id_map_.end());
 
   int node_id = window_to_node_id_it->second;
-  int parent_id = GetNodeIdFromWindow(window->GetParent());
+  int parent_id = GetNodeIdFromWindow(window->parent());
 
   NodeIdToWindowMap::iterator node_id_to_window_it =
       node_id_to_window_map_.find(node_id);
   DCHECK(node_id_to_window_it != node_id_to_window_map_.end());
 
   if (remove_observer)
-    window->aura_window()->RemoveObserver(this);
+    window->RemoveObserver(this);
 
   node_id_to_window_map_.erase(node_id_to_window_it);
   window_to_node_id_map_.erase(window_to_node_id_it);
   frontend()->childNodeRemoved(parent_id, node_id);
 }
 
 void AshDevToolsDOMAgent::RemoveWidgetTree(views::Widget* widget,
                                            bool remove_observer) {
   DCHECK(widget);
   if (widget->GetRootView())
     RemoveViewTree(widget->GetRootView(), nullptr, remove_observer);
   RemoveWidgetNode(widget, remove_observer);
 }
 
 void AshDevToolsDOMAgent::RemoveWidgetNode(views::Widget* widget,
                                            bool remove_observer) {
   WidgetToNodeIdMap::iterator widget_to_node_id_it =
       widget_to_node_id_map_.find(widget);
   DCHECK(widget_to_node_id_it != widget_to_node_id_map_.end());
 
   int node_id = widget_to_node_id_it->second;
-  int parent_id = GetNodeIdFromWindow(WmWindow::Get(widget->GetNativeWindow()));
+  int parent_id = GetNodeIdFromWindow(widget->GetNativeWindow());
 
   if (remove_observer)
     widget->RemoveRemovalsObserver(this);
 
   NodeIdToWidgetMap::iterator node_id_to_widget_it =
       node_id_to_widget_map_.find(node_id);
   DCHECK(node_id_to_widget_it != node_id_to_widget_map_.end());
 
   widget_to_node_id_map_.erase(widget_to_node_id_it);
   node_id_to_widget_map_.erase(node_id_to_widget_it);
@@ skipping 39 matching lines @@
       node_id_to_view_map_.find(node_id);
   DCHECK(node_id_to_view_it != node_id_to_view_map_.end());
 
   view_to_node_id_map_.erase(view_to_node_id_it);
   node_id_to_view_map_.erase(node_id_to_view_it);
   frontend()->childNodeRemoved(parent_id, node_id);
 }
 
 void AshDevToolsDOMAgent::RemoveObservers() {
   for (auto& pair : window_to_node_id_map_)
-    pair.first->aura_window()->RemoveObserver(this);
+    pair.first->RemoveObserver(this);
   for (auto& pair : widget_to_node_id_map_)
     pair.first->RemoveRemovalsObserver(this);
   for (auto& pair : view_to_node_id_map_)
     pair.first->RemoveObserver(this);
 }
 
 void AshDevToolsDOMAgent::Reset() {
   RemoveObservers();
   widget_for_highlighting_.reset();
   window_to_node_id_map_.clear();
   widget_to_node_id_map_.clear();
   view_to_node_id_map_.clear();
   node_id_to_window_map_.clear();
   node_id_to_widget_map_.clear();
   node_id_to_view_map_.clear();
   node_ids = 1;
 }
 
 AshDevToolsDOMAgent::WindowAndBoundsPair
 AshDevToolsDOMAgent::GetNodeWindowAndBounds(int node_id) {
-  WmWindow* window = GetWindowFromNodeId(node_id);
+  aura::Window* window = GetWindowFromNodeId(node_id);
   if (window)
     return std::make_pair(window, window->GetBoundsInScreen());
 
   views::Widget* widget = GetWidgetFromNodeId(node_id);
   if (widget) {
-    return std::make_pair(WmWindow::Get(widget->GetNativeWindow()),
+    return std::make_pair(widget->GetNativeWindow(),
                           widget->GetWindowBoundsInScreen());
   }
 
   views::View* view = GetViewFromNodeId(node_id);
   if (view) {
     gfx::Rect bounds = view->GetBoundsInScreen();
-    return std::make_pair(WmWindow::Get(view->GetWidget()->GetNativeWindow()),
-                          bounds);
+    return std::make_pair(view->GetWidget()->GetNativeWindow(), bounds);
   }
 
   return std::make_pair(nullptr, gfx::Rect());
 }
 
 void AshDevToolsDOMAgent::InitializeHighlightingWidget() {
   DCHECK(!widget_for_highlighting_);
   widget_for_highlighting_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
@@ skipping 12 matching lines @@
 
 void AshDevToolsDOMAgent::UpdateHighlight(
     const WindowAndBoundsPair& window_and_bounds,
     SkColor background,
     SkColor border) {
   constexpr int kBorderThickness = 1;
   views::View* root_view = widget_for_highlighting_->GetRootView();
   root_view->SetBorder(views::CreateSolidBorder(kBorderThickness, border));
   root_view->set_background(
       views::Background::CreateSolidBackground(background));
-  WmWindow::Get(widget_for_highlighting_->GetNativeWindow())
-      ->SetBoundsInScreen(window_and_bounds.second,
-                          window_and_bounds.first->GetDisplayNearestWindow());
+  display::Display display =
+      display::Screen::GetScreen()->GetDisplayNearestWindow(
+          window_and_bounds.first);
+  widget_for_highlighting_->GetNativeWindow()->SetBoundsInScreen(
+      window_and_bounds.second, display);
 }
 
 ui::devtools::protocol::Response AshDevToolsDOMAgent::HighlightNode(
     std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig>
         highlight_config,
     int node_id) {
   if (!widget_for_highlighting_)
     InitializeHighlightingWidget();
 
   WindowAndBoundsPair window_and_bounds(GetNodeWindowAndBounds(node_id));
 
   if (!window_and_bounds.first)
     return ui::devtools::protocol::Response::Error(
         "No node found with that id");
 
   SkColor border_color =
       RGBAToSkColor(highlight_config->getBorderColor(nullptr));
   SkColor content_color =
       RGBAToSkColor(highlight_config->getContentColor(nullptr));
   UpdateHighlight(window_and_bounds, content_color, border_color);
 
   if (!widget_for_highlighting_->IsVisible())
     widget_for_highlighting_->Show();
 
   return ui::devtools::protocol::Response::OK();
 }
 
-bool AshDevToolsDOMAgent::IsHighlightingWindow(WmWindow* window) {
+bool AshDevToolsDOMAgent::IsHighlightingWindow(aura::Window* window) {
   return widget_for_highlighting_ &&
-         GetWidgetFromWmWindow(window) == widget_for_highlighting_.get();
+         GetWidgetFromWindow(window) == widget_for_highlighting_.get();
 }
 
 }  // namespace devtools
 }  // namespace ash