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

components/ui_devtools/views/ui_devtools_unittest.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 "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "components/ui_devtools/views/ui_devtools_css_agent.h"
 #include "components/ui_devtools/views/ui_devtools_dom_agent.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 "ui/aura/client/window_parenting_client.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/display/display.h"
 #include "ui/views/background.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/native_widget_private.h"
@@ skipping 131 matching lines @@
 
 std::unique_ptr<DOM::RGBA> SkColorToRGBA(const SkColor& color) {
   return DOM::RGBA::create()
       .setA(SkColorGetA(color) / 255)
       .setB(SkColorGetB(color))
       .setG(SkColorGetG(color))
       .setR(SkColorGetR(color))
       .build();
 }
 
-std::unique_ptr<DOM::HighlightConfig> CreateHighlightConfig(
+std::unique_ptr<Overlay::HighlightConfig> CreateHighlightConfig(
     const SkColor& background_color,
     const SkColor& border_color) {
-  return DOM::HighlightConfig::create()
+  return Overlay::HighlightConfig::create()
       .setContentColor(SkColorToRGBA(background_color))
       .setBorderColor(SkColorToRGBA(border_color))
       .build();
 }
 
 void ExpectHighlighted(const gfx::Rect& bounds,
                        aura::Window* highlight_window) {
   ui::Layer* highlighting_layer = GetHighlightingLayer(highlight_window);
   EXPECT_TRUE(highlighting_layer->visible());
   EXPECT_EQ(bounds, highlighting_layer->bounds());
@@ skipping 43 matching lines @@
   void SetUp() override {
     fake_frontend_channel_ = base::MakeUnique<FakeFrontendChannel>();
     uber_dispatcher_ =
         base::MakeUnique<UberDispatcher>(fake_frontend_channel_.get());
     dom_agent_ = base::MakeUnique<ui_devtools::UIDevToolsDOMAgent>();
     dom_agent_->Init(uber_dispatcher_.get());
     css_agent_ =
         base::MakeUnique<ui_devtools::UIDevToolsCSSAgent>(dom_agent_.get());
     css_agent_->Init(uber_dispatcher_.get());
     css_agent_->enable();
+    overlay_agent_ =
+        base::MakeUnique<ui_devtools::UIDevToolsOverlayAgent>(dom_agent_.get());
+    overlay_agent_->Init(uber_dispatcher_.get());
+    overlay_agent_->enable();
 
     // We need to create |dom_agent| first to observe creation of
     // WindowTreeHosts in ViewTestBase::SetUp().
     views::ViewsTestBase::SetUp();
 
     top_window = CreateChildWindow(GetPrimaryRootWindow());
     top_default_container_window = CreateChildWindow(GetPrimaryRootWindow());
     top_overlay_window = CreateChildWindow(GetPrimaryRootWindow(),
                                            aura::client::WINDOW_TYPE_UNKNOWN);
   }
 
   void TearDown() override {
     top_overlay_window.reset();
     top_default_container_window.reset();
     top_window.reset();
     css_agent_.reset();
+    overlay_agent_.reset();
     dom_agent_.reset();
     uber_dispatcher_.reset();
     fake_frontend_channel_.reset();
     views::ViewsTestBase::TearDown();
   }
 
   void ExpectChildNodeInserted(int parent_id, int prev_sibling_id) {
     EXPECT_EQ(1, frontend_channel()->CountProtocolNotificationMessageStartsWith(
                      base::StringPrintf("{\"method\":\"DOM.childNodeInserted\","
                                         "\"params\":{\"parentNodeId\":%d,"
@@ skipping 40 matching lines @@
     EXPECT_EQ(success,
               css_agent_->setStyleTexts(std::move(edits), &output).isSuccess());
 
     if (success)
       ASSERT_TRUE(output);
     else
       ASSERT_FALSE(output);
   }
 
   void HighlightNode(int node_id) {
-    dom_agent_->highlightNode(
+    overlay_agent_->highlightNode(
         CreateHighlightConfig(kBackgroundColor, kBorderColor), node_id);
   }
 
   void HideHighlight(int root_window_index) {
     dom_agent_->hideHighlight();
     DCHECK_GE(root_window_index, 0);
     DCHECK_LE(root_window_index,
               static_cast<int>(dom_agent()->root_windows().size()));
     ASSERT_FALSE(
         GetHighlightingLayer(dom_agent()->root_windows()[root_window_index])
             ->visible());
   }
 
   FakeFrontendChannel* frontend_channel() {
     return fake_frontend_channel_.get();
   }
 
   aura::Window* GetPrimaryRootWindow() {
     DCHECK(dom_agent()->root_windows().size());
     return dom_agent()->root_windows()[0];
   }
 
   ui_devtools::UIDevToolsCSSAgent* css_agent() { return css_agent_.get(); }
   ui_devtools::UIDevToolsDOMAgent* dom_agent() { return dom_agent_.get(); }
+  ui_devtools::UIDevToolsOverlayAgent* overlay_agent() {
+    return overlay_agent_.get();
+  }
 
   std::unique_ptr<aura::Window> top_overlay_window;
   std::unique_ptr<aura::Window> top_window;
   std::unique_ptr<aura::Window> top_default_container_window;
 
  private:
   std::unique_ptr<UberDispatcher> uber_dispatcher_;
   std::unique_ptr<FakeFrontendChannel> fake_frontend_channel_;
   std::unique_ptr<ui_devtools::UIDevToolsDOMAgent> dom_agent_;
   std::unique_ptr<ui_devtools::UIDevToolsCSSAgent> css_agent_;
+  std::unique_ptr<ui_devtools::UIDevToolsOverlayAgent> overlay_agent_;
 
   DISALLOW_COPY_AND_ASSIGN(UIDevToolsTest);
 };
 
 TEST_F(UIDevToolsTest, GetDocumentWithWindowWidgetView) {
   std::unique_ptr<views::Widget> widget(
       CreateTestWidget(gfx::Rect(1, 1, 1, 1)));
   aura::Window* parent_window = widget->GetNativeWindow();
   parent_window->SetName("parent_window");
   std::unique_ptr<aura::Window> child_window = CreateChildWindow(parent_window);
@@ skipping 520 matching lines @@
   SetStyleTexts(root_view_node, "\nheight: 73;\n  ", true);
   EXPECT_EQ(gfx::Rect(25, 35, 45, 73), root_view->bounds());
 
   SetStyleTexts(root_view_node, "\nx: 10; y: 23; width: 52;\nvisibility: 1;\n",
                 true);
   EXPECT_EQ(gfx::Rect(10, 23, 52, 73), root_view->bounds());
   EXPECT_TRUE(root_view->visible());
 }
 
 }  // namespace ui_devtools