Update ash DOM agent so that widgets are direct children of windows

ash/common/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/common/devtools/ash_devtools_dom_agent.h"
 
 #include "ash/common/test/ash_test.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
@@ skipping 50 matching lines @@
 std::string GetAttributeValue(const std::string& attribute, DOM::Node* node) {
   EXPECT_TRUE(node->hasAttributes());
   Array<std::string>* attributes = node->getAttributes(nullptr);
   for (size_t i = 0; i < attributes->length() - 1; i++) {
     if (attributes->get(i) == attribute)
       return attributes->get(i + 1);
   }
   return nullptr;
 }
 
-bool Equals(views::Widget* widget, DOM::Node* node) {
-  return "Widget" == node->getNodeName() &&
-         widget->GetName() == GetAttributeValue("name", node) &&
-         (widget->GetRootView() ? 1 : 0) ==
-             node->getChildNodeCount(kDefaultChildNodeCount);
+bool Equals(WmWindow* window, DOM::Node* node) {
+  int children_count = static_cast<int>(window->GetChildren().size());
+  if (window->GetInternalWidget())
+    children_count++;
+  return "Window" == node->getNodeName() &&
+         window->GetName() == GetAttributeValue("name", node) &&
+         children_count == node->getChildNodeCount(kDefaultChildNodeCount);
 }
 
-bool Equals(WmWindow* window, DOM::Node* node) {
-  return "Window" == node->getNodeName() &&
-         window->GetName() == GetAttributeValue("name", node) &&
-         static_cast<int>(window->GetChildren().size()) ==
-             node->getChildNodeCount(kDefaultChildNodeCount);
+void Compare(views::Widget* widget, DOM::Node* node) {
+  EXPECT_EQ("Widget", node->getNodeName());
+  EXPECT_EQ(widget->GetName(), GetAttributeValue("name", node));
+  EXPECT_EQ(widget->GetRootView() ? 1 : 0,
+            node->getChildNodeCount(kDefaultChildNodeCount));
 }
 
 void Compare(views::View* view, DOM::Node* node) {
   EXPECT_EQ("View", node->getNodeName());
   EXPECT_EQ(view->GetClassName(), GetAttributeValue("name", node));
   EXPECT_EQ(view->child_count(),
             node->getChildNodeCount(kDefaultChildNodeCount));
 }
 
 void Compare(WmWindow* window, DOM::Node* node) {
   EXPECT_TRUE(Equals(window, node));
 }
 
 DOM::Node* FindInRoot(WmWindow* window, DOM::Node* root) {
   if (Equals(window, root))
     return root;
 
   Array<DOM::Node>* children = root->getChildren(nullptr);
   DOM::Node* window_node = nullptr;
   for (size_t i = 0; i < children->length(); i++) {
     window_node = FindInRoot(window, children->get(i));
     if (window_node)
       return window_node;
   }
   return window_node;
 }
 
-DOM::Node* FindInRoot(views::Widget* widget, DOM::Node* root) {
-  if (Equals(widget, root))
-    return root;
-
-  Array<DOM::Node>* children = root->getChildren(nullptr);
-  DOM::Node* widget_node = nullptr;
-  for (size_t i = 0; i < children->length(); i++) {
-    widget_node = FindInRoot(widget, children->get(i));
-    if (widget_node)
-      return widget_node;
-  }
-  return widget_node;
-}
-
 }  // namespace
 
 class AshDevToolsTest : public AshTest {
  public:
   AshDevToolsTest() {}
   ~AshDevToolsTest() override {}
 
   void SetUp() override {
     AshTest::SetUp();
     fake_frontend_channel_ = base::MakeUnique<FakeFrontendChannel>();
@@ skipping 50 matching lines @@
   WmWindow* child_window = child_owner->window();
   child_window->SetName("child_window");
   widget->Show();
   views::View* child_view = new TestView("child_view");
   widget->GetRootView()->AddChildView(child_view);
 
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
   DOM::Node* parent_node = FindInRoot(parent_window, root.get());
-  DOM::Node* widget_node = FindInRoot(widget.get(), root.get());
   ASSERT_TRUE(parent_node);
-  ASSERT_TRUE(widget_node);
-  ASSERT_TRUE(parent_node->getChildren(nullptr));
-  Compare(child_window, parent_node->getChildren(nullptr)->get(0));
+  Array<DOM::Node>* parent_children = parent_node->getChildren(nullptr);
+  ASSERT_TRUE(parent_children);
+  DOM::Node* widget_node = parent_children->get(0);
+  Compare(widget.get(), widget_node);
+  Compare(child_window, parent_children->get(1));
   Array<DOM::Node>* widget_children = widget_node->getChildren(nullptr);
   ASSERT_TRUE(widget_children);
   Compare(widget->GetRootView(), widget_children->get(0));
   ASSERT_TRUE(widget_children->get(0)->getChildren(nullptr));
   Compare(child_view, widget_children->get(0)->getChildren(nullptr)->get(1));
 }
 
 TEST_F(AshDevToolsTest, WindowAddedChildNodeInserted) {
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
@@ skipping 14 matching lines @@
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
   WmWindow* parent_window =
       WmShell::Get()->GetPrimaryRootWindow()->GetChildren()[0];
   WmWindow* child_window = parent_window->GetChildren()[0];
   DOM::Node* root_node = root->getChildren(nullptr)->get(0);
   DOM::Node* parent_node = root_node->getChildren(nullptr)->get(0);
   DOM::Node* child_node = parent_node->getChildren(nullptr)->get(0);
 
+  Compare(parent_window, parent_node);
+  Compare(child_window, child_node);
   child_window->Destroy();
   ExpectChildNodeRemoved(parent_node->getNodeId(), child_node->getNodeId());
 }
 
 TEST_F(AshDevToolsTest, WindowReorganizedChildNodeRemovedAndInserted) {
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
   WmWindow* root_window = WmShell::Get()->GetPrimaryRootWindow();
   WmWindow* target_window = root_window->GetChildren()[1];
   WmWindow* child_window = root_window->GetChildren()[0]->GetChildren()[0];
 
   DOM::Node* root_node = root->getChildren(nullptr)->get(0);
   DOM::Node* parent_node = root_node->getChildren(nullptr)->get(0);
   DOM::Node* target_node = root_node->getChildren(nullptr)->get(1);
   Array<DOM::Node>* target_node_children = target_node->getChildren(nullptr);
   DOM::Node* sibling_node =
       target_node_children->get(target_node_children->length() - 1);
   DOM::Node* child_node = parent_node->getChildren(nullptr)->get(0);
 
+  Compare(target_window, target_node);
+  Compare(child_window, child_node);
   target_window->AddChild(child_window);
   ExpectChildNodeRemoved(parent_node->getNodeId(), child_node->getNodeId());
   ExpectChildNodeInserted(target_node->getNodeId(), sibling_node->getNodeId());
 }
 
 TEST_F(AshDevToolsTest, WindowStackingChangedChildNodeRemovedAndInserted) {
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
   WmWindow* parent_window = WmShell::Get()->GetPrimaryRootWindow();
   WmWindow* child_window = parent_window->GetChildren()[0];
   WmWindow* target_window = parent_window->GetChildren()[1];
 
   DOM::Node* parent_node = root->getChildren(nullptr)->get(0);
   Array<DOM::Node>* parent_node_children = parent_node->getChildren(nullptr);
   DOM::Node* child_node = parent_node_children->get(0);
   DOM::Node* sibling_node = parent_node_children->get(1);
   int parent_id = parent_node->getNodeId();
 
+  Compare(parent_window, parent_node);
+  Compare(child_window, child_node);
   parent_window->StackChildAbove(child_window, target_window);
   ExpectChildNodeRemoved(parent_id, child_node->getNodeId());
   ExpectChildNodeInserted(parent_id, sibling_node->getNodeId());
 }
 
 }  // namespace ash