Hook up views/widgets to AshDevToolsDOMAgent

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_lookup.h"
 #include "ash/common/wm_window.h"
 #include "components/ui_devtools/devtools_server.h"
 
@@ skipping 48 matching lines @@
 
 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);
 }
 
+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)) {
+      view_index = i;
+      break;
+    }
+  }
+  DCHECK_GE(view_index, 0);
+  return view_index == 0 ? nullptr : parent->child_at(view_index - 1);
+}
+
 }  // namespace
 
 AshDevToolsDOMAgent::AshDevToolsDOMAgent(ash::WmShell* shell) : shell_(shell) {
   DCHECK(shell_);
 }
 
 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() {
-  RemoveObserverFromAllWindows();
+  RemoveObservers();
 }
 
 ui::devtools::protocol::Response AshDevToolsDOMAgent::disable() {
   Reset();
   return ui::devtools::protocol::Response::OK();
 }
 
 ui::devtools::protocol::Response AshDevToolsDOMAgent::getDocument(
     std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) {
   *out_root = BuildInitialTree();
@@ skipping 24 matching lines @@
   // the window is only added here.
   if (window == params.new_parent)
     AddWindowTree(params.target);
 }
 
 void AshDevToolsDOMAgent::OnWindowStackingChanged(WmWindow* window) {
   RemoveWindowTree(window, false);
   AddWindowTree(window);
 }
 
+void AshDevToolsDOMAgent::OnWillRemoveView(views::Widget* widget,
+                                           views::View* view) {
+  if (view == widget->GetRootView())
+    RemoveViewTree(view, nullptr, true);
+}
+
+void AshDevToolsDOMAgent::OnChildViewRemoved(views::View* view,
+                                             views::View* parent) {
+  RemoveViewTree(view, parent, true);
+}
+
+void AshDevToolsDOMAgent::OnChildViewAdded(views::View* view) {
+  AddViewTree(view);
+}
+
+void AshDevToolsDOMAgent::OnChildViewReordered(views::View* view) {
+  RemoveViewTree(view, view->parent(), false);
+  AddViewTree(view);
+}
+
 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;
 }
 
@@ skipping 44 matching lines @@
   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()));
   std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
       BuildNode("Widget", GetAttributes(widget), std::move(children));
-  // TODO(mhashmi): Add WidgetRemovalsObserver here
+  if (!widget->HasRemovalsObserver(this))
+    widget->AddRemovalsObserver(this);
   widget_to_node_id_map_[widget] = node->getNodeId();
   node_id_to_widget_map_[node->getNodeId()] = widget;
   return node;
 }
 
 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForView(
     views::View* view) {
   DCHECK(!view_to_node_id_map_.count(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));
-  // TODO(mhashmi): Add ViewObserver here
+  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) {
   DCHECK(window_to_node_id_map_.count(window->GetParent()));
   WmWindow* prev_sibling = FindPreviousSibling(window);
   frontend()->childNodeInserted(
       window_to_node_id_map_[window->GetParent()],
@@ skipping 21 matching lines @@
 
   int node_id = window_to_node_id_it->second;
   int parent_id = GetNodeIdFromWindow(window->GetParent());
 
   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->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(WmLookup::Get()->GetWindowForWidget(widget));
 
-  // TODO(mhashmi): Add WidgetRemovalsObserver and remove it here based on
-  // |remove_observer|
+  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);
   frontend()->childNodeRemoved(parent_id, node_id);
 }
 
+void AshDevToolsDOMAgent::AddViewTree(views::View* view) {
+  DCHECK(view_to_node_id_map_.count(view->parent()));
+  views::View* prev_sibling = FindPreviousSibling(view);
+  frontend()->childNodeInserted(
+      view_to_node_id_map_[view->parent()],
+      prev_sibling ? view_to_node_id_map_[prev_sibling] : 0,
+      BuildTreeForView(view));
+}
+
 void AshDevToolsDOMAgent::RemoveViewTree(views::View* view,
                                          views::View* parent,
                                          bool remove_observer) {
   DCHECK(view);
   for (int i = 0, count = view->child_count(); i < count; i++)
     RemoveViewTree(view->child_at(i), view, remove_observer);
   RemoveViewNode(view, parent, remove_observer);
 }
 
 void AshDevToolsDOMAgent::RemoveViewNode(views::View* view,
                                          views::View* parent,
                                          bool remove_observer) {
   ViewToNodeIdMap::iterator view_to_node_id_it =
       view_to_node_id_map_.find(view);
   DCHECK(view_to_node_id_it != view_to_node_id_map_.end());
 
   int node_id = view_to_node_id_it->second;
   int parent_id = 0;
   if (parent)
     parent_id = GetNodeIdFromView(parent);
   else  // views::RootView
     parent_id = GetNodeIdFromWidget(view->GetWidget());
 
-  // TODO(mhashmi): Add ViewObserver and remove it here based on
-  // |remove_observer|
+  if (remove_observer)
+    view->RemoveObserver(this);
 
   NodeIdToViewMap::iterator node_id_to_view_it =
       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::RemoveObserverFromAllWindows() {
+void AshDevToolsDOMAgent::RemoveObservers() {
   for (auto& pair : window_to_node_id_map_)
     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() {
-  RemoveObserverFromAllWindows();
+  RemoveObservers();
   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;
 }
 
 }  // namespace devtools
 }  // namespace ash