ui/views/corewm/tooltip_controller_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/corewm/tooltip_controller.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "ui/aura/client/cursor_client.h"
   9 #include "ui/aura/client/screen_position_client.h"
  10 #include "ui/aura/env.h"
  11 #include "ui/aura/test/aura_test_base.h"
  12 #include "ui/aura/test/test_screen.h"
  13 #include "ui/aura/test/test_window_delegate.h"
  14 #include "ui/aura/window.h"
  15 #include "ui/aura/window_event_dispatcher.h"
  16 #include "ui/events/test/event_generator.h"
  17 #include "ui/gfx/font.h"
  18 #include "ui/gfx/point.h"
  19 #include "ui/gfx/screen.h"
  20 #include "ui/gfx/screen_type_delegate.h"
  21 #include "ui/gfx/text_elider.h"
  22 #include "ui/views/corewm/tooltip_aura.h"
  23 #include "ui/views/corewm/tooltip_controller_test_helper.h"
  24 #include "ui/views/test/desktop_test_views_delegate.h"
  25 #include "ui/views/test/test_views_delegate.h"
  26 #include "ui/views/view.h"
  27 #include "ui/views/widget/tooltip_manager.h"
  28 #include "ui/views/widget/widget.h"
  29 #include "ui/wm/core/default_activation_client.h"
  30 #include "ui/wm/core/wm_state.h"
  31 #include "ui/wm/public/tooltip_client.h"
  32 #include "ui/wm/public/window_types.h"
  33
  34 #if defined(OS_WIN)
  35 #include "ui/base/win/scoped_ole_initializer.h"
  36 #endif
  37
  38 #if !defined(OS_CHROMEOS)
  39 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
  40 #include "ui/views/widget/desktop_aura/desktop_screen.h"
  41 #endif
  42
  43 using base::ASCIIToUTF16;
  44
  45 namespace views {
  46 namespace corewm {
  47 namespace test {
  48 namespace {
  49
  50 views::Widget* CreateWidget(aura::Window* root) {
  51   views::Widget* widget = new views::Widget;
  52   views::Widget::InitParams params;
  53   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
  54   params.accept_events = true;
  55   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
  56 #if defined(OS_CHROMEOS)
  57   params.parent = root;
  58 #else
  59   params.native_widget = new DesktopNativeWidgetAura(widget);
  60 #endif
  61   params.bounds = gfx::Rect(0, 0, 200, 100);
  62   widget->Init(params);
  63   widget->Show();
  64   return widget;
  65 }
  66
  67 TooltipController* GetController(Widget* widget) {
  68   return static_cast<TooltipController*>(
  69       aura::client::GetTooltipClient(
  70           widget->GetNativeWindow()->GetRootWindow()));
  71 }
  72
  73 }  // namespace
  74
  75 class TooltipControllerTest : public aura::test::AuraTestBase {
  76  public:
  77   TooltipControllerTest() : view_(NULL) {}
  78   virtual ~TooltipControllerTest() {}
  79
  80   virtual void SetUp() OVERRIDE {
  81 #if defined(OS_CHROMEOS)
  82     views_delegate_.reset(new TestViewsDelegate);
  83 #else
  84     views_delegate_.reset(new DesktopTestViewsDelegate);
  85 #endif
  86
  87     aura::test::AuraTestBase::SetUp();
  88     new wm::DefaultActivationClient(root_window());
  89 #if defined(OS_CHROMEOS)
  90     controller_.reset(new TooltipController(
  91           scoped_ptr<views::corewm::Tooltip>(
  92               new views::corewm::TooltipAura(gfx::SCREEN_TYPE_ALTERNATE))));
  93     root_window()->AddPreTargetHandler(controller_.get());
  94     SetTooltipClient(root_window(), controller_.get());
  95 #endif
  96     widget_.reset(CreateWidget(root_window()));
  97     widget_->SetContentsView(new View);
  98     view_ = new TooltipTestView;
  99     widget_->GetContentsView()->AddChildView(view_);
 100     view_->SetBoundsRect(widget_->GetContentsView()->GetLocalBounds());
 101     helper_.reset(new TooltipControllerTestHelper(
 102                       GetController(widget_.get())));
 103     generator_.reset(new ui::test::EventGenerator(GetRootWindow()));
 104   }
 105
 106   virtual void TearDown() OVERRIDE {
 107 #if defined(OS_CHROMEOS)
 108     root_window()->RemovePreTargetHandler(controller_.get());
 109     aura::client::SetTooltipClient(root_window(), NULL);
 110     controller_.reset();
 111 #endif
 112     generator_.reset();
 113     helper_.reset();
 114     widget_.reset();
 115     aura::test::AuraTestBase::TearDown();
 116     views_delegate_.reset();
 117   }
 118
 119  protected:
 120   aura::Window* GetWindow() {
 121     return widget_->GetNativeWindow();
 122   }
 123
 124   aura::Window* GetRootWindow() {
 125     return GetWindow()->GetRootWindow();
 126   }
 127
 128   TooltipTestView* PrepareSecondView() {
 129     TooltipTestView* view2 = new TooltipTestView;
 130     widget_->GetContentsView()->AddChildView(view2);
 131     view_->SetBounds(0, 0, 100, 100);
 132     view2->SetBounds(100, 0, 100, 100);
 133     return view2;
 134   }
 135
 136   scoped_ptr<views::Widget> widget_;
 137   TooltipTestView* view_;
 138   scoped_ptr<TooltipControllerTestHelper> helper_;
 139   scoped_ptr<ui::test::EventGenerator> generator_;
 140
 141  private:
 142   scoped_ptr<TooltipController> controller_;
 143
 144   scoped_ptr<views::TestViewsDelegate> views_delegate_;
 145
 146 #if defined(OS_WIN)
 147   ui::ScopedOleInitializer ole_initializer_;
 148 #endif
 149
 150   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest);
 151 };
 152
 153 TEST_F(TooltipControllerTest, ViewTooltip) {
 154   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
 155   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 156   EXPECT_EQ(NULL, helper_->GetTooltipWindow());
 157   generator_->MoveMouseToCenterOf(GetWindow());
 158
 159   EXPECT_EQ(GetWindow(), GetRootWindow()->GetEventHandlerForPoint(
 160       generator_->current_location()));
 161   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text");
 162   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(GetWindow()));
 163   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 164   EXPECT_EQ(GetWindow(), helper_->GetTooltipWindow());
 165
 166   // Fire tooltip timer so tooltip becomes visible.
 167   helper_->FireTooltipTimer();
 168
 169   EXPECT_TRUE(helper_->IsTooltipVisible());
 170   generator_->MoveMouseBy(1, 0);
 171
 172   EXPECT_TRUE(helper_->IsTooltipVisible());
 173   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(GetWindow()));
 174   EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 175   EXPECT_EQ(GetWindow(), helper_->GetTooltipWindow());
 176 }
 177
 178 TEST_F(TooltipControllerTest, TooltipsInMultipleViews) {
 179   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
 180   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 181   EXPECT_EQ(NULL, helper_->GetTooltipWindow());
 182
 183   PrepareSecondView();
 184   aura::Window* window = GetWindow();
 185   aura::Window* root_window = GetRootWindow();
 186
 187   // Fire tooltip timer so tooltip becomes visible.
 188   generator_->MoveMouseRelativeTo(window, view_->bounds().CenterPoint());
 189   helper_->FireTooltipTimer();
 190   EXPECT_TRUE(helper_->IsTooltipVisible());
 191   for (int i = 0; i < 49; ++i) {
 192     generator_->MoveMouseBy(1, 0);
 193     EXPECT_TRUE(helper_->IsTooltipVisible());
 194     EXPECT_EQ(window, root_window->GetEventHandlerForPoint(
 195             generator_->current_location()));
 196     base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text");
 197     EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(window));
 198     EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 199     EXPECT_EQ(window, helper_->GetTooltipWindow());
 200   }
 201   for (int i = 0; i < 49; ++i) {
 202     generator_->MoveMouseBy(1, 0);
 203     EXPECT_FALSE(helper_->IsTooltipVisible());
 204     EXPECT_EQ(window, root_window->GetEventHandlerForPoint(
 205             generator_->current_location()));
 206     base::string16 expected_tooltip;  // = ""
 207     EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(window));
 208     EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 209     EXPECT_EQ(window, helper_->GetTooltipWindow());
 210   }
 211 }
 212
 213 TEST_F(TooltipControllerTest, EnableOrDisableTooltips) {
 214   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
 215   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 216   EXPECT_EQ(NULL, helper_->GetTooltipWindow());
 217
 218   generator_->MoveMouseRelativeTo(GetWindow(), view_->bounds().CenterPoint());
 219   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text");
 220
 221   // Fire tooltip timer so tooltip becomes visible.
 222   helper_->FireTooltipTimer();
 223   EXPECT_TRUE(helper_->IsTooltipVisible());
 224
 225   // Disable tooltips and check again.
 226   helper_->controller()->SetTooltipsEnabled(false);
 227   EXPECT_FALSE(helper_->IsTooltipVisible());
 228   helper_->FireTooltipTimer();
 229   EXPECT_FALSE(helper_->IsTooltipVisible());
 230
 231   // Enable tooltips back and check again.
 232   helper_->controller()->SetTooltipsEnabled(true);
 233   EXPECT_FALSE(helper_->IsTooltipVisible());
 234   helper_->FireTooltipTimer();
 235   EXPECT_TRUE(helper_->IsTooltipVisible());
 236 }
 237
 238 // Verifies tooltip isn't shown if tooltip text consists entirely of whitespace.
 239 TEST_F(TooltipControllerTest, DontShowEmptyTooltips) {
 240   view_->set_tooltip_text(ASCIIToUTF16("                     "));
 241   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 242   EXPECT_EQ(NULL, helper_->GetTooltipWindow());
 243
 244   generator_->MoveMouseRelativeTo(GetWindow(), view_->bounds().CenterPoint());
 245
 246   helper_->FireTooltipTimer();
 247   EXPECT_FALSE(helper_->IsTooltipVisible());
 248 }
 249
 250 TEST_F(TooltipControllerTest, TooltipHidesOnKeyPressAndStaysHiddenUntilChange) {
 251   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text for view 1"));
 252   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 253   EXPECT_EQ(NULL, helper_->GetTooltipWindow());
 254
 255   TooltipTestView* view2 = PrepareSecondView();
 256   view2->set_tooltip_text(ASCIIToUTF16("Tooltip Text for view 2"));
 257
 258   aura::Window* window = GetWindow();
 259
 260   // Fire tooltip timer so tooltip becomes visible.
 261   generator_->MoveMouseRelativeTo(window, view_->bounds().CenterPoint());
 262   helper_->FireTooltipTimer();
 263   EXPECT_TRUE(helper_->IsTooltipVisible());
 264   EXPECT_TRUE(helper_->IsTooltipShownTimerRunning());
 265
 266   generator_->PressKey(ui::VKEY_1, 0);
 267   EXPECT_FALSE(helper_->IsTooltipVisible());
 268   EXPECT_FALSE(helper_->IsTooltipTimerRunning());
 269   EXPECT_FALSE(helper_->IsTooltipShownTimerRunning());
 270
 271   // Moving the mouse inside |view1| should not change the state of the tooltip
 272   // or the timers.
 273   for (int i = 0; i < 49; i++) {
 274     generator_->MoveMouseBy(1, 0);
 275     EXPECT_FALSE(helper_->IsTooltipVisible());
 276     EXPECT_FALSE(helper_->IsTooltipTimerRunning());
 277     EXPECT_FALSE(helper_->IsTooltipShownTimerRunning());
 278     EXPECT_EQ(window,
 279               GetRootWindow()->GetEventHandlerForPoint(
 280                   generator_->current_location()));
 281     base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text for view 1");
 282     EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(window));
 283     EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 284     EXPECT_EQ(window, helper_->GetTooltipWindow());
 285   }
 286
 287   // Now we move the mouse on to |view2|. It should re-start the tooltip timer.
 288   generator_->MoveMouseBy(1, 0);
 289   EXPECT_TRUE(helper_->IsTooltipTimerRunning());
 290   helper_->FireTooltipTimer();
 291   EXPECT_TRUE(helper_->IsTooltipVisible());
 292   EXPECT_TRUE(helper_->IsTooltipShownTimerRunning());
 293   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text for view 2");
 294   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(window));
 295   EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 296   EXPECT_EQ(window, helper_->GetTooltipWindow());
 297 }
 298
 299 TEST_F(TooltipControllerTest, TooltipHidesOnTimeoutAndStaysHiddenUntilChange) {
 300   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text for view 1"));
 301   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 302   EXPECT_EQ(NULL, helper_->GetTooltipWindow());
 303
 304   TooltipTestView* view2 = PrepareSecondView();
 305   view2->set_tooltip_text(ASCIIToUTF16("Tooltip Text for view 2"));
 306
 307   aura::Window* window = GetWindow();
 308
 309   // Fire tooltip timer so tooltip becomes visible.
 310   generator_->MoveMouseRelativeTo(window, view_->bounds().CenterPoint());
 311   helper_->FireTooltipTimer();
 312   EXPECT_TRUE(helper_->IsTooltipVisible());
 313   EXPECT_TRUE(helper_->IsTooltipShownTimerRunning());
 314
 315   helper_->FireTooltipShownTimer();
 316   EXPECT_FALSE(helper_->IsTooltipVisible());
 317   EXPECT_FALSE(helper_->IsTooltipTimerRunning());
 318   EXPECT_FALSE(helper_->IsTooltipShownTimerRunning());
 319
 320   // Moving the mouse inside |view1| should not change the state of the tooltip
 321   // or the timers.
 322   for (int i = 0; i < 49; ++i) {
 323     generator_->MoveMouseBy(1, 0);
 324     EXPECT_FALSE(helper_->IsTooltipVisible());
 325     EXPECT_FALSE(helper_->IsTooltipTimerRunning());
 326     EXPECT_FALSE(helper_->IsTooltipShownTimerRunning());
 327     EXPECT_EQ(window, GetRootWindow()->GetEventHandlerForPoint(
 328                   generator_->current_location()));
 329     base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text for view 1");
 330     EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(window));
 331     EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 332     EXPECT_EQ(window, helper_->GetTooltipWindow());
 333   }
 334
 335   // Now we move the mouse on to |view2|. It should re-start the tooltip timer.
 336   generator_->MoveMouseBy(1, 0);
 337   EXPECT_TRUE(helper_->IsTooltipTimerRunning());
 338   helper_->FireTooltipTimer();
 339   EXPECT_TRUE(helper_->IsTooltipVisible());
 340   EXPECT_TRUE(helper_->IsTooltipShownTimerRunning());
 341   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text for view 2");
 342   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(window));
 343   EXPECT_EQ(expected_tooltip, helper_->GetTooltipText());
 344   EXPECT_EQ(window, helper_->GetTooltipWindow());
 345 }
 346
 347 // Verifies a mouse exit event hides the tooltips.
 348 TEST_F(TooltipControllerTest, HideOnExit) {
 349   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
 350   generator_->MoveMouseToCenterOf(GetWindow());
 351   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text");
 352   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(GetWindow()));
 353   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 354   EXPECT_EQ(GetWindow(), helper_->GetTooltipWindow());
 355
 356   // Fire tooltip timer so tooltip becomes visible.
 357   helper_->FireTooltipTimer();
 358
 359   EXPECT_TRUE(helper_->IsTooltipVisible());
 360   generator_->SendMouseExit();
 361   EXPECT_FALSE(helper_->IsTooltipVisible());
 362 }
 363
 364 TEST_F(TooltipControllerTest, ReshowOnClickAfterEnterExit) {
 365   // Owned by |view_|.
 366   TooltipTestView* v1 = new TooltipTestView;
 367   TooltipTestView* v2 = new TooltipTestView;
 368   view_->AddChildView(v1);
 369   view_->AddChildView(v2);
 370   gfx::Rect view_bounds(view_->GetLocalBounds());
 371   view_bounds.set_height(view_bounds.height() / 2);
 372   v1->SetBoundsRect(view_bounds);
 373   view_bounds.set_y(view_bounds.height());
 374   v2->SetBoundsRect(view_bounds);
 375   const base::string16 v1_tt(ASCIIToUTF16("v1"));
 376   const base::string16 v2_tt(ASCIIToUTF16("v2"));
 377   v1->set_tooltip_text(v1_tt);
 378   v2->set_tooltip_text(v2_tt);
 379
 380   gfx::Point v1_point(1, 1);
 381   View::ConvertPointToWidget(v1, &v1_point);
 382   generator_->MoveMouseRelativeTo(GetWindow(), v1_point);
 383
 384   // Fire tooltip timer so tooltip becomes visible.
 385   helper_->FireTooltipTimer();
 386   EXPECT_TRUE(helper_->IsTooltipVisible());
 387   EXPECT_EQ(v1_tt, helper_->GetTooltipText());
 388
 389   // Press the mouse, move to v2 and back to v1.
 390   generator_->ClickLeftButton();
 391
 392   gfx::Point v2_point(1, 1);
 393   View::ConvertPointToWidget(v2, &v2_point);
 394   generator_->MoveMouseRelativeTo(GetWindow(), v2_point);
 395   generator_->MoveMouseRelativeTo(GetWindow(), v1_point);
 396
 397   helper_->FireTooltipTimer();
 398   EXPECT_TRUE(helper_->IsTooltipVisible());
 399   EXPECT_EQ(v1_tt, helper_->GetTooltipText());
 400 }
 401
 402 namespace {
 403
 404 // Returns the index of |window| in its parent's children.
 405 int IndexInParent(const aura::Window* window) {
 406   aura::Window::Windows::const_iterator i =
 407       std::find(window->parent()->children().begin(),
 408                 window->parent()->children().end(),
 409                 window);
 410   return i == window->parent()->children().end() ? -1 :
 411       static_cast<int>(i - window->parent()->children().begin());
 412 }
 413
 414 class TestScreenPositionClient : public aura::client::ScreenPositionClient {
 415  public:
 416   TestScreenPositionClient() {}
 417   virtual ~TestScreenPositionClient() {}
 418
 419   // ScreenPositionClient overrides:
 420   virtual void ConvertPointToScreen(const aura::Window* window,
 421                                     gfx::Point* point) OVERRIDE {
 422   }
 423   virtual void ConvertPointFromScreen(const aura::Window* window,
 424                                       gfx::Point* point) OVERRIDE {
 425   }
 426   virtual void ConvertHostPointToScreen(aura::Window* root_gwindow,
 427                                         gfx::Point* point) OVERRIDE {
 428     NOTREACHED();
 429   }
 430   virtual void SetBounds(aura::Window* window,
 431                          const gfx::Rect& bounds,
 432                          const gfx::Display& display) OVERRIDE {
 433     window->SetBounds(bounds);
 434   }
 435
 436  private:
 437   DISALLOW_COPY_AND_ASSIGN(TestScreenPositionClient);
 438 };
 439
 440 }  // namespace
 441
 442 class TooltipControllerCaptureTest : public TooltipControllerTest {
 443  public:
 444   TooltipControllerCaptureTest() {}
 445   virtual ~TooltipControllerCaptureTest() {}
 446
 447   virtual void SetUp() OVERRIDE {
 448     TooltipControllerTest::SetUp();
 449     aura::client::SetScreenPositionClient(GetRootWindow(),
 450                                           &screen_position_client_);
 451 #if !defined(OS_CHROMEOS)
 452     desktop_screen_.reset(CreateDesktopScreen());
 453     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
 454                                    desktop_screen_.get());
 455 #endif
 456   }
 457
 458   virtual void TearDown() OVERRIDE {
 459 #if !defined(OS_CHROMEOS)
 460     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, test_screen());
 461     desktop_screen_.reset();
 462 #endif
 463     aura::client::SetScreenPositionClient(GetRootWindow(), NULL);
 464     TooltipControllerTest::TearDown();
 465   }
 466
 467  private:
 468   TestScreenPositionClient screen_position_client_;
 469   scoped_ptr<gfx::Screen> desktop_screen_;
 470
 471   DISALLOW_COPY_AND_ASSIGN(TooltipControllerCaptureTest);
 472 };
 473
 474 // Verifies when capture is released the TooltipController resets state.
 475 // Flaky on all builders.  http://crbug.com/388268
 476 TEST_F(TooltipControllerCaptureTest, DISABLED_CloseOnCaptureLost) {
 477   view_->GetWidget()->SetCapture(view_);
 478   RunAllPendingInMessageLoop();
 479   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
 480   generator_->MoveMouseToCenterOf(GetWindow());
 481   base::string16 expected_tooltip = ASCIIToUTF16("Tooltip Text");
 482   EXPECT_EQ(expected_tooltip, aura::client::GetTooltipText(GetWindow()));
 483   EXPECT_EQ(base::string16(), helper_->GetTooltipText());
 484   EXPECT_EQ(GetWindow(), helper_->GetTooltipWindow());
 485
 486   // Fire tooltip timer so tooltip becomes visible.
 487   helper_->FireTooltipTimer();
 488
 489   EXPECT_TRUE(helper_->IsTooltipVisible());
 490   view_->GetWidget()->ReleaseCapture();
 491   EXPECT_FALSE(helper_->IsTooltipVisible());
 492   EXPECT_TRUE(helper_->GetTooltipWindow() == NULL);
 493 }
 494
 495 // Disabled on linux as DesktopScreenX11::GetWindowAtScreenPoint() doesn't
 496 // consider z-order.
 497 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 498 #define MAYBE_Capture DISABLED_Capture
 499 #else
 500 #define MAYBE_Capture Capture
 501 #endif
 502 // Verifies the correct window is found for tooltips when there is a capture.
 503 TEST_F(TooltipControllerCaptureTest, MAYBE_Capture) {
 504   const base::string16 tooltip_text(ASCIIToUTF16("1"));
 505   const base::string16 tooltip_text2(ASCIIToUTF16("2"));
 506
 507   widget_->SetBounds(gfx::Rect(0, 0, 200, 200));
 508   view_->set_tooltip_text(tooltip_text);
 509
 510   scoped_ptr<views::Widget> widget2(CreateWidget(root_window()));
 511   widget2->SetContentsView(new View);
 512   TooltipTestView* view2 = new TooltipTestView;
 513   widget2->GetContentsView()->AddChildView(view2);
 514   view2->set_tooltip_text(tooltip_text2);
 515   widget2->SetBounds(gfx::Rect(0, 0, 200, 200));
 516   view2->SetBoundsRect(widget2->GetContentsView()->GetLocalBounds());
 517
 518   widget_->SetCapture(view_);
 519   EXPECT_TRUE(widget_->HasCapture());
 520   widget2->Show();
 521   EXPECT_GE(IndexInParent(widget2->GetNativeWindow()),
 522             IndexInParent(widget_->GetNativeWindow()));
 523
 524   generator_->MoveMouseRelativeTo(widget_->GetNativeWindow(),
 525                                   view_->bounds().CenterPoint());
 526
 527   EXPECT_TRUE(helper_->IsTooltipTimerRunning());
 528   helper_->FireTooltipTimer();
 529   // Even though the mouse is over a window with a tooltip it shouldn't be
 530   // picked up because the windows don't have the same value for
 531   // |TooltipManager::kGroupingPropertyKey|.
 532   EXPECT_TRUE(helper_->GetTooltipText().empty());
 533
 534   // Now make both the windows have same transient value for
 535   // kGroupingPropertyKey. In this case the tooltip should be picked up from
 536   // |widget2| (because the mouse is over it).
 537   const int grouping_key = 1;
 538   widget_->SetNativeWindowProperty(TooltipManager::kGroupingPropertyKey,
 539                                    reinterpret_cast<void*>(grouping_key));
 540   widget2->SetNativeWindowProperty(TooltipManager::kGroupingPropertyKey,
 541                                    reinterpret_cast<void*>(grouping_key));
 542   generator_->MoveMouseBy(1, 10);
 543   EXPECT_TRUE(helper_->IsTooltipTimerRunning());
 544   helper_->FireTooltipTimer();
 545   EXPECT_EQ(tooltip_text2, helper_->GetTooltipText());
 546
 547   widget2.reset();
 548 }
 549
 550 namespace {
 551
 552 class TestTooltip : public Tooltip {
 553  public:
 554   TestTooltip() : is_visible_(false) {}
 555   virtual ~TestTooltip() {}
 556
 557   const base::string16& tooltip_text() const { return tooltip_text_; }
 558
 559   // Tooltip:
 560   virtual void SetText(aura::Window* window,
 561                        const base::string16& tooltip_text,
 562                        const gfx::Point& location) OVERRIDE {
 563     tooltip_text_ = tooltip_text;
 564     location_ = location;
 565   }
 566   virtual void Show() OVERRIDE {
 567     is_visible_ = true;
 568   }
 569   virtual void Hide() OVERRIDE {
 570     is_visible_ = false;
 571   }
 572   virtual bool IsVisible() OVERRIDE {
 573     return is_visible_;
 574   }
 575   const gfx::Point& location() { return location_; }
 576
 577  private:
 578   bool is_visible_;
 579   base::string16 tooltip_text_;
 580   gfx::Point location_;
 581
 582   DISALLOW_COPY_AND_ASSIGN(TestTooltip);
 583 };
 584
 585 }  // namespace
 586
 587 // Use for tests that don't depend upon views.
 588 class TooltipControllerTest2 : public aura::test::AuraTestBase {
 589  public:
 590   TooltipControllerTest2() : test_tooltip_(new TestTooltip) {}
 591   virtual ~TooltipControllerTest2() {}
 592
 593   virtual void SetUp() OVERRIDE {
 594     wm_state_.reset(new wm::WMState);
 595     aura::test::AuraTestBase::SetUp();
 596     new wm::DefaultActivationClient(root_window());
 597     controller_.reset(new TooltipController(
 598                           scoped_ptr<corewm::Tooltip>(test_tooltip_)));
 599     root_window()->AddPreTargetHandler(controller_.get());
 600     SetTooltipClient(root_window(), controller_.get());
 601     helper_.reset(new TooltipControllerTestHelper(controller_.get()));
 602     generator_.reset(new ui::test::EventGenerator(root_window()));
 603   }
 604
 605   virtual void TearDown() OVERRIDE {
 606     root_window()->RemovePreTargetHandler(controller_.get());
 607     aura::client::SetTooltipClient(root_window(), NULL);
 608     controller_.reset();
 609     generator_.reset();
 610     helper_.reset();
 611     aura::test::AuraTestBase::TearDown();
 612     wm_state_.reset();
 613   }
 614
 615  protected:
 616   // Owned by |controller_|.
 617   TestTooltip* test_tooltip_;
 618   scoped_ptr<TooltipControllerTestHelper> helper_;
 619   scoped_ptr<ui::test::EventGenerator> generator_;
 620
 621  private:
 622   scoped_ptr<TooltipController> controller_;
 623   scoped_ptr<wm::WMState> wm_state_;
 624
 625   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest2);
 626 };
 627
 628 TEST_F(TooltipControllerTest2, VerifyLeadingTrailingWhitespaceStripped) {
 629   aura::test::TestWindowDelegate test_delegate;
 630   scoped_ptr<aura::Window> window(
 631       CreateNormalWindow(100, root_window(), &test_delegate));
 632   window->SetBounds(gfx::Rect(0, 0, 300, 300));
 633   base::string16 tooltip_text(ASCIIToUTF16(" \nx  "));
 634   aura::client::SetTooltipText(window.get(), &tooltip_text);
 635   generator_->MoveMouseToCenterOf(window.get());
 636   helper_->FireTooltipTimer();
 637   EXPECT_EQ(ASCIIToUTF16("x"), test_tooltip_->tooltip_text());
 638 }
 639
 640 // Verifies that tooltip is hidden and tooltip window closed upon cancel mode.
 641 TEST_F(TooltipControllerTest2, CloseOnCancelMode) {
 642   aura::test::TestWindowDelegate test_delegate;
 643   scoped_ptr<aura::Window> window(
 644       CreateNormalWindow(100, root_window(), &test_delegate));
 645   window->SetBounds(gfx::Rect(0, 0, 300, 300));
 646   base::string16 tooltip_text(ASCIIToUTF16("Tooltip Text"));
 647   aura::client::SetTooltipText(window.get(), &tooltip_text);
 648   generator_->MoveMouseToCenterOf(window.get());
 649
 650   // Fire tooltip timer so tooltip becomes visible.
 651   helper_->FireTooltipTimer();
 652   EXPECT_TRUE(helper_->IsTooltipVisible());
 653
 654   // Send OnCancelMode event and verify that tooltip becomes invisible and
 655   // the tooltip window is closed.
 656   ui::CancelModeEvent event;
 657   helper_->controller()->OnCancelMode(&event);
 658   EXPECT_FALSE(helper_->IsTooltipVisible());
 659   EXPECT_TRUE(helper_->GetTooltipWindow() == NULL);
 660 }
 661
 662 // Use for tests that need both views and a TestTooltip.
 663 class TooltipControllerTest3 : public aura::test::AuraTestBase {
 664  public:
 665   TooltipControllerTest3() : test_tooltip_(new TestTooltip) {}
 666   virtual ~TooltipControllerTest3() {}
 667
 668   virtual void SetUp() OVERRIDE {
 669     wm_state_.reset(new wm::WMState);
 670     aura::test::AuraTestBase::SetUp();
 671     new wm::DefaultActivationClient(root_window());
 672
 673     widget_.reset(CreateWidget(root_window()));
 674     widget_->SetContentsView(new View);
 675     view_ = new TooltipTestView;
 676     widget_->GetContentsView()->AddChildView(view_);
 677     view_->SetBoundsRect(widget_->GetContentsView()->GetLocalBounds());
 678
 679     generator_.reset(new ui::test::EventGenerator(GetRootWindow()));
 680     controller_.reset(new TooltipController(
 681         scoped_ptr<views::corewm::Tooltip>(test_tooltip_)));
 682     GetRootWindow()->RemovePreTargetHandler(
 683         static_cast<TooltipController*>(aura::client::GetTooltipClient(
 684             widget_->GetNativeWindow()->GetRootWindow())));
 685     GetRootWindow()->AddPreTargetHandler(controller_.get());
 686     helper_.reset(new TooltipControllerTestHelper(controller_.get()));
 687     SetTooltipClient(GetRootWindow(), controller_.get());
 688   }
 689
 690   virtual void TearDown() OVERRIDE {
 691     GetRootWindow()->RemovePreTargetHandler(controller_.get());
 692     aura::client::SetTooltipClient(GetRootWindow(), NULL);
 693
 694     controller_.reset();
 695     generator_.reset();
 696     helper_.reset();
 697     widget_.reset();
 698     aura::test::AuraTestBase::TearDown();
 699     wm_state_.reset();
 700   }
 701
 702   aura::Window* GetWindow() { return widget_->GetNativeWindow(); }
 703
 704  protected:
 705   // Owned by |controller_|.
 706   TestTooltip* test_tooltip_;
 707   scoped_ptr<TooltipControllerTestHelper> helper_;
 708   scoped_ptr<ui::test::EventGenerator> generator_;
 709   scoped_ptr<views::Widget> widget_;
 710   TooltipTestView* view_;
 711
 712  private:
 713   scoped_ptr<TooltipController> controller_;
 714   scoped_ptr<wm::WMState> wm_state_;
 715
 716 #if defined(OS_WIN)
 717   ui::ScopedOleInitializer ole_initializer_;
 718 #endif
 719
 720   aura::Window* GetRootWindow() { return GetWindow()->GetRootWindow(); }
 721
 722   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest3);
 723 };
 724
 725 TEST_F(TooltipControllerTest3, TooltipPositionChangesOnTwoViewsWithSameLabel) {
 726   // Owned by |view_|.
 727   // These two views have the same tooltip text
 728   TooltipTestView* v1 = new TooltipTestView;
 729   TooltipTestView* v2 = new TooltipTestView;
 730   // v1_1 is a view inside v1 that has an identical tooltip text to that of v1
 731   // and v2
 732   TooltipTestView* v1_1 = new TooltipTestView;
 733   // v2_1 is a view inside v2 that has an identical tooltip text to that of v1
 734   // and v2
 735   TooltipTestView* v2_1 = new TooltipTestView;
 736   // v2_2 is a view inside v2 with the tooltip text different from all the
 737   // others
 738   TooltipTestView* v2_2 = new TooltipTestView;
 739
 740   // Setup all the views' relations
 741   view_->AddChildView(v1);
 742   view_->AddChildView(v2);
 743   v1->AddChildView(v1_1);
 744   v2->AddChildView(v2_1);
 745   v2->AddChildView(v2_2);
 746   const base::string16 reference_string(
 747       base::ASCIIToUTF16("Identical Tooltip Text"));
 748   const base::string16 alternative_string(
 749       base::ASCIIToUTF16("Another Shrubbery"));
 750   v1->set_tooltip_text(reference_string);
 751   v2->set_tooltip_text(reference_string);
 752   v1_1->set_tooltip_text(reference_string);
 753   v2_1->set_tooltip_text(reference_string);
 754   v2_2->set_tooltip_text(alternative_string);
 755
 756   // Set views' bounds
 757   gfx::Rect view_bounds(view_->GetLocalBounds());
 758   view_bounds.set_height(view_bounds.height() / 2);
 759   v1->SetBoundsRect(view_bounds);
 760   v1_1->SetBounds(0, 0, 3, 3);
 761   view_bounds.set_y(view_bounds.height());
 762   v2->SetBoundsRect(view_bounds);
 763   v2_2->SetBounds(view_bounds.width() - 3, view_bounds.height() - 3, 3, 3);
 764   v2_1->SetBounds(0, 0, 3, 3);
 765
 766   // Test whether a toolbar appears on v1
 767   gfx::Point center = v1->bounds().CenterPoint();
 768   generator_->MoveMouseRelativeTo(GetWindow(), center);
 769   helper_->FireTooltipTimer();
 770   EXPECT_TRUE(helper_->IsTooltipVisible());
 771   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 772   gfx::Point tooltip_bounds1 = test_tooltip_->location();
 773
 774   // Test whether the toolbar changes position on mouse over v2
 775   center = v2->bounds().CenterPoint();
 776   generator_->MoveMouseRelativeTo(GetWindow(), center);
 777   helper_->FireTooltipTimer();
 778   EXPECT_TRUE(helper_->IsTooltipVisible());
 779   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 780   gfx::Point tooltip_bounds2 = test_tooltip_->location();
 781
 782   EXPECT_NE(tooltip_bounds1, gfx::Point());
 783   EXPECT_NE(tooltip_bounds2, gfx::Point());
 784   EXPECT_NE(tooltip_bounds1, tooltip_bounds2);
 785
 786   // Test if the toolbar does not change position on encountering a contained
 787   // view with the same tooltip text
 788   center = v2_1->GetLocalBounds().CenterPoint();
 789   views::View::ConvertPointToTarget(v2_1, view_, &center);
 790   generator_->MoveMouseRelativeTo(GetWindow(), center);
 791   helper_->FireTooltipTimer();
 792   gfx::Point tooltip_bounds2_1 = test_tooltip_->location();
 793
 794   EXPECT_NE(tooltip_bounds2, tooltip_bounds2_1);
 795   EXPECT_TRUE(helper_->IsTooltipVisible());
 796   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 797
 798   // Test if the toolbar changes position on encountering a contained
 799   // view with a different tooltip text
 800   center = v2_2->GetLocalBounds().CenterPoint();
 801   views::View::ConvertPointToTarget(v2_2, view_, &center);
 802   generator_->MoveMouseRelativeTo(GetWindow(), center);
 803   helper_->FireTooltipTimer();
 804   gfx::Point tooltip_bounds2_2 = test_tooltip_->location();
 805
 806   EXPECT_NE(tooltip_bounds2_1, tooltip_bounds2_2);
 807   EXPECT_TRUE(helper_->IsTooltipVisible());
 808   EXPECT_EQ(alternative_string, helper_->GetTooltipText());
 809
 810   // Test if moving from a view that is contained by a larger view, both with
 811   // the same tooltip text, does not change tooltip's position.
 812   center = v1_1->GetLocalBounds().CenterPoint();
 813   views::View::ConvertPointToTarget(v1_1, view_, &center);
 814   generator_->MoveMouseRelativeTo(GetWindow(), center);
 815   helper_->FireTooltipTimer();
 816   gfx::Point tooltip_bounds1_1 = test_tooltip_->location();
 817
 818   EXPECT_TRUE(helper_->IsTooltipVisible());
 819   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 820
 821   center = v1->bounds().CenterPoint();
 822   generator_->MoveMouseRelativeTo(GetWindow(), center);
 823   helper_->FireTooltipTimer();
 824   tooltip_bounds1 = test_tooltip_->location();
 825
 826   EXPECT_NE(tooltip_bounds1_1, tooltip_bounds1);
 827   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 828 }
 829
 830 }  // namespace test
 831 }  // namespace corewm
 832 }  // namespace views