Create a unified UIElement interface for Widget, View and Window.

ash/devtools/ash_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 "ash/devtools/ash_devtools_css_agent.h"
 #include "ash/devtools/ash_devtools_dom_agent.h"
+#include "ash/devtools/ui_element.h"
+#include "ash/devtools/window_element.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/widget_finder.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "ui/display/display.h"
 #include "ui/views/background.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 using namespace ui::devtools::protocol;
+
 const int kDefaultChildNodeCount = -1;
 const SkColor kBackgroundColor = SK_ColorRED;
 const SkColor kBorderColor = SK_ColorBLUE;
 
 class TestView : public views::View {
  public:
   TestView(const char* name) : views::View(), name_(name) {}
 
   const char* GetClassName() const override { return name_; }
 
@@ skipping 489 matching lines @@
 
 TEST_F(AshDevToolsTest, ViewRearranged) {
   std::unique_ptr<views::Widget> widget(
       CreateTestWidget(gfx::Rect(1, 1, 1, 1)));
   aura::Window* window = widget->GetNativeWindow();
   widget->Show();
   views::View* root_view = widget->GetRootView();
   views::View* parent_view = new views::View;
   views::View* target_view = new views::View;
   views::View* child_view = new views::View;
+  views::View* child_view_1 = new views::View;
+
   root_view->AddChildView(parent_view);
   root_view->AddChildView(target_view);
   parent_view->AddChildView(child_view);
+  parent_view->AddChildView(child_view_1);
 
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
   DOM::Node* parent_node = FindInRoot(window, root.get());
   ASSERT_TRUE(parent_node);
   DOM::Node* widget_node = parent_node->getChildren(nullptr)->get(0);
   DOM::Node* root_view_node = widget_node->getChildren(nullptr)->get(0);
   Array<DOM::Node>* root_view_children = root_view_node->getChildren(nullptr);
   ASSERT_TRUE(root_view_children);
   size_t root_children_size = root_view_children->length();
   ASSERT_TRUE(root_children_size >= 2);
   DOM::Node* parent_view_node = root_view_children->get(root_children_size - 2);
   DOM::Node* target_view_node = root_view_children->get(root_children_size - 1);
   DOM::Node* child_view_node = parent_view_node->getChildren(nullptr)->get(0);
+  DOM::Node* child_view_node_1 = parent_view_node->getChildren(nullptr)->get(1);
 
   Compare(parent_view, parent_view_node);
   Compare(target_view, target_view_node);
   Compare(child_view, child_view_node);
+  Compare(child_view_1, child_view_node_1);
+
+  ASSERT_NE(child_view_node->getNodeId(), child_view_node_1->getNodeId());
+
+  // Reorder child_view_1 from index 1 to 0 in view::Views tree. This makes DOM
+  // tree remove view node at position 1 and insert it at position 0.
+  parent_view->ReorderChildView(child_view_1, 0);
+  ExpectChildNodeRemoved(parent_view_node->getNodeId(),
+                         child_view_node_1->getNodeId());
+  ExpectChildNodeInserted(parent_view_node->getNodeId(), 0);
+
   target_view->AddChildView(child_view);
   ExpectChildNodeRemoved(parent_view_node->getNodeId(),
                          child_view_node->getNodeId());
   ExpectChildNodeInserted(target_view_node->getNodeId(), 0);
 }
 
 TEST_F(AshDevToolsTest, ViewRearrangedRemovedAndInserted) {
   std::unique_ptr<views::Widget> widget(
       CreateTestWidget(gfx::Rect(1, 1, 1, 1)));
   aura::Window* window = widget->GetNativeWindow();
@@ skipping 63 matching lines @@
   HighlightNode(root_view_node->getNodeId());
   ExpectHighlighted(root_view->GetBoundsInScreen(), 0);
 
   HideHighlight(0);
 
   // Highlight non-existent node
   HighlightNode(10000);
   EXPECT_FALSE(GetHighlightingWindow(0)->IsVisible());
 }
 
+int GetNodeIdFromWindow(devtools::UIElement* ui_element, aura::Window* window) {
+  for (auto* child : ui_element->children()) {
+    if (child->type() == devtools::UIElementType::WINDOW &&
+        static_cast<devtools::WindowElement*>(child)->window() == window) {
+      return child->node_id();
+    }
+  }
+  for (auto* child : ui_element->children()) {
+    if (child->type() == devtools::UIElementType::WINDOW) {
+      int node_id = GetNodeIdFromWindow(child, window);
+      if (node_id > 0)
+        return node_id;
+    }
+  }
+  return 0;
+}
+
 TEST_F(AshDevToolsTest, MultipleDisplayHighlight) {
   UpdateDisplay("300x400,500x500");
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   std::unique_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
 
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
   EXPECT_EQ(root_windows[0], window->GetRootWindow());
-  HighlightNode(dom_agent()->GetNodeIdFromWindow(window.get()));
+  HighlightNode(
+      GetNodeIdFromWindow(dom_agent()->window_element_root(), window.get()));
   ExpectHighlighted(window->GetBoundsInScreen(), 0);
 
   window->SetBoundsInScreen(gfx::Rect(500, 0, 50, 50), GetSecondaryDisplay());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
-  HighlightNode(dom_agent()->GetNodeIdFromWindow(window.get()));
+  HighlightNode(
+      GetNodeIdFromWindow(dom_agent()->window_element_root(), window.get()));
   ExpectHighlighted(window->GetBoundsInScreen(), 1);
 }
 
 TEST_F(AshDevToolsTest, WindowWidgetViewGetMatchedStylesForNode) {
   std::unique_ptr<views::Widget> widget(
       CreateTestWidget(gfx::Rect(1, 1, 1, 1)));
   aura::Window* parent_window = widget->GetNativeWindow();
   std::unique_ptr<aura::Window> window(CreateChildWindow(parent_window));
   gfx::Rect window_bounds(2, 2, 3, 3);
   gfx::Rect widget_bounds(50, 50, 100, 75);
@@ skipping 113 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 ash