Remove ash dependency.

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/aura/window_tree_host.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;
 
@@ skipping 105 matching lines @@
     if (property->getName() == name) {
       int value;
       EXPECT_TRUE(base::StringToInt(property->getValue(), &value));
       return value;
     }
   }
   NOTREACHED();
   return -1;
 }
 
-aura::Window* GetHighlightingWindow(int root_window_index) {
+aura::Window* GetHighlightingWindow(aura::Window* root_window) {
   const aura::Window::Windows& overlay_windows =
-      Shell::GetAllRootWindows()[root_window_index]
-          ->GetChildById(kShellWindowId_OverlayContainer)
-          ->children();
+      root_window->GetChildById(kShellWindowId_OverlayContainer)->children();
   for (aura::Window* window : overlay_windows) {
     if (window->GetName() == "HighlightingWidget")
       return window;
   }
   NOTREACHED();
   return nullptr;
 }
 
 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(
     const SkColor& background_color,
     const SkColor& border_color) {
   return DOM::HighlightConfig::create()
       .setContentColor(SkColorToRGBA(background_color))
       .setBorderColor(SkColorToRGBA(border_color))
       .build();
 }
 
-void ExpectHighlighted(const gfx::Rect& bounds, int root_window_index) {
-  aura::Window* highlighting_window = GetHighlightingWindow(root_window_index);
+void ExpectHighlighted(const gfx::Rect& bounds, aura::Window* root_window) {
+  aura::Window* highlighting_window = GetHighlightingWindow(root_window);
   EXPECT_TRUE(highlighting_window->IsVisible());
   EXPECT_EQ(bounds, highlighting_window->GetBoundsInScreen());
   EXPECT_EQ(kBackgroundColor, GetInternalWidgetForWindow(highlighting_window)
                                   ->GetRootView()
                                   ->background()
                                   ->get_color());
 }
 
-aura::Window* GetPrimaryRootWindow() {
-  return Shell::Get()->GetPrimaryRootWindow();
-}
-
 }  // namespace
 
 class AshDevToolsTest : public test::AshTestBase {
  public:
   AshDevToolsTest() {}
   ~AshDevToolsTest() override {}
 
   views::internal::NativeWidgetPrivate* CreateTestNativeWidget() {
     views::Widget* widget = new views::Widget;
     views::Widget::InitParams params;
     params.ownership = views::Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET;
-    Shell::GetPrimaryRootWindowController()
-        ->ConfigureWidgetInitParamsForContainer(
-            widget, kShellWindowId_DefaultContainer, &params);
+    params.parent = nullptr;
+    if (!dom_agent()->root_windows().empty()) {
+      params.parent = dom_agent()->root_windows()[0]->GetChildById(
+          kShellWindowId_DefaultContainer);
+    }
     widget->Init(params);
     return widget->native_widget_private();
   }
 
   std::unique_ptr<views::Widget> CreateTestWidget(const gfx::Rect& bounds) {
     return AshTestBase::CreateTestWidget(nullptr, kShellWindowId_Invalid,
                                          bounds);
   }
 
   void SetUp() override {
-    AshTestBase::SetUp();
     fake_frontend_channel_ = base::MakeUnique<FakeFrontendChannel>();
     uber_dispatcher_ =
         base::MakeUnique<UberDispatcher>(fake_frontend_channel_.get());
     dom_agent_ = base::MakeUnique<devtools::AshDevToolsDOMAgent>();
     dom_agent_->Init(uber_dispatcher_.get());
     css_agent_ =
         base::MakeUnique<devtools::AshDevToolsCSSAgent>(dom_agent_.get());
     css_agent_->Init(uber_dispatcher_.get());
     css_agent_->enable();
+    AshTestBase::SetUp();
   }
 
   void TearDown() override {
     css_agent_.reset();
     dom_agent_.reset();
     uber_dispatcher_.reset();
     fake_frontend_channel_.reset();
     AshTestBase::TearDown();
   }
 
@@ skipping 50 matching lines @@
       ASSERT_FALSE(output);
   }
 
   void HighlightNode(int node_id) {
     dom_agent_->highlightNode(
         CreateHighlightConfig(kBackgroundColor, kBorderColor), node_id);
   }
 
   void HideHighlight(int root_window_index) {
     dom_agent_->hideHighlight();
-    ASSERT_FALSE(GetHighlightingWindow(root_window_index)->IsVisible());
+    ASSERT_FALSE(
+        GetHighlightingWindow(dom_agent()->root_windows()[root_window_index])

[sadrul, 2017/05/23 17:32:47]

First assert that |root_window_index| is valid.

[thanhph, 2017/05/24 15:15:21]

Done.

+            ->IsVisible());
   }
 
   FakeFrontendChannel* frontend_channel() {
     return fake_frontend_channel_.get();
   }
 
   devtools::AshDevToolsCSSAgent* css_agent() { return css_agent_.get(); }
   devtools::AshDevToolsDOMAgent* dom_agent() { return dom_agent_.get(); }
 
  private:
@@ skipping 48 matching lines @@
   Compare(widget, widget_node);
   // Destroy NativeWidget followed by |widget|
   widget->CloseNow();
 }
 
 TEST_F(AshDevToolsTest, WindowAddedChildNodeInserted) {
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
-  aura::Window* root_window = GetPrimaryRootWindow();
+  aura::Window* root_window = dom_agent()->root_windows()[0];

[sadrul, 2017/05/23 17:32:47]

Can we move GetPrimaryRootWindow() as a function in AshDevToolsTest, which
returns dom_agent()->root_windows()[0]? Because having the function makes it
easier to read the code.

[thanhph, 2017/05/24 15:15:21]

Done.

   aura::Window* parent_window = root_window->children()[0];
   DOM::Node* parent_node = FindInRoot(parent_window, root.get());
   Array<DOM::Node>* parent_node_children = parent_node->getChildren(nullptr);
   DOM::Node* sibling_node =
       parent_node_children->get(parent_node_children->length() - 1);
 
   std::unique_ptr<aura::Window> child(CreateChildWindow(parent_window));
   ExpectChildNodeInserted(parent_node->getNodeId(), sibling_node->getNodeId());
 }
 
 TEST_F(AshDevToolsTest, WindowDestroyedChildNodeRemoved) {
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
-  aura::Window* root_window = GetPrimaryRootWindow();
+  aura::Window* root_window = dom_agent()->root_windows()[0];
   aura::Window* rotation_window = root_window->children()[0];
   aura::Window* parent_window = rotation_window->children()[0];
   aura::Window* child_window = parent_window->children()[0];
   DOM::Node* root_node =
       root->getChildren(nullptr)->get(0)->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);
   delete child_window;
   ExpectChildNodeRemoved(parent_node->getNodeId(), child_node->getNodeId());
 }
 
 TEST_F(AshDevToolsTest, WindowReorganizedChildNodeRearranged) {
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
 
-  aura::Window* root_window = GetPrimaryRootWindow();
+  aura::Window* root_window = dom_agent()->root_windows()[0];
   aura::Window* rotation_window = root_window->children()[0];
   aura::Window* parent_window = rotation_window->children()[0];
   aura::Window* target_window = rotation_window->children()[1];
   aura::Window* child_window = parent_window->children()[0];
 
   DOM::Node* root_node =
       root->getChildren(nullptr)->get(0)->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(parent_window, parent_node);
   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, WindowReorganizedChildNodeRemovedAndInserted) {
-  aura::Window* root_window = GetPrimaryRootWindow();
+  aura::Window* root_window = dom_agent()->root_windows()[0];
   aura::Window* rotation_window = root_window->children()[0];
   aura::Window* parent_window = rotation_window->children()[0];
   aura::Window* target_window = rotation_window->children()[1];
   std::unique_ptr<aura::Window> child_window(CreateChildWindow(parent_window));
 
   // Initialize DOMAgent
   std::unique_ptr<ui::devtools::protocol::DOM::Node> root;
   dom_agent()->getDocument(&root);
   DOM::Node* root_node =
       root->getChildren(nullptr)->get(0)->getChildren(nullptr)->get(0);
@@ skipping 13 matching lines @@
   target_window->AddChild(child_window.get());
   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);
 
