Add hovering feature 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_root_window_controller.h"
 #include "ash/common/wm_window.h"
+#include "ash/public/cpp/shell_window_ids.h"
 #include "components/ui_devtools/devtools_server.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "ui/display/display.h"
+#include "ui/views/background.h"
+#include "ui/views/border.h"
 
 namespace ash {
 namespace devtools {
 
 namespace {
 using namespace ui::devtools::protocol;
 // TODO(mhashmi): Make ids reusable
 DOM::NodeId node_ids = 1;
 
 std::unique_ptr<DOM::Node> BuildNode(
@@ skipping 52 matching lines @@
   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);
 }
 
+SkColor RGBAToSkColor(DOM::RGBA* rgba) {
+  if (!rgba)
+    return SkColorSetARGB(0, 0, 0, 0);
+  // Default alpha value is 0 (not visibile) and need to convert alpha decimal
+  // percentage value to hex
+  return SkColorSetARGB(rgba->getA(0) * 255, rgba->getR(), rgba->getG(),
+                        rgba->getB());

[sadrul, 2016/12/06 20:48:58]

Should we sanity check these values?

[Sarmad Hashmi, 2016/12/06 22:54:34]

Done.

+}
+
 }  // namespace
-
-AshDevToolsDOMAgent::AshDevToolsDOMAgent(ash::WmShell* shell) : shell_(shell) {
+AshDevToolsDOMAgent::AshDevToolsDOMAgent(
+    ash::WmShell* shell,
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
+    : main_thread_task_runner_(main_thread_task_runner), shell_(shell) {
   DCHECK(shell_);
+  DCHECK(main_thread_task_runner_);
 }
 
 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() {
   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();
   return ui::devtools::protocol::Response::OK();
 }
 
+ui::devtools::protocol::Response AshDevToolsDOMAgent::highlightNode(
+    std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig>
+        highlight_config,
+    ui::devtools::protocol::Maybe<int> node_id) {
+  main_thread_task_runner_->PostTask(

[sadrul, 2016/12/06 20:48:59]

Why do you need to PostTask()?

[Sarmad Hashmi, 2016/12/06 22:54:34]

Removed, as discussed.

+      FROM_HERE,
+      base::Bind(&AshDevToolsDOMAgent::HighlightNode, base::Unretained(this),
+                 base::Passed(std::move(highlight_config)),
+                 node_id.fromJust()));
+  return ui::devtools::protocol::Response::OK();
+}
+
+ui::devtools::protocol::Response AshDevToolsDOMAgent::hideHighlight() {
+  if (widget_for_highlighting_ && widget_for_highlighting_->IsVisible()) {
+    main_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&views::Widget::Hide,
+                   base::Unretained(widget_for_highlighting_.get())));
+  }
+  return ui::devtools::protocol::Response::OK();
+}
+
 // Handles removing windows.
 void AshDevToolsDOMAgent::OnWindowTreeChanging(WmWindow* window,
                                                const TreeChangeParams& params) {
   // Only trigger this when window == params.old_parent.
   // Only removals are handled here. Removing a node can occur as a result of
   // reorganizing a window or just destroying it. OnWindowTreeChanged
   // is only called if there is a new_parent. The only case this method isn't
   // called is when adding a node because old_parent is then null.
   // Finally, We only trigger this  0 or 1 times as an old_parent will
   // either exist and only call this callback once, or not at all.
@@ skipping 103 matching lines @@
   return BuildNode("root", nullptr, std::move(children));
 }
 
 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow(
     ash::WmWindow* window) {
   DCHECK(!window_to_node_id_map_.count(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));
+  for (ash::WmWindow* child : window->GetChildren()) {
+    if (!IsHighlightingWindow(child))
+      children->addItem(BuildTreeForWindow(child));
+  }
 
   std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
       BuildNode("Window", GetAttributes(window), std::move(children));
   if (!window->HasObserver(this))
     window->AddObserver(this);
   window_to_node_id_map_[window] = node->getNodeId();
   node_id_to_window_map_[node->getNodeId()] = window;
   return node;
 }
 
@@ skipping 20 matching lines @@
   std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
       BuildNode("View", GetAttributes(view), std::move(children));
   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) {
+  if (IsHighlightingWindow(window))
+    return;
+
   DCHECK(window_to_node_id_map_.count(window->GetParent()));
   WmWindow* prev_sibling = FindPreviousSibling(window);
   frontend()->childNodeInserted(
       window_to_node_id_map_[window->GetParent()],
       prev_sibling ? window_to_node_id_map_[prev_sibling] : 0,
       BuildTreeForWindow(window));
 }
 
 void AshDevToolsDOMAgent::RemoveWindowTree(WmWindow* window,
                                            bool remove_observer) {
   DCHECK(window);
+  if (IsHighlightingWindow(window))
+    return;
+
   if (window->GetInternalWidget())
     RemoveWidgetTree(window->GetInternalWidget(), remove_observer);
 
   for (ash::WmWindow* child : window->GetChildren())
     RemoveWindowTree(child, remove_observer);
 
   RemoveWindowNode(window, remove_observer);
 }
 
 void AshDevToolsDOMAgent::RemoveWindowNode(WmWindow* window,
@@ skipping 84 matching lines @@
 
   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::DestroyHighlightingWidget() {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
+  widget_for_highlighting_.reset();
+}
+
 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() {
   RemoveObservers();
+  main_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&AshDevToolsDOMAgent::DestroyHighlightingWidget,
+                            base::Unretained(this)));
   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;
 }
 
