mus: Use TooltipManagerAura in NativeWidgetMus.

ui/views/corewm/tooltip_controller_unittest.cc

 // Copyright (c) 2013 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 "ui/views/corewm/tooltip_controller.h"
 
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/test_screen.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/display/screen.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/corewm/tooltip_controller_test_helper.h"
 #include "ui/views/test/desktop_test_views_delegate.h"
+#include "ui/views/test/native_widget_factory.h"
 #include "ui/views/test/test_views_delegate.h"
+#include "ui/views/test/views_test_base.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/core/default_screen_position_client.h"
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/tooltip_client.h"
 #include "ui/wm/public/window_types.h"
 
 #if defined(OS_WIN)
@@ skipping 14 matching lines @@
 
 views::Widget* CreateWidget(aura::Window* root) {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
   params.accept_events = true;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 #if defined(OS_CHROMEOS)
   params.parent = root;
 #else
-  params.native_widget = new DesktopNativeWidgetAura(widget);
+  params.native_widget = ::views::test::CreatePlatformDesktopNativeWidgetImpl(
+      params, widget, nullptr);
 #endif
   params.bounds = gfx::Rect(0, 0, 200, 100);
   widget->Init(params);
   widget->Show();
   return widget;
 }
 
 TooltipController* GetController(Widget* widget) {
   return static_cast<TooltipController*>(
       aura::client::GetTooltipClient(
           widget->GetNativeWindow()->GetRootWindow()));
 }
 
 }  // namespace
 
