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(view_index >= 0);

[sadrul, 2016/11/25 18:27:48]

DCHECK_GE

[Sarmad Hashmi, 2016/11/25 23:24:34]

Done.

+  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();
 }
 
 // DOM::Backend implementation
 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) {
@@ skipping 26 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);
 }
 
+// views::WidgetRemovalsObserver implementation
+void AshDevToolsDOMAgent::OnWillRemoveView(views::Widget* widget,
+                                           views::View* view) {
+  if (view == widget->GetRootView())
+    RemoveViewTree(view, nullptr, true);
+}
+
+// views::ViewObserver implementation
+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))

[sadrul, 2016/11/25 18:27:48]

Do we need to check here? If this ever returns true, that would mean the DCHECK
above in line 217 would trip, right?

[Sarmad Hashmi, 2016/11/25 23:24:34]

Not necessarily. If this returns true, then that means |remove_observer| was
false when calling the remove methods. This is so that when methods like
OnWindowStackingChanged or OnChildViewReordered are called, we don't remove and
add the observer in the callbacks (which would result in endless calls to the
observer).

So, widget->HasRemovalsObserver(this) or (view|window)->HasObserver(this) would
return true if we ever have a case where the node is being removed and added
within the same callback (observer method).

+    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))

[sadrul, 2016/11/25 18:27:48]

ditto

[Sarmad Hashmi, 2016/11/25 23:24:34]

Same as above.

+    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