Push updates to inspector when windows are added, destroyed or reorganized

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,
     std::unique_ptr<Array<std::string>> attributes,
     std::unique_ptr<Array<DOM::Node>> children) {
-  static DOM::NodeId node_ids = 0;
   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;
@@ skipping 31 matching lines @@
   }
   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));
 }
 
-std::unique_ptr<DOM::Node> BuildTreeForWindow(ash::WmWindow* window) {
+}  // namespace
+
+AshDevToolsDOMAgent::AshDevToolsDOMAgent(ash::WmShell* shell) : shell_(shell) {
+  DCHECK(shell_);
+}
+
+AshDevToolsDOMAgent::~AshDevToolsDOMAgent() {
+  RemoveObserverFromRootWindows();
+}
+
+void AshDevToolsDOMAgent::disable(ui::devtools::protocol::ErrorString* error) {
+  RemoveObserverFromRootWindows();
+}
+
+void AshDevToolsDOMAgent::getDocument(
+    ui::devtools::protocol::ErrorString* error,
+    std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) {
+  Reset();
+  *out_root = BuildInitialTree();
+}
+
+void AshDevToolsDOMAgent::OnWindowTreeChanging(WmWindow* window,

[sadrul, 2016/11/02 02:04:36]

I don't think this gets called if sibling windows are reordered. For example, if
you have two browser windows open, and you click on one to activate it, then
click on the other to activate, that changes the order of the two windows. Is
that reflected in devtools? If not, it may be necessary to also override
OnWindowStackingChanged().

[Sarmad Hashmi, 2016/11/03 01:42:17]

Done.

+                                               const TreeChangeParams& params) {
+  // If there is an old_parent + new_parent, then this window is being moved
+  // which requires a remove followed by an add. If only old_parent exists, then
+  // this is being destroyed, only remove is called. Finally, if only new_parent
+  // exists, then this is being created so only add is called.
+  if (params.old_parent)
+    RemoveWindowNode(params.target);
+  if (params.new_parent)
+    AddWindowNode(params.target, params.new_parent);
+}
+
+std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow(
+    ash::WmWindow* window) {
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
   for (ash::WmWindow* child : window->GetChildren()) {
     children->addItem(BuildTreeForWindow(child));
     views::Widget* widget = child->GetInternalWidget();
     if (widget)
       children->addItem(BuildTreeForRootWidget(widget));
   }
-  return BuildNode("Window", GetAttributes(window), std::move(children));
+  std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
+      BuildNode("Window", GetAttributes(window), std::move(children));
+  window_to_node_id_map_[window] = node->getNodeId();
+  return node;
 }
 
-}  // namespace
-
-AshDevToolsDOMAgent::AshDevToolsDOMAgent(ash::WmShell* shell) : shell_(shell) {
-  DCHECK(shell_);
-}
-
-AshDevToolsDOMAgent::~AshDevToolsDOMAgent() {}
-
 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));
 }
 
-void AshDevToolsDOMAgent::getDocument(
-    ui::devtools::protocol::ErrorString* error,
-    std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) {
-  *out_root = BuildInitialTree();
+void AshDevToolsDOMAgent::AddWindowNode(WmWindow* window, WmWindow* parent) {
+  frontend()->childNodeInserted(window_to_node_id_map_[parent], 0,

[sadrul, 2016/11/02 02:04:36]

Should 'prev_sibling' be correctly computed? (e.g. you would look at
parent->children() and figure out what the prev-sibling window is?) Maybe this
needs to happen in OnWindowTreeChanged() callback (instead of
OnWindowTreeChanging())?

[Sarmad Hashmi, 2016/11/03 01:42:17]

Done.

+                                BuildTreeForWindow(window));
+}
+
+void AshDevToolsDOMAgent::RemoveWindowNode(WmWindow* window) {
+  WindowToNodeIdMap::iterator it = window_to_node_id_map_.find(window);
+  DCHECK(it != window_to_node_id_map_.end());
+
+  int node_id = it->second;
+  int parent_id =
+      window->GetParent() ? window_to_node_id_map_[window->GetParent()] : 0;

[sadrul, 2016/11/02 02:04:36]

window->GetParent() should never be null here, right? It is getting called from
OnWindowTreeChanging(), only when params.old_parent is non-null. That would
imply window->GetParent() should also be non-null? Can this be a DCHECK()?

[Sarmad Hashmi, 2016/11/03 01:42:18]

Discussed in-person. It can be null for root windows.

+
+  window_to_node_id_map_.erase(it);
+  frontend()->childNodeRemoved(parent_id, node_id);
+}
+
+void AshDevToolsDOMAgent::AddObserverToRootWindows() {
+  // TODO(mhashmi): Use ShellObserver events to add observers to new root
+  // windows
+  for (ash::WmWindow* window : shell_->GetAllRootWindows()) {
+    window->AddObserver(this);

[sadrul, 2016/11/02 02:04:36]

No {}

[Sarmad Hashmi, 2016/11/03 01:42:17]

Done.

+  }
+}
+
+void AshDevToolsDOMAgent::RemoveObserverFromRootWindows() {
+  for (ash::WmWindow* window : shell_->GetAllRootWindows()) {

[sadrul, 2016/11/02 02:04:36]

ditto

[Sarmad Hashmi, 2016/11/03 01:42:18]

Done.

+    window->RemoveObserver(this);
+  }
+}
+
+void AshDevToolsDOMAgent::Reset() {
+  AddObserverToRootWindows();
+  window_to_node_id_map_.clear();
+  node_ids = 1;
 }
 
 }  // namespace devtools
 }  // namespace ash