-class TooltipControllerTest : public aura::test::AuraTestBase {
+class TooltipControllerTest : public ViewsTestBase {
  public:
   TooltipControllerTest() : view_(NULL) {}
   ~TooltipControllerTest() override {}
 
   void SetUp() override {
-#if defined(OS_CHROMEOS)
-    views_delegate_.reset(new TestViewsDelegate);
-#else
-    views_delegate_.reset(new DesktopTestViewsDelegate);
-#endif
+    ViewsTestBase::SetUp();
 
-    aura::test::AuraTestBase::SetUp();
-    new wm::DefaultActivationClient(root_window());
+    aura::Window* root_window = GetContext();
+
+    new wm::DefaultActivationClient(root_window);
 #if defined(OS_CHROMEOS)
     controller_.reset(
         new TooltipController(std::unique_ptr<views::corewm::Tooltip>(
             new views::corewm::TooltipAura)));
-    root_window()->AddPreTargetHandler(controller_.get());
-    SetTooltipClient(root_window(), controller_.get());
+    root_window->AddPreTargetHandler(controller_.get());
+    SetTooltipClient(root_window, controller_.get());
 #endif
-    widget_.reset(CreateWidget(root_window()));
+    widget_.reset(CreateWidget(root_window));
     widget_->SetContentsView(new View);
     view_ = new TooltipTestView;
     widget_->GetContentsView()->AddChildView(view_);
     view_->SetBoundsRect(widget_->GetContentsView()->GetLocalBounds());
     helper_.reset(new TooltipControllerTestHelper(
                       GetController(widget_.get())));
     generator_.reset(new ui::test::EventGenerator(GetRootWindow()));
   }
 
   void TearDown() override {
 #if defined(OS_CHROMEOS)
-    root_window()->RemovePreTargetHandler(controller_.get());
-    aura::client::SetTooltipClient(root_window(), NULL);
+    aura::Window* root_window = GetContext();
+    root_window->RemovePreTargetHandler(controller_.get());
+    aura::client::SetTooltipClient(root_window, NULL);
     controller_.reset();
 #endif
     generator_.reset();
     helper_.reset();
     widget_.reset();
-    aura::test::AuraTestBase::TearDown();
-    views_delegate_.reset();
+    ViewsTestBase::TearDown();
   }
 
  protected:
   aura::Window* GetWindow() {
     return widget_->GetNativeWindow();
   }
 
   aura::Window* GetRootWindow() {
     return GetWindow()->GetRootWindow();
   }
 
+  aura::Window* CreateNormalWindow(int id,
+                                   aura::Window* parent,
+                                   aura::WindowDelegate* delegate) {
+    aura::Window* window = new aura::Window(
+        delegate
+            ? delegate
+            : aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate());
+    window->set_id(id);
+    window->Init(ui::LAYER_TEXTURED);
+    parent->AddChild(window);
+    window->SetBounds(gfx::Rect(0, 0, 100, 100));
+    window->Show();
+    return window;
+  }
+
   TooltipTestView* PrepareSecondView() {
     TooltipTestView* view2 = new TooltipTestView;
     widget_->GetContentsView()->AddChildView(view2);
     view_->SetBounds(0, 0, 100, 100);
     view2->SetBounds(100, 0, 100, 100);
     return view2;
   }
 
   std::unique_ptr<views::Widget> widget_;
   TooltipTestView* view_;
   std::unique_ptr<TooltipControllerTestHelper> helper_;
   std::unique_ptr<ui::test::EventGenerator> generator_;
 
  private:
   std::unique_ptr<TooltipController> controller_;
 
-  std::unique_ptr<views::TestViewsDelegate> views_delegate_;
-
 #if defined(OS_WIN)
   ui::ScopedOleInitializer ole_initializer_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest);
 };
 
 TEST_F(TooltipControllerTest, ViewTooltip) {
   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
@@ skipping 259 matching lines @@
 
 class TooltipControllerCaptureTest : public TooltipControllerTest {
  public:
   TooltipControllerCaptureTest() {}
   ~TooltipControllerCaptureTest() override {}
 
   void SetUp() override {
     TooltipControllerTest::SetUp();
     aura::client::SetScreenPositionClient(GetRootWindow(),
                                           &screen_position_client_);
-#if !defined(OS_CHROMEOS)
-    desktop_screen_.reset(CreateDesktopScreen());
-    display::Screen::SetScreenInstance(desktop_screen_.get());
-#endif
   }
 
   void TearDown() override {
-#if !defined(OS_CHROMEOS)
-    display::Screen::SetScreenInstance(test_screen());
-    desktop_screen_.reset();
-#endif
     aura::client::SetScreenPositionClient(GetRootWindow(), NULL);
     TooltipControllerTest::TearDown();
   }
 
  private:
   wm::DefaultScreenPositionClient screen_position_client_;
   std::unique_ptr<display::Screen> desktop_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(TooltipControllerCaptureTest);
 };
 
 // Verifies when capture is released the TooltipController resets state.
 // Flaky on all builders.  http://crbug.com/388268
 TEST_F(TooltipControllerCaptureTest, DISABLED_CloseOnCaptureLost) {
   view_->GetWidget()->SetCapture(view_);
-  RunAllPendingInMessageLoop();
+  RunPendingMessages();
   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
   generator_->MoveMouseToCenterOf(GetWindow());
   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text");
   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(GetWindow()));
   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
   EXPECT_EQ(GetWindow(), helper_->GetTooltipWindow());
 
   // Fire tooltip timer so tooltip becomes visible.
   helper_->FireTooltipTimer();
 
   EXPECT_TRUE(helper_->IsTooltipVisible());
   view_->GetWidget()->ReleaseCapture();
   EXPECT_FALSE(helper_->IsTooltipVisible());
   EXPECT_TRUE(helper_->GetTooltipWindow() == NULL);
 }
 
 // Disabled on linux as DesktopScreenX11::GetWindowAtScreenPoint() doesn't
 // consider z-order.
 // Disabled on Windows due to failing bots. http://crbug.com/604479
 #if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_WIN)
 #define MAYBE_Capture DISABLED_Capture
 #else
 #define MAYBE_Capture Capture
 #endif
 // Verifies the correct window is found for tooltips when there is a capture.
 TEST_F(TooltipControllerCaptureTest, MAYBE_Capture) {
+  // Currently, capture in one test affects capture in other tests.
+  if (IsMus())
+    return;
+
   const base::string16 tooltip_text(ASCIIToUTF16("1"));
   const base::string16 tooltip_text2(ASCIIToUTF16("2"));
 
   widget_->SetBounds(gfx::Rect(0, 0, 200, 200));
   view_->set_tooltip_text(tooltip_text);
 
-  std::unique_ptr<views::Widget> widget2(CreateWidget(root_window()));
+  std::unique_ptr<views::Widget> widget2(CreateWidget(GetContext()));
   widget2->SetContentsView(new View);
   TooltipTestView* view2 = new TooltipTestView;
   widget2->GetContentsView()->AddChildView(view2);
   view2->set_tooltip_text(tooltip_text2);
   widget2->SetBounds(gfx::Rect(0, 0, 200, 200));
   view2->SetBoundsRect(widget2->GetContentsView()->GetLocalBounds());
 
   widget_->SetCapture(view_);
   EXPECT_TRUE(widget_->HasCapture());
   widget2->Show();
@@ skipping 129 matching lines @@
 
   // Send OnCancelMode event and verify that tooltip becomes invisible and
   // the tooltip window is closed.
   ui::CancelModeEvent event;
   helper_->controller()->OnCancelMode(&event);
   EXPECT_FALSE(helper_->IsTooltipVisible());
   EXPECT_TRUE(helper_->GetTooltipWindow() == NULL);
 }
 
 // Use for tests that need both views and a TestTooltip.
