Show corresponding window/widget/view in UIElement tree when clicking on a UI element.

components/ui_devtools/views/ui_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 "components/ui_devtools/views/ui_devtools_dom_agent.h"
 
 #include "components/ui_devtools/devtools_server.h"
+#include "components/ui_devtools/views/ui_devtools_overlay_agent.h"
 #include "components/ui_devtools/views/ui_element.h"
 #include "components/ui_devtools/views/view_element.h"
 #include "components/ui_devtools/views/widget_element.h"
 #include "components/ui_devtools/views/window_element.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
+#include "ui/views/pointer_watcher.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ui_devtools {
 namespace {
 
 using namespace ui_devtools::protocol;
 // TODO(mhashmi): Make ids reusable
 
 std::unique_ptr<DOM::Node> BuildNode(
     const std::string& name,
     std::unique_ptr<Array<std::string>> attributes,
     std::unique_ptr<Array<DOM::Node>> children,
     int node_ids) {
   constexpr int kDomElementNodeType = 1;
   std::unique_ptr<DOM::Node> node = DOM::Node::create()
                                         .setNodeId(node_ids)
+                                        .setBackendNodeId(node_ids)
                                         .setNodeName(name)
                                         .setNodeType(kDomElementNodeType)
                                         .setAttributes(std::move(attributes))
                                         .build();
   node->setChildNodeCount(static_cast<int>(children->length()));
   node->setChildren(std::move(children));
   return node;
 }
 
 // TODO(thanhph): Move this function to UIElement::GetAttributes().
@@ skipping 49 matching lines @@
 }
 
 std::unique_ptr<DOM::Node> BuildDomNodeFromUIElement(UIElement* root) {
   std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
   for (auto* it : root->children())
     children->addItem(BuildDomNodeFromUIElement(it));
 
   constexpr int kDomElementNodeType = 1;
   std::unique_ptr<DOM::Node> node = DOM::Node::create()
                                         .setNodeId(root->node_id())
+                                        .setBackendNodeId(root->node_id())
                                         .setNodeName(root->GetTypeName())
                                         .setNodeType(kDomElementNodeType)
                                         .setAttributes(GetAttributes(root))
                                         .build();
   node->setChildNodeCount(static_cast<int>(children->length()));
   node->setChildren(std::move(children));
   return node;
 }
 
+int FindUIElementIdForView(UIElement* root, views::View* element) {
+  if (root->type() == UIElementType::VIEW &&
+      UIElement::GetBackingElement<views::View, ViewElement>(root) == element)
+    return root->node_id();
+
+  for (auto* child : root->children()) {
+    int ui_element_id = FindUIElementIdForView(child, element);
+    if (ui_element_id)
+      return ui_element_id;
+  }
+  return 0;
+}
+
+int FindUIElementIdForWidget(UIElement* root, views::Widget* element) {
+  if (root->type() == UIElementType::WIDGET &&
+      UIElement::GetBackingElement<views::Widget, WidgetElement>(root) ==
+          element)
+    return root->node_id();
+
+  for (auto* child : root->children()) {
+    int ui_element_id = FindUIElementIdForWidget(child, element);
+    if (ui_element_id)
+      return ui_element_id;
+  }
+  return 0;
+}
+
+int FindUIElementIdForWindow(UIElement* root, aura::Window* element) {
+  if (root->type() == UIElementType::WINDOW &&
+      UIElement::GetBackingElement<aura::Window, WindowElement>(root) ==
+          element)
+    return root->node_id();
+
+  for (auto* child : root->children()) {
+    int ui_element_id = FindUIElementIdForWindow(child, element);
+    if (ui_element_id)
+      return ui_element_id;
+  }
+  return 0;
+}
+
 }  // namespace
 
 UIDevToolsDOMAgent::UIDevToolsDOMAgent() : is_building_tree_(false) {
   aura::Env::GetInstance()->AddObserver(this);
 }
 
 UIDevToolsDOMAgent::~UIDevToolsDOMAgent() {
   aura::Env::GetInstance()->RemoveObserver(this);
   Reset();
 }
 
 ui_devtools::protocol::Response UIDevToolsDOMAgent::disable() {
   Reset();
   return ui_devtools::protocol::Response::OK();
 }
 
 ui_devtools::protocol::Response UIDevToolsDOMAgent::getDocument(
     std::unique_ptr<ui_devtools::protocol::DOM::Node>* out_root) {
   *out_root = BuildInitialTree();
   return ui_devtools::protocol::Response::OK();
 }
 
-ui_devtools::protocol::Response UIDevToolsDOMAgent::highlightNode(
-    std::unique_ptr<ui_devtools::protocol::DOM::HighlightConfig>
-        highlight_config,
-    ui_devtools::protocol::Maybe<int> node_id) {
-  return HighlightNode(std::move(highlight_config), node_id.fromJust());
-}
-
 ui_devtools::protocol::Response UIDevToolsDOMAgent::hideHighlight() {
   if (layer_for_highlighting_ && layer_for_highlighting_->visible())
     layer_for_highlighting_->SetVisible(false);
   return ui_devtools::protocol::Response::OK();
 }
 
