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/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/widget/native_widget_private.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/core/coordinate_conversion.h"
 
 namespace ash {
 namespace {
 
 using namespace ui::devtools::protocol;
 
 const int kDefaultChildNodeCount = -1;
 const SkColor kBackgroundColor = SK_ColorRED;
 const SkColor kBorderColor = SK_ColorBLUE;
 
@@ skipping 101 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) {
-  const aura::Window::Windows& overlay_windows =
-      Shell::GetAllRootWindows()[root_window_index]
-          ->GetChildById(kShellWindowId_OverlayContainer)
-          ->children();
+aura::Window* GetHighlightingWindow(aura::Window* root_window) {
+  // const aura::Window::Windows& overlay_windows =
+  // root_window->GetChildById(kShellWindowId_OverlayContainer)->children();
+  const aura::Window::Windows& overlay_windows = root_window->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);
+    DCHECK(dom_agent()->root_windows().size());
+    params.parent = GetPrimaryRootWindow();
     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);
+    std::unique_ptr<views::Widget> widget(new views::Widget);
+    views::Widget::InitParams params;
+    params.delegate = nullptr;
+    params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+    params.bounds = bounds;
+    params.parent = GetPrimaryRootWindow();
+    widget->Init(params);
+    widget->Show();
+    return widget;
+  }
+
+  aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
+    aura::Window* window = new aura::Window(nullptr);
+    window->set_id(0);
+    window->Init(ui::LAYER_TEXTURED);
+    window->Show();
+    aura::Window* root = dom_agent()->root_windows()[0];
+    gfx::Point origin = bounds.origin();
+    ::wm::ConvertPointFromScreen(root, &origin);
+    window->SetBounds(gfx::Rect(origin, bounds.size()));
+    aura::client::ParentWindowWithContext(window, root, bounds);
+    return window;
   }
 
   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());
+    DCHECK_GE(root_window_index, 0);
+    DCHECK_LE(root_window_index,
+              static_cast<int>(dom_agent()->root_windows().size()));
+    ASSERT_FALSE(
+        GetHighlightingWindow(dom_agent()->root_windows()[root_window_index])
+            ->IsVisible());
   }
 
   FakeFrontendChannel* frontend_channel() {
     return fake_frontend_channel_.get();
   }
 
+  aura::Window* GetPrimaryRootWindow() {
+    DCHECK(dom_agent()->root_windows().size());
+    return dom_agent()->root_windows()[0];
+  }
+
   devtools::AshDevToolsCSSAgent* css_agent() { return css_agent_.get(); }
   devtools::AshDevToolsDOMAgent* dom_agent() { return dom_agent_.get(); }
 
  private:
   std::unique_ptr<UberDispatcher> uber_dispatcher_;
   std::unique_ptr<FakeFrontendChannel> fake_frontend_channel_;
   std::unique_ptr<devtools::AshDevToolsDOMAgent> dom_agent_;
   std::unique_ptr<devtools::AshDevToolsCSSAgent> css_agent_;
 
   DISALLOW_COPY_AND_ASSIGN(AshDevToolsTest);
@@ skipping 320 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(), GetPrimaryRootWindow());
 
   HideHighlight(0);
 
   HighlightNode(widget_node->getNodeId());
-  ExpectHighlighted(widget->GetWindowBoundsInScreen(), 0);
+  ExpectHighlighted(widget->GetWindowBoundsInScreen(), GetPrimaryRootWindow());
 
   HideHighlight(0);
 
   HighlightNode(root_view_node->getNodeId());
-  ExpectHighlighted(root_view->GetBoundsInScreen(), 0);
+  ExpectHighlighted(root_view->GetBoundsInScreen(), GetPrimaryRootWindow());
 
   HideHighlight(0);
 
   // Highlight non-existent node
   HighlightNode(10000);
-  EXPECT_FALSE(GetHighlightingWindow(0)->IsVisible());
+  EXPECT_FALSE(GetHighlightingWindow(GetPrimaryRootWindow())->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;
 }
 
+// TODO(thanhph): Make test AshDevToolsTest.MultipleDisplayHighlight work with
+// multiple displays by updating params.parent in
+// InitializeHighlightingWidget().
+
 TEST_F(AshDevToolsTest, MultipleDisplayHighlight) {
+  LOG(ERROR) << "1.";
   UpdateDisplay("300x400,500x500");
+  LOG(ERROR) << "2.";
 
-  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
+  aura::Window::Windows root_windows = dom_agent()->root_windows();
+  LOG(ERROR) << "root_windows[0]->GetBoundsInScreen().ToString(): "
+             << root_windows[0]->GetBoundsInScreen().ToString();
+  LOG(ERROR) << "root_windows[1]->GetBoundsInScreen().ToString(): "
+             << root_windows[1]->GetBoundsInScreen().ToString();
+
   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());
+  LOG(ERROR) << "4.";
   HighlightNode(
       GetNodeIdFromWindow(dom_agent()->window_element_root(), window.get()));
-  ExpectHighlighted(window->GetBoundsInScreen(), 0);
+  LOG(ERROR) << "5.";
+  ExpectHighlighted(window->GetBoundsInScreen(),
+                    dom_agent()->root_windows()[0]);
+  LOG(ERROR) << "6.";
 
   window->SetBoundsInScreen(gfx::Rect(500, 0, 50, 50), GetSecondaryDisplay());
+  LOG(ERROR) << "7.";
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
+  LOG(ERROR) << "8.";
   HighlightNode(
       GetNodeIdFromWindow(dom_agent()->window_element_root(), window.get()));
-  ExpectHighlighted(window->GetBoundsInScreen(), 1);
+  LOG(ERROR) << "9.";
+  ExpectHighlighted(window->GetBoundsInScreen(),
+                    dom_agent()->root_windows()[2]);
+  LOG(ERROR) << "10.";
 }
 
 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