ash/system/tray/system_tray_unittest.cc

   1 // Copyright (c) 2012 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/system/tray/system_tray.h"
   6
   7 #include <vector>
   8
   9 #include "ash/accessibility_delegate.h"
  10 #include "ash/root_window_controller.h"
  11 #include "ash/shelf/shelf_layout_manager.h"
  12 #include "ash/shelf/shelf_widget.h"
  13 #include "ash/shell.h"
  14 #include "ash/system/status_area_widget.h"
  15 #include "ash/system/tray/system_tray_item.h"
  16 #include "ash/system/tray/tray_constants.h"
  17 #include "ash/test/ash_test_base.h"
  18 #include "ash/wm/window_util.h"
  19 #include "base/run_loop.h"
  20 #include "base/strings/utf_string_conversions.h"
  21 #include "ui/aura/window.h"
  22 #include "ui/base/ui_base_types.h"
  23 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  24 #include "ui/events/test/event_generator.h"
  25 #include "ui/gfx/geometry/rect.h"
  26 #include "ui/views/controls/label.h"
  27 #include "ui/views/layout/fill_layout.h"
  28 #include "ui/views/view.h"
  29 #include "ui/views/widget/widget.h"
  30 #include "ui/views/widget/widget_delegate.h"
  31
  32 #if defined(OS_WIN)
  33 #include "base/win/windows_version.h"
  34 #endif
  35
  36 namespace ash {
  37 namespace test {
  38
  39 namespace {
  40
  41 SystemTray* GetSystemTray() {
  42   return Shell::GetPrimaryRootWindowController()->shelf()->
  43       status_area_widget()->system_tray();
  44 }
  45
  46 // Trivial item implementation that tracks its views for testing.
  47 class TestItem : public SystemTrayItem {
  48  public:
  49   TestItem() : SystemTrayItem(GetSystemTray()), tray_view_(NULL) {}
  50
  51   virtual views::View* CreateTrayView(user::LoginStatus status) OVERRIDE {
  52     tray_view_ = new views::View;
  53     // Add a label so it has non-zero width.
  54     tray_view_->SetLayoutManager(new views::FillLayout);
  55     tray_view_->AddChildView(new views::Label(base::UTF8ToUTF16("Tray")));
  56     return tray_view_;
  57   }
  58
  59   virtual views::View* CreateDefaultView(user::LoginStatus status) OVERRIDE {
  60     default_view_ = new views::View;
  61     default_view_->SetLayoutManager(new views::FillLayout);
  62     default_view_->AddChildView(new views::Label(base::UTF8ToUTF16("Default")));
  63     return default_view_;
  64   }
  65
  66   virtual views::View* CreateDetailedView(user::LoginStatus status) OVERRIDE {
  67     detailed_view_ = new views::View;
  68     detailed_view_->SetLayoutManager(new views::FillLayout);
  69     detailed_view_->AddChildView(
  70         new views::Label(base::UTF8ToUTF16("Detailed")));
  71     return detailed_view_;
  72   }
  73
  74   virtual views::View* CreateNotificationView(
  75       user::LoginStatus status) OVERRIDE {
  76     notification_view_ = new views::View;
  77     return notification_view_;
  78   }
  79
  80   virtual void DestroyTrayView() OVERRIDE {
  81     tray_view_ = NULL;
  82   }
  83
  84   virtual void DestroyDefaultView() OVERRIDE {
  85     default_view_ = NULL;
  86   }
  87
  88   virtual void DestroyDetailedView() OVERRIDE {
  89     detailed_view_ = NULL;
  90   }
  91
  92   virtual void DestroyNotificationView() OVERRIDE {
  93     notification_view_ = NULL;
  94   }
  95
  96   virtual void UpdateAfterLoginStatusChange(
  97       user::LoginStatus status) OVERRIDE {
  98   }
  99
 100   views::View* tray_view() const { return tray_view_; }
 101   views::View* default_view() const { return default_view_; }
 102   views::View* detailed_view() const { return detailed_view_; }
 103   views::View* notification_view() const { return notification_view_; }
 104
 105  private:
 106   views::View* tray_view_;
 107   views::View* default_view_;
 108   views::View* detailed_view_;
 109   views::View* notification_view_;
 110 };
 111
 112 // Trivial item implementation that returns NULL from tray/default/detailed
 113 // view creation methods.
 114 class TestNoViewItem : public SystemTrayItem {
 115  public:
 116   TestNoViewItem() : SystemTrayItem(GetSystemTray()) {}
 117
 118   virtual views::View* CreateTrayView(user::LoginStatus status) OVERRIDE {
 119     return NULL;
 120   }
 121
 122   virtual views::View* CreateDefaultView(user::LoginStatus status) OVERRIDE {
 123     return NULL;
 124   }
 125
 126   virtual views::View* CreateDetailedView(user::LoginStatus status) OVERRIDE {
 127     return NULL;
 128   }
 129
 130   virtual views::View* CreateNotificationView(
 131       user::LoginStatus status) OVERRIDE {
 132     return NULL;
 133   }
 134
 135   virtual void DestroyTrayView() OVERRIDE {}
 136   virtual void DestroyDefaultView() OVERRIDE {}
 137   virtual void DestroyDetailedView() OVERRIDE {}
 138   virtual void DestroyNotificationView() OVERRIDE {}
 139   virtual void UpdateAfterLoginStatusChange(
 140       user::LoginStatus status) OVERRIDE {
 141   }
 142 };
 143
 144 class ModalWidgetDelegate : public views::WidgetDelegateView {
 145  public:
 146   ModalWidgetDelegate() {}
 147   virtual ~ModalWidgetDelegate() {}
 148
 149   virtual views::View* GetContentsView() OVERRIDE { return this; }
 150   virtual ui::ModalType GetModalType() const OVERRIDE {
 151     return ui::MODAL_TYPE_SYSTEM;
 152   }
 153
 154  private:
 155   DISALLOW_COPY_AND_ASSIGN(ModalWidgetDelegate);
 156 };
 157
 158 }  // namespace
 159
 160 typedef AshTestBase SystemTrayTest;
 161
 162 TEST_F(SystemTrayTest, SystemTrayDefaultView) {
 163   SystemTray* tray = GetSystemTray();
 164   ASSERT_TRUE(tray->GetWidget());
 165
 166   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 167
 168   // Ensure that closing the bubble destroys it.
 169   ASSERT_TRUE(tray->CloseSystemBubble());
 170   RunAllPendingInMessageLoop();
 171   ASSERT_FALSE(tray->CloseSystemBubble());
 172 }
 173
 174 // Opening and closing the bubble should change the coloring of the tray.
 175 TEST_F(SystemTrayTest, SystemTrayColoring) {
 176   SystemTray* tray = GetSystemTray();
 177   ASSERT_TRUE(tray->GetWidget());
 178   // At the beginning the tray coloring is not active.
 179   ASSERT_FALSE(tray->draw_background_as_active());
 180
 181   // Showing the system bubble should show the background as active.
 182   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 183   ASSERT_TRUE(tray->draw_background_as_active());
 184
 185   // Closing the system menu should change the coloring back to normal.
 186   ASSERT_TRUE(tray->CloseSystemBubble());
 187   RunAllPendingInMessageLoop();
 188   ASSERT_FALSE(tray->draw_background_as_active());
 189 }
 190
 191 // Closing the system bubble through an alignment change should change the
 192 // system tray coloring back to normal.
 193 TEST_F(SystemTrayTest, SystemTrayColoringAfterAlignmentChange) {
 194   SystemTray* tray = GetSystemTray();
 195   ASSERT_TRUE(tray->GetWidget());
 196   ShelfLayoutManager* manager =
 197       Shell::GetPrimaryRootWindowController()->shelf()->shelf_layout_manager();
 198   manager->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
 199   // At the beginning the tray coloring is not active.
 200   ASSERT_FALSE(tray->draw_background_as_active());
 201
 202   // Showing the system bubble should show the background as active.
 203   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 204   ASSERT_TRUE(tray->draw_background_as_active());
 205
 206   // Changing the alignment should close the system bubble and change the
 207   // background color.
 208   manager->SetAlignment(SHELF_ALIGNMENT_LEFT);
 209   ASSERT_FALSE(tray->draw_background_as_active());
 210   RunAllPendingInMessageLoop();
 211   // The bubble should already be closed by now.
 212   ASSERT_FALSE(tray->CloseSystemBubble());
 213 }
 214
 215 TEST_F(SystemTrayTest, SystemTrayTestItems) {
 216   SystemTray* tray = GetSystemTray();
 217   ASSERT_TRUE(tray->GetWidget());
 218
 219   TestItem* test_item = new TestItem;
 220   TestItem* detailed_item = new TestItem;
 221   tray->AddTrayItem(test_item);
 222   tray->AddTrayItem(detailed_item);
 223
 224   // Check items have been added
 225   const std::vector<SystemTrayItem*>& items = tray->GetTrayItems();
 226   ASSERT_TRUE(
 227       std::find(items.begin(), items.end(), test_item) != items.end());
 228   ASSERT_TRUE(
 229       std::find(items.begin(), items.end(), detailed_item) != items.end());
 230
 231   // Ensure the tray views are created.
 232   ASSERT_TRUE(test_item->tray_view() != NULL);
 233   ASSERT_TRUE(detailed_item->tray_view() != NULL);
 234
 235   // Ensure a default views are created.
 236   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 237   ASSERT_TRUE(test_item->default_view() != NULL);
 238   ASSERT_TRUE(detailed_item->default_view() != NULL);
 239
 240   // Show the detailed view, ensure it's created and the default view destroyed.
 241   tray->ShowDetailedView(detailed_item, 0, false, BUBBLE_CREATE_NEW);
 242   RunAllPendingInMessageLoop();
 243   ASSERT_TRUE(test_item->default_view() == NULL);
 244   ASSERT_TRUE(detailed_item->detailed_view() != NULL);
 245
 246   // Show the default view, ensure it's created and the detailed view destroyed.
 247   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 248   RunAllPendingInMessageLoop();
 249   ASSERT_TRUE(test_item->default_view() != NULL);
 250   ASSERT_TRUE(detailed_item->detailed_view() == NULL);
 251 }
 252
 253 TEST_F(SystemTrayTest, SystemTrayNoViewItems) {
 254   SystemTray* tray = GetSystemTray();
 255   ASSERT_TRUE(tray->GetWidget());
 256
 257   // Verify that no crashes occur on items lacking some views.
 258   TestNoViewItem* no_view_item = new TestNoViewItem;
 259   tray->AddTrayItem(no_view_item);
 260   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 261   tray->ShowDetailedView(no_view_item, 0, false, BUBBLE_USE_EXISTING);
 262   RunAllPendingInMessageLoop();
 263 }
 264
 265 TEST_F(SystemTrayTest, TrayWidgetAutoResizes) {
 266   SystemTray* tray = GetSystemTray();
 267   ASSERT_TRUE(tray->GetWidget());
 268
 269   // Add an initial tray item so that the tray gets laid out correctly.
 270   TestItem* initial_item = new TestItem;
 271   tray->AddTrayItem(initial_item);
 272
 273   gfx::Size initial_size = tray->GetWidget()->GetWindowBoundsInScreen().size();
 274
 275   TestItem* new_item = new TestItem;
 276   tray->AddTrayItem(new_item);
 277
 278   gfx::Size new_size = tray->GetWidget()->GetWindowBoundsInScreen().size();
 279
 280   // Adding the new item should change the size of the tray.
 281   EXPECT_NE(initial_size.ToString(), new_size.ToString());
 282
 283   // Hiding the tray view of the new item should also change the size of the
 284   // tray.
 285   new_item->tray_view()->SetVisible(false);
 286   EXPECT_EQ(initial_size.ToString(),
 287             tray->GetWidget()->GetWindowBoundsInScreen().size().ToString());
 288
 289   new_item->tray_view()->SetVisible(true);
 290   EXPECT_EQ(new_size.ToString(),
 291             tray->GetWidget()->GetWindowBoundsInScreen().size().ToString());
 292 }
 293
 294 TEST_F(SystemTrayTest, SystemTrayNotifications) {
 295   SystemTray* tray = GetSystemTray();
 296   ASSERT_TRUE(tray->GetWidget());
 297
 298   TestItem* test_item = new TestItem;
 299   TestItem* detailed_item = new TestItem;
 300   tray->AddTrayItem(test_item);
 301   tray->AddTrayItem(detailed_item);
 302
 303   // Ensure the tray views are created.
 304   ASSERT_TRUE(test_item->tray_view() != NULL);
 305   ASSERT_TRUE(detailed_item->tray_view() != NULL);
 306
 307   // Ensure a notification view is created.
 308   tray->ShowNotificationView(test_item);
 309   ASSERT_TRUE(test_item->notification_view() != NULL);
 310
 311   // Show the default view, notification view should remain.
 312   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 313   RunAllPendingInMessageLoop();
 314   ASSERT_TRUE(test_item->notification_view() != NULL);
 315
 316   // Show the detailed view, ensure the notification view remains.
 317   tray->ShowDetailedView(detailed_item, 0, false, BUBBLE_CREATE_NEW);
 318   RunAllPendingInMessageLoop();
 319   ASSERT_TRUE(detailed_item->detailed_view() != NULL);
 320   ASSERT_TRUE(test_item->notification_view() != NULL);
 321
 322   // Hide the detailed view, ensure the notification view still exists.
 323   ASSERT_TRUE(tray->CloseSystemBubble());
 324   RunAllPendingInMessageLoop();
 325   ASSERT_TRUE(detailed_item->detailed_view() == NULL);
 326   ASSERT_TRUE(test_item->notification_view() != NULL);
 327 }
 328
 329 TEST_F(SystemTrayTest, BubbleCreationTypesTest) {
 330   SystemTray* tray = GetSystemTray();
 331   ASSERT_TRUE(tray->GetWidget());
 332
 333   TestItem* test_item = new TestItem;
 334   tray->AddTrayItem(test_item);
 335
 336   // Ensure the tray views are created.
 337   ASSERT_TRUE(test_item->tray_view() != NULL);
 338
 339   // Show the default view, ensure the notification view is destroyed.
 340   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 341   RunAllPendingInMessageLoop();
 342
 343   views::Widget* widget = test_item->default_view()->GetWidget();
 344   gfx::Rect bubble_bounds = widget->GetWindowBoundsInScreen();
 345
 346   tray->ShowDetailedView(test_item, 0, true, BUBBLE_USE_EXISTING);
 347   RunAllPendingInMessageLoop();
 348
 349   EXPECT_FALSE(test_item->default_view());
 350
 351   EXPECT_EQ(bubble_bounds.ToString(), test_item->detailed_view()->GetWidget()->
 352       GetWindowBoundsInScreen().ToString());
 353   EXPECT_EQ(widget, test_item->detailed_view()->GetWidget());
 354
 355   tray->ShowDefaultView(BUBBLE_USE_EXISTING);
 356   RunAllPendingInMessageLoop();
 357
 358   EXPECT_EQ(bubble_bounds.ToString(), test_item->default_view()->GetWidget()->
 359       GetWindowBoundsInScreen().ToString());
 360   EXPECT_EQ(widget, test_item->default_view()->GetWidget());
 361 }
 362
 363 // Tests that the tray is laid out properly and is fully contained within
 364 // the shelf.
 365 TEST_F(SystemTrayTest, TrayBoundsInWidget) {
 366   ShelfLayoutManager* manager =
 367       Shell::GetPrimaryRootWindowController()->shelf()->shelf_layout_manager();
 368   StatusAreaWidget* widget =
 369       Shell::GetPrimaryRootWindowController()->shelf()->status_area_widget();
 370   SystemTray* tray = widget->system_tray();
 371
 372   // Test in bottom alignment.
 373   manager->SetAlignment(SHELF_ALIGNMENT_BOTTOM);
 374   gfx::Rect window_bounds = widget->GetWindowBoundsInScreen();
 375   gfx::Rect tray_bounds = tray->GetBoundsInScreen();
 376   EXPECT_TRUE(window_bounds.bottom() >= tray_bounds.bottom());
 377   EXPECT_TRUE(window_bounds.right() >= tray_bounds.right());
 378   EXPECT_TRUE(window_bounds.x() >= tray_bounds.x());
 379   EXPECT_TRUE(window_bounds.y() >= tray_bounds.y());
 380
 381   // Test in the left alignment.
 382   manager->SetAlignment(SHELF_ALIGNMENT_LEFT);
 383   window_bounds = widget->GetWindowBoundsInScreen();
 384   tray_bounds = tray->GetBoundsInScreen();
 385   EXPECT_TRUE(window_bounds.bottom() >= tray_bounds.bottom());
 386   EXPECT_TRUE(window_bounds.right() >= tray_bounds.right());
 387   EXPECT_TRUE(window_bounds.x() >= tray_bounds.x());
 388   EXPECT_TRUE(window_bounds.y() >= tray_bounds.y());
 389
 390   // Test in the right alignment.
 391   manager->SetAlignment(SHELF_ALIGNMENT_LEFT);
 392   window_bounds = widget->GetWindowBoundsInScreen();
 393   tray_bounds = tray->GetBoundsInScreen();
 394   EXPECT_TRUE(window_bounds.bottom() >= tray_bounds.bottom());
 395   EXPECT_TRUE(window_bounds.right() >= tray_bounds.right());
 396   EXPECT_TRUE(window_bounds.x() >= tray_bounds.x());
 397   EXPECT_TRUE(window_bounds.y() >= tray_bounds.y());
 398 }
 399
 400 TEST_F(SystemTrayTest, PersistentBubble) {
 401   SystemTray* tray = GetSystemTray();
 402   ASSERT_TRUE(tray->GetWidget());
 403
 404   TestItem* test_item = new TestItem;
 405   tray->AddTrayItem(test_item);
 406
 407   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(0));
 408
 409   // Tests for usual default view.
 410   // Activating window.
 411   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 412   ASSERT_TRUE(tray->HasSystemBubble());
 413   wm::ActivateWindow(window.get());
 414   base::RunLoop().RunUntilIdle();
 415   ASSERT_FALSE(tray->HasSystemBubble());
 416
 417   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 418   ASSERT_TRUE(tray->HasSystemBubble());
 419   {
 420     ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 421                                        gfx::Point(5, 5));
 422     generator.ClickLeftButton();
 423     ASSERT_FALSE(tray->HasSystemBubble());
 424   }
 425
 426   // Same tests for persistent default view.
 427   tray->ShowPersistentDefaultView();
 428   ASSERT_TRUE(tray->HasSystemBubble());
 429   wm::ActivateWindow(window.get());
 430   base::RunLoop().RunUntilIdle();
 431   ASSERT_TRUE(tray->HasSystemBubble());
 432
 433   {
 434     ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 435                                        gfx::Point(5, 5));
 436     generator.ClickLeftButton();
 437     ASSERT_TRUE(tray->HasSystemBubble());
 438   }
 439 }
 440
 441 #if defined(OS_CHROMEOS)
 442 // Accessibility/Settings tray items are available only on cros.
 443 #define MAYBE_WithSystemModal WithSystemModal
 444 #else
 445 #define MAYBE_WithSystemModal DISABLED_WithSystemModal
 446 #endif
 447 TEST_F(SystemTrayTest, MAYBE_WithSystemModal) {
 448   // Check if the accessibility item is created even with system modal
 449   // dialog.
 450   Shell::GetInstance()->accessibility_delegate()->SetVirtualKeyboardEnabled(
 451       true);
 452   views::Widget* widget = views::Widget::CreateWindowWithContextAndBounds(
 453       new ModalWidgetDelegate(),
 454       Shell::GetPrimaryRootWindow(),
 455       gfx::Rect(0, 0, 100, 100));
 456   widget->Show();
 457
 458   SystemTray* tray = GetSystemTray();
 459   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 460
 461   ASSERT_TRUE(tray->HasSystemBubble());
 462   const views::View* accessibility =
 463       tray->GetSystemBubble()->bubble_view()->GetViewByID(
 464           test::kAccessibilityTrayItemViewId);
 465   ASSERT_TRUE(accessibility);
 466   EXPECT_TRUE(accessibility->visible());
 467   EXPECT_FALSE(tray->GetSystemBubble()->bubble_view()->GetViewByID(
 468       test::kSettingsTrayItemViewId));
 469
 470   widget->Close();
 471
 472   tray->ShowDefaultView(BUBBLE_CREATE_NEW);
 473   // System modal is gone. The bubble should now contains settings
 474   // as well.
 475   accessibility = tray->GetSystemBubble()->bubble_view()->GetViewByID(
 476       test::kAccessibilityTrayItemViewId);
 477   ASSERT_TRUE(accessibility);
 478   EXPECT_TRUE(accessibility->visible());
 479
 480   const views::View* settings =
 481       tray->GetSystemBubble()->bubble_view()->GetViewByID(
 482           test::kSettingsTrayItemViewId);
 483   ASSERT_TRUE(settings);
 484   EXPECT_TRUE(settings->visible());
 485 }
 486
 487 // Tests that if SetVisible(true) is called while animating to hidden that the
 488 // tray becomes visible, and stops animating to hidden.
 489 TEST_F(SystemTrayTest, SetVisibleDuringHideAnimation) {
 490   SystemTray* tray = GetSystemTray();
 491   ASSERT_TRUE(tray->visible());
 492
 493   scoped_ptr<ui::ScopedAnimationDurationScaleMode> animation_duration;
 494   animation_duration.reset(
 495       new ui::ScopedAnimationDurationScaleMode(
 496           ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
 497   tray->SetVisible(false);
 498   EXPECT_TRUE(tray->visible());
 499   EXPECT_EQ(0.0f, tray->layer()->GetTargetOpacity());
 500
 501   tray->SetVisible(true);
 502   animation_duration.reset();
 503   tray->layer()->GetAnimator()->StopAnimating();
 504   EXPECT_TRUE(tray->visible());
 505   EXPECT_EQ(1.0f, tray->layer()->GetTargetOpacity());
 506 }
 507
 508 }  // namespace test
 509 }  // namespace ash