ash/shelf/shelf_tooltip_manager_unittest.cc

   1 // Copyright 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 "ash/shelf/shelf_tooltip_manager.h"
   6
   7 #include "ash/root_window_controller.h"
   8 #include "ash/shelf/shelf_layout_manager.h"
   9 #include "ash/shelf/shelf_widget.h"
  10 #include "ash/shell.h"
  11 #include "ash/shell_window_ids.h"
  12 #include "ash/test/ash_test_base.h"
  13 #include "ash/test/shelf_test_api.h"
  14 #include "ash/wm/window_util.h"
  15 #include "base/strings/string16.h"
  16 #include "base/time/time.h"
  17 #include "ui/aura/window_event_dispatcher.h"
  18 #include "ui/events/event.h"
  19 #include "ui/events/event_constants.h"
  20 #include "ui/events/event_handler.h"
  21 #include "ui/events/event_utils.h"
  22 #include "ui/events/keycodes/keyboard_codes.h"
  23 #include "ui/events/test/events_test_utils.h"
  24 #include "ui/views/widget/widget.h"
  25
  26 namespace {
  27
  28 void SetEventTarget(ui::EventTarget* target,
  29                     ui::Event* event) {
  30   ui::Event::DispatcherApi dispatch_helper(event);
  31   dispatch_helper.set_target(target);
  32 }
  33
  34 }
  35
  36 namespace ash {
  37 namespace test {
  38
  39 class ShelfTooltipManagerTest : public AshTestBase {
  40  public:
  41   ShelfTooltipManagerTest() {}
  42   ~ShelfTooltipManagerTest() override {}
  43
  44   void SetUp() override {
  45     AshTestBase::SetUp();
  46     RootWindowController* controller = Shell::GetPrimaryRootWindowController();
  47     tooltip_manager_.reset(new ShelfTooltipManager(
  48         controller->GetShelfLayoutManager(),
  49         ShelfTestAPI(controller->shelf()->shelf()).shelf_view()));
  50   }
  51
  52   void TearDown() override {
  53     tooltip_manager_.reset();
  54     AshTestBase::TearDown();
  55   }
  56
  57   void ShowDelayed() {
  58     CreateWidget();
  59     tooltip_manager_->ShowDelayed(dummy_anchor_.get(), base::string16());
  60   }
  61
  62   void ShowImmediately() {
  63     CreateWidget();
  64     tooltip_manager_->ShowImmediately(dummy_anchor_.get(), base::string16());
  65   }
  66
  67   bool TooltipIsVisible() {
  68     return tooltip_manager_->IsVisible();
  69   }
  70
  71   bool IsTimerRunning() {
  72     return tooltip_manager_->timer_.get() != NULL;
  73   }
  74
  75   ui::EventHandler* GetEventHandler() {
  76     return tooltip_manager_.get();
  77   }
  78
  79   views::Widget* GetTooltipWidget() {
  80     return tooltip_manager_->widget_;
  81   }
  82
  83  protected:
  84   scoped_ptr<views::Widget> widget_;
  85   scoped_ptr<views::View> dummy_anchor_;
  86   scoped_ptr<ShelfTooltipManager> tooltip_manager_;
  87
  88  private:
  89   void CreateWidget() {
  90     dummy_anchor_.reset(new views::View);
  91
  92     widget_.reset(new views::Widget);
  93     views::Widget::InitParams params(
  94         views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
  95     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
  96     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
  97     params.parent = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
  98                                         ash::kShellWindowId_ShelfContainer);
  99
 100     widget_->Init(params);
 101     widget_->SetContentsView(dummy_anchor_.get());
 102   }
 103
 104   DISALLOW_COPY_AND_ASSIGN(ShelfTooltipManagerTest);
 105 };
 106
 107 TEST_F(ShelfTooltipManagerTest, ShowingBasics) {
 108   // ShowDelayed() should just start the timer instead of showing immediately.
 109   ShowDelayed();
 110   EXPECT_FALSE(TooltipIsVisible());
 111   EXPECT_TRUE(IsTimerRunning());
 112
 113   ShowImmediately();
 114   EXPECT_TRUE(TooltipIsVisible());
 115   EXPECT_FALSE(IsTimerRunning());
 116 }
 117
 118 TEST_F(ShelfTooltipManagerTest, HideWhenShelfIsHidden) {
 119   ShowImmediately();
 120   ASSERT_TRUE(TooltipIsVisible());
 121
 122   // Create a full-screen window to hide the shelf.
 123   scoped_ptr<views::Widget> widget(new views::Widget);
 124   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 125   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 126   params.context = CurrentContext();
 127   widget->Init(params);
 128   widget->SetFullscreen(true);
 129   widget->Show();
 130
 131   // Once the shelf is hidden, the tooltip should be invisible.
 132   ASSERT_EQ(
 133       SHELF_HIDDEN,
 134       Shell::GetPrimaryRootWindowController()->
 135           GetShelfLayoutManager()->visibility_state());
 136   EXPECT_FALSE(TooltipIsVisible());
 137
 138   // Do not show the view if the shelf is hidden.
 139   ShowImmediately();
 140   EXPECT_FALSE(TooltipIsVisible());
 141
 142   // ShowDelayed() doesn't even start the timer for the hidden shelf.
 143   ShowDelayed();
 144   EXPECT_FALSE(IsTimerRunning());
 145 }
 146
 147 TEST_F(ShelfTooltipManagerTest, HideWhenShelfIsAutoHide) {
 148   // Create a visible window so auto-hide behavior is enforced.
 149   views::Widget* dummy = new views::Widget;
 150   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 151   params.bounds = gfx::Rect(0, 0, 200, 200);
 152   params.context = CurrentContext();
 153   dummy->Init(params);
 154   dummy->Show();
 155
 156   ShowImmediately();
 157   ASSERT_TRUE(TooltipIsVisible());
 158
 159   ShelfLayoutManager* shelf =
 160       Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
 161   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 162   shelf->UpdateAutoHideState();
 163   ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 164
 165   // Tooltip visibility change for auto hide may take time.
 166   EXPECT_TRUE(TooltipIsVisible());
 167   RunAllPendingInMessageLoop();
 168   EXPECT_FALSE(TooltipIsVisible());
 169
 170   // Do not show the view if the shelf is hidden.
 171   ShowImmediately();
 172   EXPECT_FALSE(TooltipIsVisible());
 173
 174   // ShowDelayed doesn't even run the timer for the hidden shelf.
 175   ShowDelayed();
 176   EXPECT_FALSE(IsTimerRunning());
 177 }
 178
 179 TEST_F(ShelfTooltipManagerTest, ShouldHideForEvents) {
 180   ShowImmediately();
 181   ASSERT_TRUE(TooltipIsVisible());
 182
 183   aura::Window* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
 184   ui::EventHandler* event_handler = GetEventHandler();
 185
 186   // Should not hide for key events.
 187   ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE);
 188   SetEventTarget(root_window, &key_event);
 189   event_handler->OnKeyEvent(&key_event);
 190   EXPECT_FALSE(key_event.handled());
 191   EXPECT_TRUE(TooltipIsVisible());
 192
 193   // Should hide for touch events.
 194   ui::TouchEvent touch_event(
 195       ui::ET_TOUCH_PRESSED, gfx::Point(), 0, base::TimeDelta());
 196   SetEventTarget(root_window, &touch_event);
 197   event_handler->OnTouchEvent(&touch_event);
 198   EXPECT_FALSE(touch_event.handled());
 199   EXPECT_FALSE(TooltipIsVisible());
 200
 201   // Shouldn't hide if the touch happens on the tooltip.
 202   ShowImmediately();
 203   views::Widget* tooltip_widget = GetTooltipWidget();
 204   SetEventTarget(tooltip_widget->GetNativeWindow(), &touch_event);
 205   event_handler->OnTouchEvent(&touch_event);
 206   EXPECT_FALSE(touch_event.handled());
 207   EXPECT_TRUE(TooltipIsVisible());
 208
 209   // Should hide for gesture events.
 210   ui::GestureEvent gesture_event(
 211       0,
 212       0,
 213       ui::EF_NONE,
 214       base::TimeDelta::FromMilliseconds(base::Time::Now().ToDoubleT() * 1000),
 215       ui::GestureEventDetails(ui::ET_GESTURE_BEGIN));
 216   SetEventTarget(tooltip_widget->GetNativeWindow(), &gesture_event);
 217   event_handler->OnGestureEvent(&gesture_event);
 218   EXPECT_FALSE(gesture_event.handled());
 219   RunAllPendingInMessageLoop();
 220   EXPECT_FALSE(TooltipIsVisible());
 221 }
 222
 223 TEST_F(ShelfTooltipManagerTest, HideForMouseMoveEvent) {
 224   ShowImmediately();
 225   ASSERT_TRUE(TooltipIsVisible());
 226
 227   aura::Window* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
 228   ui::EventHandler* event_handler = GetEventHandler();
 229
 230   gfx::Rect tooltip_rect = GetTooltipWidget()->GetNativeWindow()->bounds();
 231   ASSERT_FALSE(tooltip_rect.IsEmpty());
 232
 233   // Shouldn't hide if the mouse is in the tooltip.
 234   ui::MouseEvent mouse_event(ui::ET_MOUSE_MOVED, tooltip_rect.CenterPoint(),
 235                              tooltip_rect.CenterPoint(), ui::EventTimeForNow(),
 236                              ui::EF_NONE, ui::EF_NONE);
 237   ui::LocatedEventTestApi test_api(&mouse_event);
 238
 239   SetEventTarget(root_window, &mouse_event);
 240   event_handler->OnMouseEvent(&mouse_event);
 241   EXPECT_FALSE(mouse_event.handled());
 242   EXPECT_TRUE(TooltipIsVisible());
 243
 244   // Should hide if the mouse is out of the tooltip.
 245   test_api.set_location(tooltip_rect.origin() + gfx::Vector2d(-1, -1));
 246   event_handler->OnMouseEvent(&mouse_event);
 247   EXPECT_FALSE(mouse_event.handled());
 248   RunAllPendingInMessageLoop();
 249   EXPECT_FALSE(TooltipIsVisible());
 250 }
 251
 252 // Checks that tooltip is hidden when mouse is pressed in anywhere.
 253 TEST_F(ShelfTooltipManagerTest, HideForMouseClickEvent) {
 254   ShowImmediately();
 255   ASSERT_TRUE(TooltipIsVisible());
 256
 257   aura::Window* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
 258   ui::EventHandler* event_handler = GetEventHandler();
 259
 260   gfx::Rect tooltip_rect = GetTooltipWidget()->GetNativeWindow()->bounds();
 261   ASSERT_FALSE(tooltip_rect.IsEmpty());
 262
 263   // Should hide if the mouse is pressed in the tooltip.
 264   ui::MouseEvent mouse_event(ui::ET_MOUSE_PRESSED, tooltip_rect.CenterPoint(),
 265                              tooltip_rect.CenterPoint(), ui::EventTimeForNow(),
 266                              ui::EF_NONE, ui::EF_NONE);
 267
 268   SetEventTarget(root_window, &mouse_event);
 269   event_handler->OnMouseEvent(&mouse_event);
 270   EXPECT_FALSE(mouse_event.handled());
 271   RunAllPendingInMessageLoop();
 272   EXPECT_FALSE(TooltipIsVisible());
 273
 274   // Should hide if the mouse is pressed outside of the tooltip.
 275   ShowImmediately();
 276   ASSERT_TRUE(TooltipIsVisible());
 277
 278   ui::LocatedEventTestApi test_api(&mouse_event);
 279   test_api.set_location(tooltip_rect.origin() + gfx::Vector2d(-1, -1));
 280
 281   SetEventTarget(root_window, &mouse_event);
 282   event_handler->OnMouseEvent(&mouse_event);
 283   EXPECT_FALSE(mouse_event.handled());
 284   RunAllPendingInMessageLoop();
 285   EXPECT_FALSE(TooltipIsVisible());
 286 }
 287
 288 }  // namespace test
 289 }  // namespace ash