-  aura::Window* root_window = GetPrimaryRootWindow();
+  aura::Window* root_window = dom_agent()->root_windows()[0];
   aura::Window* parent_window = root_window->children()[0];
   aura::Window* child_window = parent_window->children()[0];
   aura::Window* target_window = parent_window->children()[1];
 
   DOM::Node* parent_node =
       root->getChildren(nullptr)->get(0)->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();
@@ skipping 163 matching lines @@
 
   DOM::Node* parent_node = FindInRoot(parent_window, root.get());
   ASSERT_TRUE(parent_node);
   Array<DOM::Node>* parent_children = parent_node->getChildren(nullptr);
   ASSERT_TRUE(parent_children);
   DOM::Node* window_node = parent_children->get(1);
   DOM::Node* widget_node = parent_children->get(0);
   DOM::Node* root_view_node = widget_node->getChildren(nullptr)->get(0);
 
   HighlightNode(window_node->getNodeId());
-  ExpectHighlighted(window->GetBoundsInScreen(), 0);
+  ExpectHighlighted(window->GetBoundsInScreen(),
+                    dom_agent()->root_windows()[0]);
 
   HideHighlight(0);
 
   HighlightNode(widget_node->getNodeId());
-  ExpectHighlighted(widget->GetWindowBoundsInScreen(), 0);
+  ExpectHighlighted(widget->GetWindowBoundsInScreen(),
+                    dom_agent()->root_windows()[0]);
 
   HideHighlight(0);
 
   HighlightNode(root_view_node->getNodeId());
-  ExpectHighlighted(root_view->GetBoundsInScreen(), 0);
+  ExpectHighlighted(root_view->GetBoundsInScreen(),
+                    dom_agent()->root_windows()[0]);
 
   HideHighlight(0);
 
   // Highlight non-existent node
   HighlightNode(10000);
-  EXPECT_FALSE(GetHighlightingWindow(0)->IsVisible());
+  EXPECT_FALSE(
+      GetHighlightingWindow(dom_agent()->root_windows()[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();
+  aura::Window::Windows root_windows = dom_agent()->root_windows();

[sadrul, 2017/05/23 17:32:47]

const auto& root_windows = dom_agent()->root_windows();

[thanhph, 2017/05/24 15:15:21]

I removed this test for now as we discussed. Added a TODO to support multiple
displays in the future.

   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(
       GetNodeIdFromWindow(dom_agent()->window_element_root(), window.get()));
-  ExpectHighlighted(window->GetBoundsInScreen(), 0);
+  ExpectHighlighted(window->GetBoundsInScreen(),
+                    dom_agent()->root_windows()[0]);
 
   window->SetBoundsInScreen(gfx::Rect(500, 0, 50, 50), GetSecondaryDisplay());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   HighlightNode(
       GetNodeIdFromWindow(dom_agent()->window_element_root(), window.get()));
-  ExpectHighlighted(window->GetBoundsInScreen(), 1);
+  ExpectHighlighted(window->GetBoundsInScreen(),
+                    dom_agent()->root_windows()[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);
   gfx::Rect view_bounds(4, 4, 3, 3);
@@ skipping 112 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