+AshDevToolsDOMAgent::WindowAndBoundsPair
+AshDevToolsDOMAgent::GetNodeWindowAndBounds(int node_id) {
+  WmWindow* window = GetWindowFromNodeId(node_id);
+  if (window)
+    return std::make_pair(window, window->GetBoundsInScreen());
+
+  views::Widget* widget = GetWidgetFromNodeId(node_id);
+  if (widget) {
+    return std::make_pair(WmLookup::Get()->GetWindowForWidget(widget),
+                          widget->GetWindowBoundsInScreen());
+  }
+
+  views::View* view = GetViewFromNodeId(node_id);
+  if (view) {
+    gfx::Rect bounds = view->GetBoundsInScreen();
+    while (view->parent() != nullptr)
+      view = view->parent();

[sadrul, 2016/12/06 20:48:58]

Why is this needed?

[Sarmad Hashmi, 2016/12/06 22:54:34]

Sorry, thought an earlier bug I was encountering was solved by this. Seems like
it works without. Removed.

+    return std::make_pair(
+        WmLookup::Get()->GetWindowForWidget(view->GetWidget()), bounds);
+  }
+
+  return std::make_pair(nullptr, gfx::Rect());
+}
+
+void AshDevToolsDOMAgent::InitializeHighlightingWidget() {
+  DCHECK(!widget_for_highlighting_);
+  widget_for_highlighting_.reset(new views::Widget);
+  views::Widget::InitParams params;
+  params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
+  params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.opacity = views::Widget::InitParams::WindowOpacity::TRANSLUCENT_WINDOW;
+  params.name = "HighlightingWidget";
+  shell_->GetPrimaryRootWindowController()
+      ->ConfigureWidgetInitParamsForContainer(widget_for_highlighting_.get(),
+                                              kShellWindowId_OverlayContainer,
+                                              &params);
+  params.keep_on_top = true;
+  params.accept_events = false;
+  widget_for_highlighting_->Init(params);
+}
+
+void AshDevToolsDOMAgent::UpdateHighlight(WindowAndBoundsPair window_and_bounds,
+                                          SkColor background,
+                                          SkColor border) {
+  constexpr int kBorderThickness = 1;
+  views::View* root_view = widget_for_highlighting_->GetRootView();
+  root_view->SetBorder(views::CreateSolidBorder(kBorderThickness, border));
+  root_view->set_background(
+      views::Background::CreateSolidBackground(background));
+  WmLookup::Get()
+      ->GetWindowForWidget(widget_for_highlighting_.get())
+      ->SetBoundsInScreen(window_and_bounds.second,
+                          window_and_bounds.first->GetDisplayNearestWindow());

[sadrul, 2016/12/06 20:48:59]

Can you just SetBounds() on |widget_for_highlighting_| instead?

[Sarmad Hashmi, 2016/12/06 22:54:34]

We need to do SetBoundsInScreen so that we can handle highlighting on multiple
displays. Widgets don't have this method. Using SetBoundsInScreen, we can pass
in the display and avoid having a highlight intended for the secondary display
happen instead on the primary display.

+}
+
+void AshDevToolsDOMAgent::HighlightNode(
+    std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig>
+        highlight_config,
+    int node_id) {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
+  if (!widget_for_highlighting_)
+    InitializeHighlightingWidget();
+
+  WindowAndBoundsPair window_and_bounds(GetNodeWindowAndBounds(node_id));
+  // Invalid node id provided
+  if (!window_and_bounds.first)
+    return;
+
+  SkColor border_color =
+      RGBAToSkColor(highlight_config->getBorderColor(nullptr));
+  SkColor content_color =
+      RGBAToSkColor(highlight_config->getContentColor(nullptr));
+  UpdateHighlight(window_and_bounds, content_color, border_color);
+
+  if (!widget_for_highlighting_->IsVisible())
+    widget_for_highlighting_->Show();
+}
+
+bool AshDevToolsDOMAgent::IsHighlightingWindow(WmWindow* window) {
+  return widget_for_highlighting_ &&
+         window->GetInternalWidget() == widget_for_highlighting_.get();
+}
+
 }  // namespace devtools
 }  // namespace ash