-class TooltipControllerTest3 : public aura::test::AuraTestBase {
+class TooltipControllerTest3 : public ViewsTestBase {
  public:
   TooltipControllerTest3() : test_tooltip_(new TestTooltip) {}
   ~TooltipControllerTest3() override {}
 
   void SetUp() override {
     wm_state_.reset(new wm::WMState);
-    aura::test::AuraTestBase::SetUp();
-    new wm::DefaultActivationClient(root_window());
+    ViewsTestBase::SetUp();
 
-    widget_.reset(CreateWidget(root_window()));
+    aura::Window* root_window = GetContext();
+    new wm::DefaultActivationClient(root_window);
+
+    widget_.reset(CreateWidget(root_window));
     widget_->SetContentsView(new View);
     view_ = new TooltipTestView;
     widget_->GetContentsView()->AddChildView(view_);
     view_->SetBoundsRect(widget_->GetContentsView()->GetLocalBounds());
 
     generator_.reset(new ui::test::EventGenerator(GetRootWindow()));
     controller_.reset(new TooltipController(
         std::unique_ptr<views::corewm::Tooltip>(test_tooltip_)));
     GetRootWindow()->RemovePreTargetHandler(
         static_cast<TooltipController*>(aura::client::GetTooltipClient(
             widget_->GetNativeWindow()->GetRootWindow())));
     GetRootWindow()->AddPreTargetHandler(controller_.get());
     helper_.reset(new TooltipControllerTestHelper(controller_.get()));
     SetTooltipClient(GetRootWindow(), controller_.get());
   }
 
   void TearDown() override {
     GetRootWindow()->RemovePreTargetHandler(controller_.get());
     aura::client::SetTooltipClient(GetRootWindow(), NULL);
 
     controller_.reset();
     generator_.reset();
     helper_.reset();
     widget_.reset();
-    aura::test::AuraTestBase::TearDown();
+    ViewsTestBase::TearDown();
     wm_state_.reset();
   }
 
   aura::Window* GetWindow() { return widget_->GetNativeWindow(); }
 
  protected:
   // Owned by |controller_|.
   TestTooltip* test_tooltip_;
   std::unique_ptr<TooltipControllerTestHelper> helper_;
   std::unique_ptr<ui::test::EventGenerator> generator_;
@@ skipping 114 matching lines @@
   helper_->FireTooltipTimer();
   tooltip_bounds1 = test_tooltip_->location();
 
   EXPECT_NE(tooltip_bounds1_1, tooltip_bounds1);
   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 }
 
 }  // namespace test
 }  // namespace corewm
 }  // namespace views