+ui_devtools::protocol::Response
+UIDevToolsDOMAgent::pushNodesByBackendIdsToFrontend(
+    std::unique_ptr<protocol::Array<int>> backend_node_ids,
+    std::unique_ptr<protocol::Array<int>>* result) {
+  *result = protocol::Array<int>::create();
+  for (size_t index = 0; index < backend_node_ids->length(); ++index)
+    (*result)->addItem(backend_node_ids->get(index));
+  return ui_devtools::protocol::Response::OK();
+}
+
+ui_devtools::protocol::Response UIDevToolsDOMAgent::setInspectedNode(
+    int node_id) {
+  return ui_devtools::protocol::Response::OK();
+}
+
 void UIDevToolsDOMAgent::OnUIElementAdded(UIElement* parent, UIElement* child) {
   // When parent is null, only need to update |node_id_to_ui_element_|.
   if (!parent) {
     node_id_to_ui_element_[child->node_id()] = child;
     return;
   }
   // If tree is being built, don't add child to dom tree again.
   if (is_building_tree_)
     return;
   DCHECK(node_id_to_ui_element_.count(parent->node_id()));
@@ skipping 36 matching lines @@
 }
 
 void UIDevToolsDOMAgent::RemoveObserver(UIDevToolsDOMAgentObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 UIElement* UIDevToolsDOMAgent::GetElementFromNodeId(int node_id) {
   return node_id_to_ui_element_[node_id];
 }
 
+ui_devtools::protocol::Response UIDevToolsDOMAgent::HighlightNode(
+    std::unique_ptr<ui_devtools::protocol::Overlay::HighlightConfig>
+        highlight_config,
+    int node_id) {
+  if (!layer_for_highlighting_) {
+    layer_for_highlighting_.reset(
+        new ui::Layer(ui::LayerType::LAYER_SOLID_COLOR));
+    layer_for_highlighting_->set_name("HighlightingLayer");
+  }
+
+  std::pair<aura::Window*, gfx::Rect> window_and_bounds =
+      node_id_to_ui_element_.count(node_id)
+          ? node_id_to_ui_element_[node_id]->GetNodeWindowAndBounds()
+          : std::make_pair<aura::Window*, gfx::Rect>(nullptr, gfx::Rect());
+
+  if (!window_and_bounds.first) {
+    return ui_devtools::protocol::Response::Error("No node found with that id");
+  }
+  SkColor content_color =
+      RGBAToSkColor(highlight_config->getContentColor(nullptr));
+  UpdateHighlight(window_and_bounds, content_color);
+
+  if (!layer_for_highlighting_->visible())
+    layer_for_highlighting_->SetVisible(true);
+
+  return ui_devtools::protocol::Response::OK();
+}
+
+void UIDevToolsDOMAgent::FindElementByEventHandler(const gfx::Point& p,
+                                                   int* element_id) {
+  for (auto* element_window : window_element_root_->children()) {
+    aura::Window* window =
+        UIElement::GetBackingElement<aura::Window, WindowElement>(
+            element_window);
+    if (!window->bounds().Contains(p))
+      return;
+    aura::Window* point_window = window->GetEventHandlerForPoint(p);
+
+    if (point_window) {
+      views::Widget* widget =
+          views::Widget::GetWidgetForNativeWindow(point_window);
+
+      if (widget) {
+        views::View* view = widget->GetRootView();
+
+        if (view) {
+          gfx::Point p_inside(p);
+          aura::Window::ConvertPointToTarget(window, point_window, &p_inside);
+          views::View* point_view = view->GetEventHandlerForPoint(p_inside);
+
+          DCHECK(point_view);
+          *element_id = FindUIElementIdForView(element_window, point_view);
+        } else {
+          *element_id = FindUIElementIdForWidget(element_window, widget);
+        }
+      } else {
+        *element_id = FindUIElementIdForWindow(element_window, point_window);
+      }
+    }
+  }
+}
+
 void UIDevToolsDOMAgent::OnHostInitialized(aura::WindowTreeHost* host) {
   root_windows_.push_back(host->window());
 }
 
 void UIDevToolsDOMAgent::OnNodeBoundsChanged(int node_id) {
   for (auto& observer : observers_)
     observer.OnNodeBoundsChanged(node_id);
 }
 
 std::unique_ptr<ui_devtools::protocol::DOM::Node>
@@ skipping 128 matching lines @@
   aura::client::ScreenPositionClient* screen_position_client =
       aura::client::GetScreenPositionClient(root);
 
   gfx::Rect bounds(window_and_bounds.second);
   gfx::Point origin = bounds.origin();
   screen_position_client->ConvertPointFromScreen(root, &origin);
   bounds.set_origin(origin);
   layer_for_highlighting_->SetBounds(bounds);
 }
 
-ui_devtools::protocol::Response UIDevToolsDOMAgent::HighlightNode(
-    std::unique_ptr<ui_devtools::protocol::DOM::HighlightConfig>
-        highlight_config,
-    int node_id) {
-  if (!layer_for_highlighting_) {
-    layer_for_highlighting_.reset(
-        new ui::Layer(ui::LayerType::LAYER_SOLID_COLOR));
-    layer_for_highlighting_->set_name("HighlightingLayer");
-  }
-
-  std::pair<aura::Window*, gfx::Rect> window_and_bounds =
-      node_id_to_ui_element_.count(node_id)
-          ? node_id_to_ui_element_[node_id]->GetNodeWindowAndBounds()
-          : std::make_pair<aura::Window*, gfx::Rect>(nullptr, gfx::Rect());
-
-  if (!window_and_bounds.first) {
-    return ui_devtools::protocol::Response::Error("No node found with that id");
-  }
-  SkColor content_color =
-      RGBAToSkColor(highlight_config->getContentColor(nullptr));
-  UpdateHighlight(window_and_bounds, content_color);
-
-  if (!layer_for_highlighting_->visible())
-    layer_for_highlighting_->SetVisible(true);
-
-  return ui_devtools::protocol::Response::OK();
-}
-
 }  // namespace ui_devtools