Add CSS agent for various window/widget/view attributes in devtools

ash/common/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/common/devtools/ash_devtools_dom_agent.h"
 
 #include "ash/common/wm_window.h"
 #include "components/ui_devtools/devtools_server.h"
-#include "ui/views/view.h"
-#include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace devtools {
 
 namespace {
 using namespace ui::devtools::protocol;
 DOM::NodeId node_ids = 1;
 
 std::unique_ptr<DOM::Node> BuildNode(
     const std::string& name,
@@ skipping 29 matching lines @@
   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;
 }
 
-std::unique_ptr<DOM::Node> BuildTreeForView(views::View* view) {
-  std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
-  for (int i = 0, count = view->child_count(); i < count; i++) {
-    children->addItem(BuildTreeForView(view->child_at(i)));
-  }
-  return BuildNode("View", GetAttributes(view), std::move(children));
-}
-
-std::unique_ptr<DOM::Node> BuildTreeForRootWidget(views::Widget* widget) {
-  std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
-  children->addItem(BuildTreeForView(widget->GetRootView()));
-  return BuildNode("Widget", GetAttributes(widget), std::move(children));
-}
 
 WmWindow* FindPreviousSibling(WmWindow* window) {
   std::vector<WmWindow*> siblings = window->GetParent()->GetChildren();
   std::vector<WmWindow*>::iterator 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);
 }
 
@@ skipping 41 matching lines @@
   // the window is only added here.
   if (window == params.new_parent)
     AddWindowNode(params.target);
 }
 
 void AshDevToolsDOMAgent::OnWindowStackingChanged(WmWindow* window) {
   RemoveWindowNode(window, window->GetParent());
   AddWindowNode(window);
 }
 
+WmWindow* 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;
+}
+
+std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForView(
+    views::View* view) {
+  std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
+  for (int i = 0, count = view->child_count(); i < count; i++) {
+    children->addItem(BuildTreeForView(view->child_at(i)));
+  }
+  std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
+      BuildNode("View", GetAttributes(view), std::move(children));
+  node_id_to_view_map_[node->getNodeId()] = view;
+  return node;
+}
+
+std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForRootWidget(
+    views::Widget* widget) {
+  std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
+  children->addItem(BuildTreeForView(widget->GetRootView()));
+  std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
+      BuildNode("Widget", GetAttributes(widget), std::move(children));
+  node_id_to_widget_map_[node->getNodeId()] = widget;
+  return node;
+}
+
 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow(
     ash::WmWindow* window) {
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
   views::Widget* widget = window->GetInternalWidget();
   if (widget)
     children->addItem(BuildTreeForRootWidget(widget));
   for (ash::WmWindow* child : window->GetChildren()) {
     children->addItem(BuildTreeForWindow(child));
   }
   std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
       BuildNode("Window", GetAttributes(window), std::move(children));
   // Only add as observer if window is not in map
   if (!window_to_node_id_map_.count(window))
     window->AddObserver(this);
   window_to_node_id_map_[window] = node->getNodeId();
+  node_id_to_window_map_[node->getNodeId()] = window;
   return node;
 }
 
 std::unique_ptr<ui::devtools::protocol::DOM::Node>
 AshDevToolsDOMAgent::BuildInitialTree() {
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
   for (ash::WmWindow* window : shell_->GetAllRootWindows()) {
     children->addItem(BuildTreeForWindow(window));
   }
   return BuildNode("root", nullptr, std::move(children));
@@ skipping 15 matching lines @@
   DCHECK(it != window_to_node_id_map_.end());
 
   int node_id = it->second;
   int parent_id = 0;
   if (window != window->GetRootWindow()) {
     DCHECK(old_parent);
     DCHECK(window_to_node_id_map_.count(old_parent));
     parent_id = window_to_node_id_map_[old_parent];
   }
 
   window_to_node_id_map_.erase(it);

[sadrul, 2016/11/09 16:47:46]

Remove node_id from node_id_to_window_map_?

Should this also go find window->GetInternalWidget(), and remove from
node_id_to_widget_map_, and node_id_to_view_map_ too? (i.e. a reverse of
BuildTreeForWindow())

[Sarmad Hashmi, 2016/11/09 20:51:38]

Yes! Done. I'm not doing the removal of views in this CL because it'll crash
unless we add observers (for view adding/removing) so that newly added views are
mapped and can safely be removed. Same with widgets, but that doesn't cause a
crash because you can't have a widget without a window being created.

   frontend()->childNodeRemoved(parent_id, node_id);
 }
 
 void AshDevToolsDOMAgent::RemoveObserverFromAllWindows() {
   for (auto& pair : window_to_node_id_map_)
     pair.first->RemoveObserver(this);
 }
 
 void AshDevToolsDOMAgent::Reset() {
   RemoveObserverFromAllWindows();
   window_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;
 }
 
 }  // namespace devtools
 }  // namespace ash