ash/shelf/shelf_view_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/shelf/shelf_view.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "ash/ash_switches.h"
  11 #include "ash/root_window_controller.h"
  12 #include "ash/shelf/overflow_bubble.h"
  13 #include "ash/shelf/overflow_bubble_view.h"
  14 #include "ash/shelf/shelf.h"
  15 #include "ash/shelf/shelf_button.h"
  16 #include "ash/shelf/shelf_constants.h"
  17 #include "ash/shelf/shelf_icon_observer.h"
  18 #include "ash/shelf/shelf_item_delegate_manager.h"
  19 #include "ash/shelf/shelf_layout_manager.h"
  20 #include "ash/shelf/shelf_model.h"
  21 #include "ash/shelf/shelf_tooltip_manager.h"
  22 #include "ash/shelf/shelf_widget.h"
  23 #include "ash/shell.h"
  24 #include "ash/shell_window_ids.h"
  25 #include "ash/test/ash_test_base.h"
  26 #include "ash/test/overflow_bubble_view_test_api.h"
  27 #include "ash/test/shelf_test_api.h"
  28 #include "ash/test/shelf_view_test_api.h"
  29 #include "ash/test/shell_test_api.h"
  30 #include "ash/test/test_shelf_delegate.h"
  31 #include "ash/test/test_shelf_item_delegate.h"
  32 #include "ash/wm/coordinate_conversion.h"
  33 #include "base/basictypes.h"
  34 #include "base/command_line.h"
  35 #include "base/compiler_specific.h"
  36 #include "base/memory/scoped_ptr.h"
  37 #include "base/strings/string_number_conversions.h"
  38 #include "grit/ash_resources.h"
  39 #include "ui/aura/test/aura_test_base.h"
  40 #include "ui/aura/test/event_generator.h"
  41 #include "ui/aura/window.h"
  42 #include "ui/aura/window_event_dispatcher.h"
  43 #include "ui/base/l10n/l10n_util.h"
  44 #include "ui/compositor/layer.h"
  45 #include "ui/events/event.h"
  46 #include "ui/events/event_constants.h"
  47 #include "ui/views/view_model.h"
  48 #include "ui/views/widget/widget.h"
  49 #include "ui/views/widget/widget_delegate.h"
  50
  51 namespace ash {
  52 namespace test {
  53
  54 ////////////////////////////////////////////////////////////////////////////////
  55 // ShelfIconObserver tests.
  56
  57 class TestShelfIconObserver : public ShelfIconObserver {
  58  public:
  59   explicit TestShelfIconObserver(Shelf* shelf)
  60       : shelf_(shelf),
  61         change_notified_(false) {
  62     if (shelf_)
  63       shelf_->AddIconObserver(this);
  64   }
  65
  66   virtual ~TestShelfIconObserver() {
  67     if (shelf_)
  68       shelf_->RemoveIconObserver(this);
  69   }
  70
  71   // ShelfIconObserver implementation.
  72   virtual void OnShelfIconPositionsChanged() OVERRIDE {
  73     change_notified_ = true;
  74   }
  75
  76   int change_notified() const { return change_notified_; }
  77   void Reset() { change_notified_ = false; }
  78
  79  private:
  80   Shelf* shelf_;
  81   bool change_notified_;
  82
  83   DISALLOW_COPY_AND_ASSIGN(TestShelfIconObserver);
  84 };
  85
  86 class ShelfViewIconObserverTest : public AshTestBase {
  87  public:
  88   ShelfViewIconObserverTest() {}
  89   virtual ~ShelfViewIconObserverTest() {}
  90
  91   virtual void SetUp() OVERRIDE {
  92     AshTestBase::SetUp();
  93     Shelf* shelf = Shelf::ForPrimaryDisplay();
  94     observer_.reset(new TestShelfIconObserver(shelf));
  95
  96     shelf_view_test_.reset(
  97         new ShelfViewTestAPI(ShelfTestAPI(shelf).shelf_view()));
  98     shelf_view_test_->SetAnimationDuration(1);
  99   }
 100
 101   virtual void TearDown() OVERRIDE {
 102     observer_.reset();
 103     AshTestBase::TearDown();
 104   }
 105
 106   TestShelfIconObserver* observer() { return observer_.get(); }
 107
 108   ShelfViewTestAPI* shelf_view_test() {
 109     return shelf_view_test_.get();
 110   }
 111
 112   Shelf* ShelfForSecondaryDisplay() {
 113     return Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
 114   }
 115
 116  private:
 117   scoped_ptr<TestShelfIconObserver> observer_;
 118   scoped_ptr<ShelfViewTestAPI> shelf_view_test_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(ShelfViewIconObserverTest);
 121 };
 122
 123 // TestShelfItemDelegate which tracks whether it gets selected.
 124 class ShelfItemSelectionTracker : public TestShelfItemDelegate {
 125  public:
 126   ShelfItemSelectionTracker() : TestShelfItemDelegate(NULL), selected_(false) {
 127   }
 128
 129   virtual ~ShelfItemSelectionTracker() {
 130   }
 131
 132   // Returns true if the delegate was selected.
 133   bool WasSelected() {
 134     return selected_;
 135   }
 136
 137   // TestShelfItemDelegate:
 138   virtual bool ItemSelected(const ui::Event& event) OVERRIDE {
 139     selected_ = true;
 140     return false;
 141   }
 142
 143  private:
 144   bool selected_;
 145
 146   DISALLOW_COPY_AND_ASSIGN(ShelfItemSelectionTracker);
 147 };
 148
 149 TEST_F(ShelfViewIconObserverTest, AddRemove) {
 150   TestShelfDelegate* shelf_delegate = TestShelfDelegate::instance();
 151   ASSERT_TRUE(shelf_delegate);
 152
 153   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 154   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 155   params.bounds = gfx::Rect(0, 0, 200, 200);
 156   params.context = CurrentContext();
 157
 158   scoped_ptr<views::Widget> widget(new views::Widget());
 159   widget->Init(params);
 160   shelf_delegate->AddShelfItem(widget->GetNativeWindow());
 161   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
 162   EXPECT_TRUE(observer()->change_notified());
 163   observer()->Reset();
 164
 165   widget->Show();
 166   widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow());
 167   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
 168   EXPECT_TRUE(observer()->change_notified());
 169   observer()->Reset();
 170 }
 171
 172 // Sometimes fails on trybots on win7_aura. http://crbug.com/177135
 173 #if defined(OS_WIN)
 174 #define MAYBE_AddRemoveWithMultipleDisplays \
 175     DISABLED_AddRemoveWithMultipleDisplays
 176 #else
 177 #define MAYBE_AddRemoveWithMultipleDisplays \
 178     AddRemoveWithMultipleDisplays
 179 #endif
 180 // Make sure creating/deleting an window on one displays notifies a
 181 // shelf on external display as well as one on primary.
 182 TEST_F(ShelfViewIconObserverTest, MAYBE_AddRemoveWithMultipleDisplays) {
 183   UpdateDisplay("400x400,400x400");
 184   TestShelfIconObserver second_observer(ShelfForSecondaryDisplay());
 185
 186   TestShelfDelegate* shelf_delegate = TestShelfDelegate::instance();
 187   ASSERT_TRUE(shelf_delegate);
 188
 189   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 190   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 191   params.bounds = gfx::Rect(0, 0, 200, 200);
 192   params.context = CurrentContext();
 193
 194   scoped_ptr<views::Widget> widget(new views::Widget());
 195   widget->Init(params);
 196   shelf_delegate->AddShelfItem(widget->GetNativeWindow());
 197   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
 198   EXPECT_TRUE(observer()->change_notified());
 199   EXPECT_TRUE(second_observer.change_notified());
 200   observer()->Reset();
 201   second_observer.Reset();
 202
 203   widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow());
 204   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
 205   EXPECT_TRUE(observer()->change_notified());
 206   EXPECT_TRUE(second_observer.change_notified());
 207
 208   observer()->Reset();
 209   second_observer.Reset();
 210 }
 211
 212 TEST_F(ShelfViewIconObserverTest, BoundsChanged) {
 213   ShelfWidget* widget = Shell::GetPrimaryRootWindowController()->shelf();
 214   Shelf* shelf = Shelf::ForPrimaryDisplay();
 215   gfx::Size shelf_size = widget->GetWindowBoundsInScreen().size();
 216   shelf_size.set_width(shelf_size.width() / 2);
 217   ASSERT_GT(shelf_size.width(), 0);
 218   shelf->SetShelfViewBounds(gfx::Rect(shelf_size));
 219   // No animation happens for ShelfView bounds change.
 220   EXPECT_TRUE(observer()->change_notified());
 221   observer()->Reset();
 222 }
 223
 224 ////////////////////////////////////////////////////////////////////////////////
 225 // ShelfView tests.
 226
 227 // Simple ShelfDelegate implmentation for ShelfViewTest.OverflowBubbleSize
 228 // and CheckDragAndDropFromOverflowBubbleToShelf
 229 class TestShelfDelegateForShelfView : public ShelfDelegate {
 230  public:
 231   explicit TestShelfDelegateForShelfView(ShelfModel* model)
 232       : model_(model) {}
 233   virtual ~TestShelfDelegateForShelfView() {}
 234
 235   // ShelfDelegate overrides:
 236   virtual void OnShelfCreated(Shelf* shelf) OVERRIDE {}
 237
 238   virtual void OnShelfDestroyed(Shelf* shelf) OVERRIDE {}
 239
 240   virtual ShelfID GetShelfIDForAppID(const std::string& app_id) OVERRIDE {
 241     ShelfID id = 0;
 242     EXPECT_TRUE(base::StringToInt(app_id, &id));
 243     return id;
 244   }
 245
 246   virtual const std::string& GetAppIDForShelfID(ShelfID id) OVERRIDE {
 247     // Use |app_id_| member variable because returning a reference to local
 248     // variable is not allowed.
 249     app_id_ = base::IntToString(id);
 250     return app_id_;
 251   }
 252
 253   virtual void PinAppWithID(const std::string& app_id) OVERRIDE {
 254   }
 255
 256   virtual bool IsAppPinned(const std::string& app_id) OVERRIDE {
 257     // Returns true for ShelfViewTest.OverflowBubbleSize. To test ripping off in
 258     // that test, an item is already pinned state.
 259     return true;
 260   }
 261
 262   virtual bool CanPin() const OVERRIDE {
 263     return true;
 264   }
 265
 266   virtual void UnpinAppWithID(const std::string& app_id) OVERRIDE {
 267     ShelfID id = 0;
 268     EXPECT_TRUE(base::StringToInt(app_id, &id));
 269     ASSERT_GT(id, 0);
 270     int index = model_->ItemIndexByID(id);
 271     ASSERT_GE(index, 0);
 272
 273     model_->RemoveItemAt(index);
 274   }
 275
 276  private:
 277   ShelfModel* model_;
 278
 279   // Temp member variable for returning a value. See the comment in the
 280   // GetAppIDForShelfID().
 281   std::string app_id_;
 282
 283   DISALLOW_COPY_AND_ASSIGN(TestShelfDelegateForShelfView);
 284 };
 285
 286 class ShelfViewTest : public AshTestBase {
 287  public:
 288   ShelfViewTest() : model_(NULL), shelf_view_(NULL), browser_index_(1) {}
 289   virtual ~ShelfViewTest() {}
 290
 291   virtual void SetUp() OVERRIDE {
 292     AshTestBase::SetUp();
 293     test::ShellTestApi test_api(Shell::GetInstance());
 294     model_ = test_api.shelf_model();
 295     Shelf* shelf = Shelf::ForPrimaryDisplay();
 296     shelf_view_ = ShelfTestAPI(shelf).shelf_view();
 297
 298     // The bounds should be big enough for 4 buttons + overflow chevron.
 299     shelf_view_->SetBounds(0, 0, 500, kShelfSize);
 300
 301     test_api_.reset(new ShelfViewTestAPI(shelf_view_));
 302     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 303
 304     item_manager_ = Shell::GetInstance()->shelf_item_delegate_manager();
 305     DCHECK(item_manager_);
 306
 307     // Add browser shortcut shelf item at index 0 for test.
 308     AddBrowserShortcut();
 309   }
 310
 311   virtual void TearDown() OVERRIDE {
 312     test_api_.reset();
 313     AshTestBase::TearDown();
 314   }
 315
 316  protected:
 317   void CreateAndSetShelfItemDelegateForID(ShelfID id) {
 318     scoped_ptr<ShelfItemDelegate> delegate(new TestShelfItemDelegate(NULL));
 319     item_manager_->SetShelfItemDelegate(id, delegate.Pass());
 320   }
 321
 322   ShelfID AddBrowserShortcut() {
 323     ShelfItem browser_shortcut;
 324     browser_shortcut.type = TYPE_BROWSER_SHORTCUT;
 325
 326     ShelfID id = model_->next_id();
 327     model_->AddAt(browser_index_, browser_shortcut);
 328     CreateAndSetShelfItemDelegateForID(id);
 329     test_api_->RunMessageLoopUntilAnimationsDone();
 330     return id;
 331   }
 332
 333   ShelfID AddAppShortcut() {
 334     ShelfItem item;
 335     item.type = TYPE_APP_SHORTCUT;
 336     item.status = STATUS_CLOSED;
 337
 338     ShelfID id = model_->next_id();
 339     model_->Add(item);
 340     CreateAndSetShelfItemDelegateForID(id);
 341     test_api_->RunMessageLoopUntilAnimationsDone();
 342     return id;
 343   }
 344
 345   ShelfID AddPanel() {
 346     ShelfID id = AddPanelNoWait();
 347     test_api_->RunMessageLoopUntilAnimationsDone();
 348     return id;
 349   }
 350
 351   ShelfID AddPlatformAppNoWait() {
 352     ShelfItem item;
 353     item.type = TYPE_PLATFORM_APP;
 354     item.status = STATUS_RUNNING;
 355
 356     ShelfID id = model_->next_id();
 357     model_->Add(item);
 358     CreateAndSetShelfItemDelegateForID(id);
 359     return id;
 360   }
 361
 362   ShelfID AddPanelNoWait() {
 363     ShelfItem item;
 364     item.type = TYPE_APP_PANEL;
 365     item.status = STATUS_RUNNING;
 366
 367     ShelfID id = model_->next_id();
 368     model_->Add(item);
 369     CreateAndSetShelfItemDelegateForID(id);
 370     return id;
 371   }
 372
 373   ShelfID AddPlatformApp() {
 374     ShelfID id = AddPlatformAppNoWait();
 375     test_api_->RunMessageLoopUntilAnimationsDone();
 376     return id;
 377   }
 378
 379   void RemoveByID(ShelfID id) {
 380     model_->RemoveItemAt(model_->ItemIndexByID(id));
 381     test_api_->RunMessageLoopUntilAnimationsDone();
 382   }
 383
 384   ShelfButton* GetButtonByID(ShelfID id) {
 385     int index = model_->ItemIndexByID(id);
 386     return test_api_->GetButton(index);
 387   }
 388
 389   ShelfItem GetItemByID(ShelfID id) {
 390     ShelfItems::const_iterator items = model_->ItemByID(id);
 391     return *items;
 392   }
 393
 394   void CheckModelIDs(
 395       const std::vector<std::pair<ShelfID, views::View*> >& id_map) {
 396     size_t map_index = 0;
 397     for (size_t model_index = 0;
 398          model_index < model_->items().size();
 399          ++model_index) {
 400       ShelfItem item = model_->items()[model_index];
 401       ShelfID id = item.id;
 402       EXPECT_EQ(id_map[map_index].first, id);
 403       EXPECT_EQ(id_map[map_index].second, GetButtonByID(id));
 404       ++map_index;
 405     }
 406     ASSERT_EQ(map_index, id_map.size());
 407   }
 408
 409   void VerifyShelfItemBoundsAreValid() {
 410     for (int i=0;i <= test_api_->GetLastVisibleIndex(); ++i) {
 411       if (test_api_->GetButton(i)) {
 412         gfx::Rect shelf_view_bounds = shelf_view_->GetLocalBounds();
 413         gfx::Rect item_bounds = test_api_->GetBoundsByIndex(i);
 414         EXPECT_GE(item_bounds.x(), 0);
 415         EXPECT_GE(item_bounds.y(), 0);
 416         EXPECT_LE(item_bounds.right(), shelf_view_bounds.width());
 417         EXPECT_LE(item_bounds.bottom(), shelf_view_bounds.height());
 418       }
 419     }
 420   }
 421
 422   views::View* SimulateButtonPressed(ShelfButtonHost::Pointer pointer,
 423                                      int button_index) {
 424     ShelfButtonHost* button_host = shelf_view_;
 425     views::View* button = test_api_->GetButton(button_index);
 426     ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
 427                                gfx::Point(),
 428                                button->GetBoundsInScreen().origin(), 0, 0);
 429     button_host->PointerPressedOnButton(button, pointer, click_event);
 430     return button;
 431   }
 432
 433   views::View* SimulateClick(ShelfButtonHost::Pointer pointer,
 434                              int button_index) {
 435     ShelfButtonHost* button_host = shelf_view_;
 436     views::View* button = SimulateButtonPressed(pointer, button_index);
 437     button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
 438     return button;
 439   }
 440
 441   views::View* SimulateDrag(ShelfButtonHost::Pointer pointer,
 442                             int button_index,
 443                             int destination_index) {
 444     ShelfButtonHost* button_host = shelf_view_;
 445     views::View* button = SimulateButtonPressed(pointer, button_index);
 446
 447     // Drag.
 448     views::View* destination = test_api_->GetButton(destination_index);
 449     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED,
 450                               gfx::Point(destination->x() - button->x(),
 451                                          destination->y() - button->y()),
 452                               destination->GetBoundsInScreen().origin(), 0, 0);
 453     button_host->PointerDraggedOnButton(button, pointer, drag_event);
 454     return button;
 455   }
 456
 457   void SetupForDragTest(
 458       std::vector<std::pair<ShelfID, views::View*> >* id_map) {
 459     // Initialize |id_map| with the automatically-created shelf buttons.
 460     for (size_t i = 0; i < model_->items().size(); ++i) {
 461       ShelfButton* button = test_api_->GetButton(i);
 462       id_map->push_back(std::make_pair(model_->items()[i].id, button));
 463     }
 464     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
 465
 466     // Add 5 app shelf buttons for testing.
 467     for (int i = 0; i < 5; ++i) {
 468       ShelfID id = AddAppShortcut();
 469       // App Icon is located at index 0, and browser shortcut is located at
 470       // index 1. So we should start to add app shortcut at index 2.
 471       id_map->insert(id_map->begin() + (i + browser_index_ + 1),
 472                      std::make_pair(id, GetButtonByID(id)));
 473     }
 474     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
 475   }
 476
 477   views::View* GetTooltipAnchorView() {
 478     return shelf_view_->tooltip_manager()->anchor_;
 479   }
 480
 481   void AddButtonsUntilOverflow() {
 482     int items_added = 0;
 483     while (!test_api_->IsOverflowButtonVisible()) {
 484       AddAppShortcut();
 485       ++items_added;
 486       ASSERT_LT(items_added, 10000);
 487     }
 488   }
 489
 490   void ShowTooltip() {
 491     shelf_view_->tooltip_manager()->ShowInternal();
 492   }
 493
 494   void TestDraggingAnItemFromOverflowToShelf(bool cancel) {
 495     test_api_->ShowOverflowBubble();
 496     ASSERT_TRUE(test_api_->overflow_bubble() &&
 497                 test_api_->overflow_bubble()->IsShowing());
 498
 499     ash::test::ShelfViewTestAPI test_api_for_overflow(
 500       test_api_->overflow_bubble()->shelf_view());
 501
 502     int total_item_count = model_->item_count();
 503
 504     int last_visible_item_id_in_shelf =
 505         GetItemId(test_api_->GetLastVisibleIndex());
 506     int second_last_visible_item_id_in_shelf =
 507         GetItemId(test_api_->GetLastVisibleIndex() - 1);
 508     int first_visible_item_id_in_overflow =
 509         GetItemId(test_api_for_overflow.GetFirstVisibleIndex());
 510     int second_last_visible_item_id_in_overflow =
 511         GetItemId(test_api_for_overflow.GetLastVisibleIndex() - 1);
 512
 513     int drag_item_index =
 514         test_api_for_overflow.GetLastVisibleIndex();
 515     ShelfID drag_item_id = GetItemId(drag_item_index);
 516     ShelfButton* drag_button = test_api_for_overflow.GetButton(drag_item_index);
 517     gfx::Point center_point_of_drag_item =
 518         drag_button->GetBoundsInScreen().CenterPoint();
 519
 520     aura::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
 521                                          center_point_of_drag_item);
 522     // Rip an item off to OverflowBubble.
 523     generator.PressLeftButton();
 524     gfx::Point rip_off_point(center_point_of_drag_item.x(), 0);
 525     generator.MoveMouseTo(rip_off_point);
 526     test_api_for_overflow.RunMessageLoopUntilAnimationsDone();
 527     ASSERT_TRUE(test_api_for_overflow.IsRippedOffFromShelf());
 528     ASSERT_FALSE(test_api_for_overflow.DraggedItemFromOverflowToShelf());
 529
 530     // Move a dragged item into Shelf at |drop_index|.
 531     int drop_index = 1;
 532     gfx::Point drop_point =
 533         test_api_->GetButton(drop_index)->GetBoundsInScreen().CenterPoint();
 534     int item_width = test_api_for_overflow.GetButtonSize();
 535     // To insert at |drop_index|, more smaller x-axis value of |drop_point|
 536     // should be used.
 537     gfx::Point modified_drop_point(drop_point.x() - item_width / 4,
 538                                    drop_point.y());
 539     generator.MoveMouseTo(modified_drop_point);
 540     test_api_for_overflow.RunMessageLoopUntilAnimationsDone();
 541     test_api_->RunMessageLoopUntilAnimationsDone();
 542     ASSERT_TRUE(test_api_for_overflow.IsRippedOffFromShelf());
 543     ASSERT_TRUE(test_api_for_overflow.DraggedItemFromOverflowToShelf());
 544
 545     if (cancel)
 546       drag_button->OnMouseCaptureLost();
 547     else
 548       generator.ReleaseLeftButton();
 549
 550     test_api_for_overflow.RunMessageLoopUntilAnimationsDone();
 551     test_api_->RunMessageLoopUntilAnimationsDone();
 552     ASSERT_FALSE(test_api_for_overflow.IsRippedOffFromShelf());
 553     ASSERT_FALSE(test_api_for_overflow.DraggedItemFromOverflowToShelf());
 554
 555     // Compare pre-stored items' id with newly positioned items' after dragging
 556     // is canceled or finished.
 557     if (cancel) {
 558       EXPECT_EQ(last_visible_item_id_in_shelf,
 559                 GetItemId(test_api_->GetLastVisibleIndex()));
 560       EXPECT_EQ(second_last_visible_item_id_in_shelf,
 561                 GetItemId(test_api_->GetLastVisibleIndex() - 1));
 562       EXPECT_EQ(first_visible_item_id_in_overflow,
 563                 GetItemId(test_api_for_overflow.GetFirstVisibleIndex()));
 564       EXPECT_EQ(second_last_visible_item_id_in_overflow,
 565                 GetItemId(test_api_for_overflow.GetLastVisibleIndex() - 1));
 566     } else {
 567       EXPECT_EQ(drag_item_id, GetItemId(drop_index));
 568       EXPECT_EQ(total_item_count, model_->item_count());
 569       EXPECT_EQ(last_visible_item_id_in_shelf,
 570                 GetItemId(test_api_for_overflow.GetFirstVisibleIndex()));
 571       EXPECT_EQ(second_last_visible_item_id_in_shelf,
 572                 GetItemId(test_api_->GetLastVisibleIndex()));
 573       EXPECT_EQ(first_visible_item_id_in_overflow,
 574                 GetItemId(test_api_for_overflow.GetFirstVisibleIndex() + 1));
 575       EXPECT_EQ(second_last_visible_item_id_in_overflow,
 576                 GetItemId(test_api_for_overflow.GetLastVisibleIndex()));
 577     }
 578   }
 579
 580   // Returns the item's ShelfID at |index|.
 581   ShelfID GetItemId(int index) {
 582     DCHECK_GE(index, 0);
 583     return model_->items()[index].id;
 584   }
 585
 586   void ReplaceShelfDelegateForRipOffTest() {
 587     // Replace ShelfDelegate.
 588     test::ShellTestApi test_api(Shell::GetInstance());
 589     test_api.SetShelfDelegate(NULL);
 590     ShelfDelegate* delegate = new TestShelfDelegateForShelfView(model_);
 591     test_api.SetShelfDelegate(delegate);
 592     test::ShelfTestAPI(Shelf::ForPrimaryDisplay()).SetShelfDelegate(delegate);
 593     test_api_->SetShelfDelegate(delegate);
 594   }
 595
 596   ShelfModel* model_;
 597   ShelfView* shelf_view_;
 598   int browser_index_;
 599   ShelfItemDelegateManager* item_manager_;
 600
 601   scoped_ptr<ShelfViewTestAPI> test_api_;
 602
 603  private:
 604   DISALLOW_COPY_AND_ASSIGN(ShelfViewTest);
 605 };
 606
 607 class ScopedTextDirectionChange {
 608  public:
 609   ScopedTextDirectionChange(bool is_rtl)
 610       : is_rtl_(is_rtl) {
 611     original_locale_ = l10n_util::GetApplicationLocale(std::string());
 612     if (is_rtl_)
 613       base::i18n::SetICUDefaultLocale("he");
 614     CheckTextDirectionIsCorrect();
 615   }
 616
 617   ~ScopedTextDirectionChange() {
 618     if (is_rtl_)
 619       base::i18n::SetICUDefaultLocale(original_locale_);
 620   }
 621
 622  private:
 623   void CheckTextDirectionIsCorrect() {
 624     ASSERT_EQ(is_rtl_, base::i18n::IsRTL());
 625   }
 626
 627   bool is_rtl_;
 628   std::string original_locale_;
 629 };
 630
 631 class ShelfViewTextDirectionTest
 632     : public ShelfViewTest,
 633       public testing::WithParamInterface<bool> {
 634  public:
 635   ShelfViewTextDirectionTest() : text_direction_change_(GetParam()) {}
 636   virtual ~ShelfViewTextDirectionTest() {}
 637
 638   virtual void SetUp() OVERRIDE {
 639     ShelfViewTest::SetUp();
 640   }
 641
 642   virtual void TearDown() OVERRIDE {
 643     ShelfViewTest::TearDown();
 644   }
 645
 646  private:
 647   ScopedTextDirectionChange text_direction_change_;
 648
 649   DISALLOW_COPY_AND_ASSIGN(ShelfViewTextDirectionTest);
 650 };
 651
 652 // Checks that the ideal item icon bounds match the view's bounds in the screen
 653 // in both LTR and RTL.
 654 TEST_P(ShelfViewTextDirectionTest, IdealBoundsOfItemIcon) {
 655   ShelfID id = AddPlatformApp();
 656   ShelfButton* button = GetButtonByID(id);
 657   gfx::Rect item_bounds = button->GetBoundsInScreen();
 658   gfx::Point icon_offset = button->GetIconBounds().origin();
 659   item_bounds.Offset(icon_offset.OffsetFromOrigin());
 660   gfx::Rect ideal_bounds = shelf_view_->GetIdealBoundsOfItemIcon(id);
 661   gfx::Point screen_origin;
 662   views::View::ConvertPointToScreen(shelf_view_, &screen_origin);
 663   ideal_bounds.Offset(screen_origin.x(), screen_origin.y());
 664   EXPECT_EQ(item_bounds.x(), ideal_bounds.x());
 665   EXPECT_EQ(item_bounds.y(), ideal_bounds.y());
 666 }
 667
 668 // Check that items in the overflow area are returning the overflow button as
 669 // ideal bounds.
 670 TEST_F(ShelfViewTest, OverflowButtonBounds) {
 671   ShelfID first_id = AddPlatformApp();
 672   ShelfID overflow_id = AddPlatformApp();
 673   int items_added = 0;
 674   while (!test_api_->IsOverflowButtonVisible()) {
 675     // Added button is visible after animation while in this loop.
 676     EXPECT_TRUE(GetButtonByID(overflow_id)->visible());
 677     overflow_id = AddPlatformApp();
 678     ++items_added;
 679     ASSERT_LT(items_added, 10000);
 680   }
 681   ShelfID last_id = AddPlatformApp();
 682
 683   gfx::Rect first_bounds = shelf_view_->GetIdealBoundsOfItemIcon(first_id);
 684   gfx::Rect overflow_bounds =
 685       shelf_view_->GetIdealBoundsOfItemIcon(overflow_id);
 686   gfx::Rect last_bounds = shelf_view_->GetIdealBoundsOfItemIcon(last_id);
 687
 688   // Check that all items have the same size and that the overflow items are
 689   // identical whereas the first one does not match either of them.
 690   EXPECT_EQ(first_bounds.size().ToString(), last_bounds.size().ToString());
 691   EXPECT_NE(first_bounds.ToString(), last_bounds.ToString());
 692   EXPECT_EQ(overflow_bounds.ToString(), last_bounds.ToString());
 693 }
 694
 695 // Checks that shelf view contents are considered in the correct drag group.
 696 TEST_F(ShelfViewTest, EnforceDragType) {
 697   EXPECT_TRUE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_PLATFORM_APP));
 698   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_SHORTCUT));
 699   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP,
 700                                        TYPE_BROWSER_SHORTCUT));
 701   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_WINDOWED_APP));
 702   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_LIST));
 703   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_PANEL));
 704
 705   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_SHORTCUT));
 706   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_SHORTCUT,
 707                                       TYPE_BROWSER_SHORTCUT));
 708   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT,
 709                                        TYPE_WINDOWED_APP));
 710   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_LIST));
 711   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_PANEL));
 712
 713   EXPECT_TRUE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT,
 714                                       TYPE_BROWSER_SHORTCUT));
 715   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT,
 716                                        TYPE_WINDOWED_APP));
 717   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_APP_LIST));
 718   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_APP_PANEL));
 719
 720   EXPECT_TRUE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_WINDOWED_APP));
 721   EXPECT_FALSE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_APP_LIST));
 722   EXPECT_FALSE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_APP_PANEL));
 723
 724   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_LIST, TYPE_APP_LIST));
 725   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_LIST, TYPE_APP_PANEL));
 726
 727   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_PANEL, TYPE_APP_PANEL));
 728 }
 729
 730 // Adds platform app button until overflow and verifies that the last added
 731 // platform app button is hidden.
 732 TEST_F(ShelfViewTest, AddBrowserUntilOverflow) {
 733   // All buttons should be visible.
 734   ASSERT_EQ(test_api_->GetButtonCount(),
 735             test_api_->GetLastVisibleIndex() + 1);
 736
 737   // Add platform app button until overflow.
 738   int items_added = 0;
 739   ShelfID last_added = AddPlatformApp();
 740   while (!test_api_->IsOverflowButtonVisible()) {
 741     // Added button is visible after animation while in this loop.
 742     EXPECT_TRUE(GetButtonByID(last_added)->visible());
 743
 744     last_added = AddPlatformApp();
 745     ++items_added;
 746     ASSERT_LT(items_added, 10000);
 747   }
 748
 749   // The last added button should be invisible.
 750   EXPECT_FALSE(GetButtonByID(last_added)->visible());
 751 }
 752
 753 // Adds one platform app button then adds app shortcut until overflow. Verifies
 754 // that the browser button gets hidden on overflow and last added app shortcut
 755 // is still visible.
 756 TEST_F(ShelfViewTest, AddAppShortcutWithBrowserButtonUntilOverflow) {
 757   // All buttons should be visible.
 758   ASSERT_EQ(test_api_->GetButtonCount(),
 759             test_api_->GetLastVisibleIndex() + 1);
 760
 761   ShelfID browser_button_id = AddPlatformApp();
 762
 763   // Add app shortcut until overflow.
 764   int items_added = 0;
 765   ShelfID last_added = AddAppShortcut();
 766   while (!test_api_->IsOverflowButtonVisible()) {
 767     // Added button is visible after animation while in this loop.
 768     EXPECT_TRUE(GetButtonByID(last_added)->visible());
 769
 770     last_added = AddAppShortcut();
 771     ++items_added;
 772     ASSERT_LT(items_added, 10000);
 773   }
 774
 775   // And the platform app button is invisible.
 776   EXPECT_FALSE(GetButtonByID(browser_button_id)->visible());
 777 }
 778
 779 TEST_F(ShelfViewTest, AddPanelHidesPlatformAppButton) {
 780   // All buttons should be visible.
 781   ASSERT_EQ(test_api_->GetButtonCount(),
 782             test_api_->GetLastVisibleIndex() + 1);
 783
 784   // Add platform app button until overflow, remember last visible platform app
 785   // button.
 786   int items_added = 0;
 787   ShelfID first_added = AddPlatformApp();
 788   EXPECT_TRUE(GetButtonByID(first_added)->visible());
 789   while (true) {
 790     ShelfID added = AddPlatformApp();
 791     if (test_api_->IsOverflowButtonVisible()) {
 792       EXPECT_FALSE(GetButtonByID(added)->visible());
 793       RemoveByID(added);
 794       break;
 795     }
 796     ++items_added;
 797     ASSERT_LT(items_added, 10000);
 798   }
 799
 800   ShelfID panel = AddPanel();
 801   EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
 802
 803   RemoveByID(panel);
 804   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 805 }
 806
 807 // When there are more panels then platform app buttons we should hide panels
 808 // rather than platform apps.
 809 TEST_F(ShelfViewTest, PlatformAppHidesExcessPanels) {
 810   // All buttons should be visible.
 811   ASSERT_EQ(test_api_->GetButtonCount(),
 812             test_api_->GetLastVisibleIndex() + 1);
 813
 814   // Add platform app button.
 815   ShelfID platform_app = AddPlatformApp();
 816   ShelfID first_panel = AddPanel();
 817
 818   EXPECT_TRUE(GetButtonByID(platform_app)->visible());
 819   EXPECT_TRUE(GetButtonByID(first_panel)->visible());
 820
 821   // Add panels until there is an overflow.
 822   ShelfID last_panel = first_panel;
 823   int items_added = 0;
 824   while (!test_api_->IsOverflowButtonVisible()) {
 825     last_panel = AddPanel();
 826     ++items_added;
 827     ASSERT_LT(items_added, 10000);
 828   }
 829
 830   // The first panel should now be hidden by the new platform apps needing
 831   // space.
 832   EXPECT_FALSE(GetButtonByID(first_panel)->visible());
 833   EXPECT_TRUE(GetButtonByID(last_panel)->visible());
 834   EXPECT_TRUE(GetButtonByID(platform_app)->visible());
 835
 836   // Adding platform apps should eventually begin to hide platform apps. We will
 837   // add platform apps until either the last panel or platform app is hidden.
 838   items_added = 0;
 839   while (GetButtonByID(platform_app)->visible() &&
 840          GetButtonByID(last_panel)->visible()) {
 841     platform_app = AddPlatformApp();
 842     ++items_added;
 843     ASSERT_LT(items_added, 10000);
 844   }
 845   EXPECT_TRUE(GetButtonByID(last_panel)->visible());
 846   EXPECT_FALSE(GetButtonByID(platform_app)->visible());
 847 }
 848
 849 // Adds button until overflow then removes first added one. Verifies that
 850 // the last added one changes from invisible to visible and overflow
 851 // chevron is gone.
 852 TEST_F(ShelfViewTest, RemoveButtonRevealsOverflowed) {
 853   // All buttons should be visible.
 854   ASSERT_EQ(test_api_->GetButtonCount(),
 855             test_api_->GetLastVisibleIndex() + 1);
 856
 857   // Add platform app buttons until overflow.
 858   int items_added = 0;
 859   ShelfID first_added = AddPlatformApp();
 860   ShelfID last_added = first_added;
 861   while (!test_api_->IsOverflowButtonVisible()) {
 862     last_added = AddPlatformApp();
 863     ++items_added;
 864     ASSERT_LT(items_added, 10000);
 865   }
 866
 867   // Expect add more than 1 button. First added is visible and last is not.
 868   EXPECT_NE(first_added, last_added);
 869   EXPECT_TRUE(GetButtonByID(first_added)->visible());
 870   EXPECT_FALSE(GetButtonByID(last_added)->visible());
 871
 872   // Remove first added.
 873   RemoveByID(first_added);
 874
 875   // Last added button becomes visible and overflow chevron is gone.
 876   EXPECT_TRUE(GetButtonByID(last_added)->visible());
 877   EXPECT_EQ(1.0f, GetButtonByID(last_added)->layer()->opacity());
 878   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 879 }
 880
 881 // Verifies that remove last overflowed button should hide overflow chevron.
 882 TEST_F(ShelfViewTest, RemoveLastOverflowed) {
 883   // All buttons should be visible.
 884   ASSERT_EQ(test_api_->GetButtonCount(),
 885             test_api_->GetLastVisibleIndex() + 1);
 886
 887   // Add platform app button until overflow.
 888   int items_added = 0;
 889   ShelfID last_added = AddPlatformApp();
 890   while (!test_api_->IsOverflowButtonVisible()) {
 891     last_added = AddPlatformApp();
 892     ++items_added;
 893     ASSERT_LT(items_added, 10000);
 894   }
 895
 896   RemoveByID(last_added);
 897   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 898 }
 899
 900 // Adds platform app button without waiting for animation to finish and verifies
 901 // that all added buttons are visible.
 902 TEST_F(ShelfViewTest, AddButtonQuickly) {
 903   // All buttons should be visible.
 904   ASSERT_EQ(test_api_->GetButtonCount(),
 905             test_api_->GetLastVisibleIndex() + 1);
 906
 907   // Add a few platform buttons quickly without wait for animation.
 908   int added_count = 0;
 909   while (!test_api_->IsOverflowButtonVisible()) {
 910     AddPlatformAppNoWait();
 911     ++added_count;
 912     ASSERT_LT(added_count, 10000);
 913   }
 914
 915   // ShelfView should be big enough to hold at least 3 new buttons.
 916   ASSERT_GE(added_count, 3);
 917
 918   // Wait for the last animation to finish.
 919   test_api_->RunMessageLoopUntilAnimationsDone();
 920
 921   // Verifies non-overflow buttons are visible.
 922   for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) {
 923     ShelfButton* button = test_api_->GetButton(i);
 924     if (button) {
 925       EXPECT_TRUE(button->visible()) << "button index=" << i;
 926       EXPECT_EQ(1.0f, button->layer()->opacity()) << "button index=" << i;
 927     }
 928   }
 929 }
 930
 931 // Check that model changes are handled correctly while a shelf icon is being
 932 // dragged.
 933 TEST_F(ShelfViewTest, ModelChangesWhileDragging) {
 934   ShelfButtonHost* button_host = shelf_view_;
 935
 936   std::vector<std::pair<ShelfID, views::View*> > id_map;
 937   SetupForDragTest(&id_map);
 938
 939   // Dragging browser shortcut at index 1.
 940   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
 941   views::View* dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
 942   std::rotate(id_map.begin() + 1,
 943               id_map.begin() + 2,
 944               id_map.begin() + 4);
 945   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 946   button_host->PointerReleasedOnButton(
 947       dragged_button, ShelfButtonHost::MOUSE, false);
 948   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 949
 950   // Dragging changes model order.
 951   dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
 952   std::rotate(id_map.begin() + 1,
 953               id_map.begin() + 2,
 954               id_map.begin() + 4);
 955   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 956
 957   // Cancelling the drag operation restores previous order.
 958   button_host->PointerReleasedOnButton(
 959       dragged_button, ShelfButtonHost::MOUSE, true);
 960   std::rotate(id_map.begin() + 1,
 961               id_map.begin() + 3,
 962               id_map.begin() + 4);
 963   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 964
 965   // Deleting an item keeps the remaining intact.
 966   dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
 967   model_->RemoveItemAt(1);
 968   id_map.erase(id_map.begin() + 1);
 969   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 970   button_host->PointerReleasedOnButton(
 971       dragged_button, ShelfButtonHost::MOUSE, false);
 972
 973   // Adding a shelf item cancels the drag and respects the order.
 974   dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
 975   ShelfID new_id = AddAppShortcut();
 976   id_map.insert(id_map.begin() + 6,
 977                 std::make_pair(new_id, GetButtonByID(new_id)));
 978   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 979   button_host->PointerReleasedOnButton(
 980       dragged_button, ShelfButtonHost::MOUSE, false);
 981
 982   // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
 983   // the order.
 984   dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
 985   new_id = AddPanel();
 986   id_map.insert(id_map.begin() + 7,
 987                 std::make_pair(new_id, GetButtonByID(new_id)));
 988   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 989   button_host->PointerReleasedOnButton(
 990       dragged_button, ShelfButtonHost::MOUSE, false);
 991 }
 992
 993 // Check that 2nd drag from the other pointer would be ignored.
 994 TEST_F(ShelfViewTest, SimultaneousDrag) {
 995   ShelfButtonHost* button_host = shelf_view_;
 996
 997   std::vector<std::pair<ShelfID, views::View*> > id_map;
 998   SetupForDragTest(&id_map);
 999
1000   // Start a mouse drag.
1001   views::View* dragged_button_mouse =
1002       SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
1003   std::rotate(id_map.begin() + 1,
1004               id_map.begin() + 2,
1005               id_map.begin() + 4);
1006   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1007   // Attempt a touch drag before the mouse drag finishes.
1008   views::View* dragged_button_touch =
1009       SimulateDrag(ShelfButtonHost::TOUCH, 4, 2);
1010
1011   // Nothing changes since 2nd drag is ignored.
1012   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1013
1014   // Finish the mouse drag.
1015   button_host->PointerReleasedOnButton(
1016       dragged_button_mouse, ShelfButtonHost::MOUSE, false);
1017   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1018
1019   // Now start a touch drag.
1020   dragged_button_touch = SimulateDrag(ShelfButtonHost::TOUCH, 4, 2);
1021   std::rotate(id_map.begin() + 3,
1022               id_map.begin() + 4,
1023               id_map.begin() + 5);
1024   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1025
1026   // And attempt a mouse drag before the touch drag finishes.
1027   dragged_button_mouse = SimulateDrag(ShelfButtonHost::MOUSE, 1, 2);
1028
1029   // Nothing changes since 2nd drag is ignored.
1030   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1031
1032   button_host->PointerReleasedOnButton(
1033       dragged_button_touch, ShelfButtonHost::TOUCH, false);
1034   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1035 }
1036
1037 // Check that clicking first on one item and then dragging another works as
1038 // expected.
1039 TEST_F(ShelfViewTest, ClickOneDragAnother) {
1040   ShelfButtonHost* button_host = shelf_view_;
1041
1042   std::vector<std::pair<ShelfID, views::View*> > id_map;
1043   SetupForDragTest(&id_map);
1044
1045   // A click on item 1 is simulated.
1046   SimulateClick(ShelfButtonHost::MOUSE, 1);
1047
1048   // Dragging browser index at 0 should change the model order correctly.
1049   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
1050   views::View* dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
1051   std::rotate(id_map.begin() + 1,
1052               id_map.begin() + 2,
1053               id_map.begin() + 4);
1054   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
1055   button_host->PointerReleasedOnButton(
1056       dragged_button, ShelfButtonHost::MOUSE, false);
1057   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
1058 }
1059
1060 // Check that clicking an item and jittering the mouse a bit still selects the
1061 // item.
1062 TEST_F(ShelfViewTest, ClickAndMoveSlightly) {
1063   std::vector<std::pair<ShelfID, views::View*> > id_map;
1064   SetupForDragTest(&id_map);
1065
1066   ShelfID shelf_id = (id_map.begin() + 1)->first;
1067   views::View* button = (id_map.begin() + 1)->second;
1068
1069   // Replace the ShelfItemDelegate for |shelf_id| with one which tracks whether
1070   // the shelf item gets selected.
1071   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
1072   item_manager_->SetShelfItemDelegate(
1073       shelf_id,
1074       scoped_ptr<ShelfItemDelegate>(selection_tracker).Pass());
1075
1076   gfx::Vector2d press_offset(5, 30);
1077   gfx::Point press_location = gfx::Point() + press_offset;
1078   gfx::Point press_location_in_screen =
1079       button->GetBoundsInScreen().origin() + press_offset;
1080
1081   ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
1082                              press_location,
1083                              press_location_in_screen,
1084                              ui::EF_LEFT_MOUSE_BUTTON, 0);
1085   button->OnMousePressed(click_event);
1086
1087   ui::MouseEvent drag_event1(ui::ET_MOUSE_DRAGGED,
1088                              press_location + gfx::Vector2d(0, 1),
1089                              press_location_in_screen + gfx::Vector2d(0, 1),
1090                              ui::EF_LEFT_MOUSE_BUTTON, 0);
1091   button->OnMouseDragged(drag_event1);
1092
1093   ui::MouseEvent drag_event2(ui::ET_MOUSE_DRAGGED,
1094                              press_location + gfx::Vector2d(-1, 0),
1095                              press_location_in_screen + gfx::Vector2d(-1, 0),
1096                              ui::EF_LEFT_MOUSE_BUTTON, 0);
1097   button->OnMouseDragged(drag_event2);
1098
1099   ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED,
1100                                press_location + gfx::Vector2d(-1, 0),
1101                                press_location_in_screen + gfx::Vector2d(-1, 0),
1102                                ui::EF_LEFT_MOUSE_BUTTON, 0);
1103   button->OnMouseReleased(release_event);
1104
1105   EXPECT_TRUE(selection_tracker->WasSelected());
1106 }
1107
1108 // Confirm that item status changes are reflected in the buttons.
1109 TEST_F(ShelfViewTest, ShelfItemStatus) {
1110   // All buttons should be visible.
1111   ASSERT_EQ(test_api_->GetButtonCount(),
1112             test_api_->GetLastVisibleIndex() + 1);
1113
1114   // Add platform app button.
1115   ShelfID last_added = AddPlatformApp();
1116   ShelfItem item = GetItemByID(last_added);
1117   int index = model_->ItemIndexByID(last_added);
1118   ShelfButton* button = GetButtonByID(last_added);
1119   ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
1120   item.status = STATUS_ACTIVE;
1121   model_->Set(index, item);
1122   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
1123   item.status = STATUS_ATTENTION;
1124   model_->Set(index, item);
1125   ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
1126 }
1127
1128 // Confirm that item status changes are reflected in the buttons
1129 // for platform apps.
1130 TEST_F(ShelfViewTest, ShelfItemStatusPlatformApp) {
1131   // All buttons should be visible.
1132   ASSERT_EQ(test_api_->GetButtonCount(),
1133             test_api_->GetLastVisibleIndex() + 1);
1134
1135   // Add platform app button.
1136   ShelfID last_added = AddPlatformApp();
1137   ShelfItem item = GetItemByID(last_added);
1138   int index = model_->ItemIndexByID(last_added);
1139   ShelfButton* button = GetButtonByID(last_added);
1140   ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
1141   item.status = STATUS_ACTIVE;
1142   model_->Set(index, item);
1143   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
1144   item.status = STATUS_ATTENTION;
1145   model_->Set(index, item);
1146   ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
1147 }
1148
1149 // Confirm that shelf item bounds are correctly updated on shelf changes.
1150 TEST_F(ShelfViewTest, ShelfItemBoundsCheck) {
1151   VerifyShelfItemBoundsAreValid();
1152   shelf_view_->shelf_layout_manager()->SetAutoHideBehavior(
1153       SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1154   test_api_->RunMessageLoopUntilAnimationsDone();
1155   VerifyShelfItemBoundsAreValid();
1156   shelf_view_->shelf_layout_manager()->SetAutoHideBehavior(
1157       SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1158   test_api_->RunMessageLoopUntilAnimationsDone();
1159   VerifyShelfItemBoundsAreValid();
1160 }
1161
1162 TEST_F(ShelfViewTest, ShelfTooltipTest) {
1163   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
1164             test_api_->GetButtonCount());
1165
1166   // Prepare some items to the shelf.
1167   ShelfID app_button_id = AddAppShortcut();
1168   ShelfID platform_button_id = AddPlatformApp();
1169
1170   ShelfButton* app_button = GetButtonByID(app_button_id);
1171   ShelfButton* platform_button = GetButtonByID(platform_button_id);
1172
1173   ShelfButtonHost* button_host = shelf_view_;
1174   ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
1175
1176   button_host->MouseEnteredButton(app_button);
1177   // There's a delay to show the tooltip, so it's not visible yet.
1178   EXPECT_FALSE(tooltip_manager->IsVisible());
1179   EXPECT_EQ(app_button, GetTooltipAnchorView());
1180
1181   ShowTooltip();
1182   EXPECT_TRUE(tooltip_manager->IsVisible());
1183
1184   // Once it's visible, it keeps visibility and is pointing to the same
1185   // item.
1186   button_host->MouseExitedButton(app_button);
1187   EXPECT_TRUE(tooltip_manager->IsVisible());
1188   EXPECT_EQ(app_button, GetTooltipAnchorView());
1189
1190   // When entered to another item, it switches to the new item.  There is no
1191   // delay for the visibility.
1192   button_host->MouseEnteredButton(platform_button);
1193   EXPECT_TRUE(tooltip_manager->IsVisible());
1194   EXPECT_EQ(platform_button, GetTooltipAnchorView());
1195
1196   button_host->MouseExitedButton(platform_button);
1197   tooltip_manager->Close();
1198
1199   // Next time: enter app_button -> move immediately to tab_button.
1200   button_host->MouseEnteredButton(app_button);
1201   button_host->MouseExitedButton(app_button);
1202   button_host->MouseEnteredButton(platform_button);
1203   EXPECT_FALSE(tooltip_manager->IsVisible());
1204   EXPECT_EQ(platform_button, GetTooltipAnchorView());
1205 }
1206
1207 // Verify a fix for crash caused by a tooltip update for a deletedshelf
1208 // button, see crbug.com/288838.
1209 TEST_F(ShelfViewTest, RemovingItemClosesTooltip) {
1210   ShelfButtonHost* button_host = shelf_view_;
1211   ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
1212
1213   // Add an item to the shelf.
1214   ShelfID app_button_id = AddAppShortcut();
1215   ShelfButton* app_button = GetButtonByID(app_button_id);
1216
1217   // Spawn a tooltip on that item.
1218   button_host->MouseEnteredButton(app_button);
1219   ShowTooltip();
1220   EXPECT_TRUE(tooltip_manager->IsVisible());
1221
1222   // Remove the app shortcut while the tooltip is open. The tooltip should be
1223   // closed.
1224   RemoveByID(app_button_id);
1225   EXPECT_FALSE(tooltip_manager->IsVisible());
1226
1227   // Change the shelf layout. This should not crash.
1228   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
1229                                           Shell::GetPrimaryRootWindow());
1230 }
1231
1232 // Changing the shelf alignment closes any open tooltip.
1233 TEST_F(ShelfViewTest, ShelfAlignmentClosesTooltip) {
1234   ShelfButtonHost* button_host = shelf_view_;
1235   ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
1236
1237   // Add an item to the shelf.
1238   ShelfID app_button_id = AddAppShortcut();
1239   ShelfButton* app_button = GetButtonByID(app_button_id);
1240
1241   // Spawn a tooltip on the item.
1242   button_host->MouseEnteredButton(app_button);
1243   ShowTooltip();
1244   EXPECT_TRUE(tooltip_manager->IsVisible());
1245
1246   // Changing shelf alignment hides the tooltip.
1247   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
1248                                           Shell::GetPrimaryRootWindow());
1249   EXPECT_FALSE(tooltip_manager->IsVisible());
1250 }
1251
1252 TEST_F(ShelfViewTest, ShouldHideTooltipTest) {
1253   ShelfID app_button_id = AddAppShortcut();
1254   ShelfID platform_button_id = AddPlatformApp();
1255
1256   // The tooltip shouldn't hide if the mouse is on normal buttons.
1257   for (int i = 0; i < test_api_->GetButtonCount(); i++) {
1258     ShelfButton* button = test_api_->GetButton(i);
1259     if (!button)
1260       continue;
1261
1262     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
1263         button->GetMirroredBounds().CenterPoint()))
1264         << "ShelfView tries to hide on button " << i;
1265   }
1266
1267   // The tooltip should not hide on the app-list button.
1268   views::View* app_list_button = shelf_view_->GetAppListButtonView();
1269   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
1270       app_list_button->GetMirroredBounds().CenterPoint()));
1271
1272   // The tooltip shouldn't hide if the mouse is in the gap between two buttons.
1273   gfx::Rect app_button_rect = GetButtonByID(app_button_id)->GetMirroredBounds();
1274   gfx::Rect platform_button_rect =
1275       GetButtonByID(platform_button_id)->GetMirroredBounds();
1276   ASSERT_FALSE(app_button_rect.Intersects(platform_button_rect));
1277   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
1278       gfx::UnionRects(app_button_rect, platform_button_rect).CenterPoint()));
1279
1280   // The tooltip should hide if it's outside of all buttons.
1281   gfx::Rect all_area;
1282   for (int i = 0; i < test_api_->GetButtonCount(); i++) {
1283     ShelfButton* button = test_api_->GetButton(i);
1284     if (!button)
1285       continue;
1286
1287     all_area.Union(button->GetMirroredBounds());
1288   }
1289   all_area.Union(shelf_view_->GetAppListButtonView()->GetMirroredBounds());
1290   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(all_area.origin()));
1291   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
1292       gfx::Point(all_area.right() - 1, all_area.bottom() - 1)));
1293   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
1294       gfx::Point(all_area.right(), all_area.y())));
1295   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
1296       gfx::Point(all_area.x() - 1, all_area.y())));
1297   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
1298       gfx::Point(all_area.x(), all_area.y() - 1)));
1299   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
1300       gfx::Point(all_area.x(), all_area.bottom())));
1301 }
1302
1303 TEST_F(ShelfViewTest, ShouldHideTooltipWithAppListWindowTest) {
1304   Shell::GetInstance()->ToggleAppList(NULL);
1305   ASSERT_TRUE(Shell::GetInstance()->GetAppListWindow());
1306
1307   // The tooltip shouldn't hide if the mouse is on normal buttons.
1308   for (int i = 1; i < test_api_->GetButtonCount(); i++) {
1309     ShelfButton* button = test_api_->GetButton(i);
1310     if (!button)
1311       continue;
1312
1313     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
1314         button->GetMirroredBounds().CenterPoint()))
1315         << "ShelfView tries to hide on button " << i;
1316   }
1317
1318   // The tooltip should hide on the app-list button.
1319   views::View* app_list_button = shelf_view_->GetAppListButtonView();
1320   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
1321       app_list_button->GetMirroredBounds().CenterPoint()));
1322 }
1323
1324 // Test that by moving the mouse cursor off the button onto the bubble it closes
1325 // the bubble.
1326 TEST_F(ShelfViewTest, ShouldHideTooltipWhenHoveringOnTooltip) {
1327   ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
1328   tooltip_manager->CreateZeroDelayTimerForTest();
1329   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1330
1331   // Move the mouse off any item and check that no tooltip is shown.
1332   generator.MoveMouseTo(gfx::Point(0, 0));
1333   EXPECT_FALSE(tooltip_manager->IsVisible());
1334
1335   // Move the mouse over the button and check that it is visible.
1336   views::View* app_list_button = shelf_view_->GetAppListButtonView();
1337   gfx::Rect bounds = app_list_button->GetBoundsInScreen();
1338   generator.MoveMouseTo(bounds.CenterPoint());
1339   // Wait for the timer to go off.
1340   RunAllPendingInMessageLoop();
1341   EXPECT_TRUE(tooltip_manager->IsVisible());
1342
1343   // Move the mouse cursor slightly to the right of the item. The tooltip should
1344   // stay open.
1345   generator.MoveMouseBy(bounds.width() / 2 + 5, 0);
1346   // Make sure there is no delayed close.
1347   RunAllPendingInMessageLoop();
1348   EXPECT_TRUE(tooltip_manager->IsVisible());
1349
1350   // Move back - it should still stay open.
1351   generator.MoveMouseBy(-(bounds.width() / 2 + 5), 0);
1352   // Make sure there is no delayed close.
1353   RunAllPendingInMessageLoop();
1354   EXPECT_TRUE(tooltip_manager->IsVisible());
1355
1356   // Now move the mouse cursor slightly above the item - so that it is over the
1357   // tooltip bubble. Now it should disappear.
1358   generator.MoveMouseBy(0, -(bounds.height() / 2 + 5));
1359   // Wait until the delayed close kicked in.
1360   RunAllPendingInMessageLoop();
1361   EXPECT_FALSE(tooltip_manager->IsVisible());
1362 }
1363
1364 // Resizing shelf view while an add animation without fade-in is running,
1365 // which happens when overflow happens. App list button should end up in its
1366 // new ideal bounds.
1367 TEST_F(ShelfViewTest, ResizeDuringOverflowAddAnimation) {
1368   // All buttons should be visible.
1369   ASSERT_EQ(test_api_->GetButtonCount(),
1370             test_api_->GetLastVisibleIndex() + 1);
1371
1372   // Add buttons until overflow. Let the non-overflow add animations finish but
1373   // leave the last running.
1374   int items_added = 0;
1375   AddPlatformAppNoWait();
1376   while (!test_api_->IsOverflowButtonVisible()) {
1377     test_api_->RunMessageLoopUntilAnimationsDone();
1378     AddPlatformAppNoWait();
1379     ++items_added;
1380     ASSERT_LT(items_added, 10000);
1381   }
1382
1383   // Resize shelf view with that animation running and stay overflown.
1384   gfx::Rect bounds = shelf_view_->bounds();
1385   bounds.set_width(bounds.width() - kShelfSize);
1386   shelf_view_->SetBoundsRect(bounds);
1387   ASSERT_TRUE(test_api_->IsOverflowButtonVisible());
1388
1389   // Finish the animation.
1390   test_api_->RunMessageLoopUntilAnimationsDone();
1391
1392   // App list button should ends up in its new ideal bounds.
1393   const int app_list_button_index = test_api_->GetButtonCount() - 1;
1394   const gfx::Rect& app_list_ideal_bounds =
1395       test_api_->GetIdealBoundsByIndex(app_list_button_index);
1396   const gfx::Rect& app_list_bounds =
1397       test_api_->GetBoundsByIndex(app_list_button_index);
1398   EXPECT_EQ(app_list_ideal_bounds, app_list_bounds);
1399 }
1400
1401 // Checks the overflow bubble size when an item is ripped off and re-inserted.
1402 TEST_F(ShelfViewTest, OverflowBubbleSize) {
1403   // Replace current ShelfDelegate with TestShelfDelegateForShelfView.
1404   ReplaceShelfDelegateForRipOffTest();
1405
1406   AddButtonsUntilOverflow();
1407
1408   // Show overflow bubble.
1409   test_api_->ShowOverflowBubble();
1410   ASSERT_TRUE(test_api_->overflow_bubble() &&
1411               test_api_->overflow_bubble()->IsShowing());
1412
1413   ShelfViewTestAPI test_for_overflow_view(
1414       test_api_->overflow_bubble()->shelf_view());
1415
1416   int ripped_index = test_for_overflow_view.GetLastVisibleIndex();
1417   gfx::Size bubble_size = test_for_overflow_view.GetPreferredSize();
1418   int item_width = test_for_overflow_view.GetButtonSize() +
1419       test_for_overflow_view.GetButtonSpacing();
1420
1421   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
1422                                        gfx::Point());
1423   ShelfButton* button = test_for_overflow_view.GetButton(ripped_index);
1424   // Rip off the last visible item.
1425   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
1426   gfx::Point rip_off_point(start_point.x(), 0);
1427   generator.MoveMouseTo(start_point.x(), start_point.y());
1428   base::MessageLoop::current()->RunUntilIdle();
1429   generator.PressLeftButton();
1430   base::MessageLoop::current()->RunUntilIdle();
1431   generator.MoveMouseTo(rip_off_point.x(), rip_off_point.y());
1432   base::MessageLoop::current()->RunUntilIdle();
1433   test_for_overflow_view.RunMessageLoopUntilAnimationsDone();
1434
1435   // Check the overflow bubble size when an item is ripped off.
1436   EXPECT_EQ(bubble_size.width() - item_width,
1437             test_for_overflow_view.GetPreferredSize().width());
1438   ASSERT_TRUE(test_api_->overflow_bubble() &&
1439               test_api_->overflow_bubble()->IsShowing());
1440
1441   // Re-insert an item into the overflow bubble.
1442   int first_index = test_for_overflow_view.GetFirstVisibleIndex();
1443   button = test_for_overflow_view.GetButton(first_index);
1444
1445   // Check the bubble size after an item is re-inserted.
1446   generator.MoveMouseTo(button->GetBoundsInScreen().CenterPoint());
1447   test_for_overflow_view.RunMessageLoopUntilAnimationsDone();
1448   EXPECT_EQ(bubble_size.width(),
1449             test_for_overflow_view.GetPreferredSize().width());
1450
1451   generator.ReleaseLeftButton();
1452   test_for_overflow_view.RunMessageLoopUntilAnimationsDone();
1453   EXPECT_EQ(bubble_size.width(),
1454             test_for_overflow_view.GetPreferredSize().width());
1455 }
1456
1457 // Check the drag insertion bounds of scrolled overflow bubble.
1458 TEST_F(ShelfViewTest, CheckDragInsertBoundsOfScrolledOverflowBubble) {
1459   UpdateDisplay("400x300");
1460
1461   EXPECT_EQ(2, model_->item_count());
1462
1463   AddButtonsUntilOverflow();
1464
1465   // Show overflow bubble.
1466   test_api_->ShowOverflowBubble();
1467   ASSERT_TRUE(test_api_->overflow_bubble() &&
1468               test_api_->overflow_bubble()->IsShowing());
1469
1470   int item_width = test_api_->GetButtonSize() +
1471       test_api_->GetButtonSpacing();
1472   OverflowBubbleView* bubble_view = test_api_->overflow_bubble()->bubble_view();
1473   test::OverflowBubbleViewTestAPI bubble_view_api(bubble_view);
1474
1475   // Add more buttons until OverflowBubble is scrollable and it has 3 invisible
1476   // items.
1477   while (bubble_view_api.GetContentsSize().width() <
1478          (bubble_view->GetContentsBounds().width() + 3 * item_width))
1479     AddAppShortcut();
1480
1481   ASSERT_TRUE(test_api_->overflow_bubble() &&
1482               test_api_->overflow_bubble()->IsShowing());
1483
1484   ShelfViewTestAPI test_for_overflow_view(
1485       test_api_->overflow_bubble()->shelf_view());
1486   int first_index = test_for_overflow_view.GetFirstVisibleIndex();
1487   int last_index = test_for_overflow_view.GetLastVisibleIndex();
1488
1489   ShelfButton* first_button = test_for_overflow_view.GetButton(first_index);
1490   ShelfButton* last_button = test_for_overflow_view.GetButton(last_index);
1491   gfx::Point first_point = first_button->GetBoundsInScreen().CenterPoint();
1492   gfx::Point last_point = last_button->GetBoundsInScreen().CenterPoint();
1493   gfx::Rect drag_reinsert_bounds =
1494       test_for_overflow_view.GetBoundsForDragInsertInScreen();
1495   EXPECT_TRUE(drag_reinsert_bounds.Contains(first_point));
1496   EXPECT_FALSE(drag_reinsert_bounds.Contains(last_point));
1497
1498   // Scrolls sufficiently to show last item.
1499   bubble_view_api.ScrollByXOffset(3 * item_width);
1500   drag_reinsert_bounds =
1501       test_for_overflow_view.GetBoundsForDragInsertInScreen();
1502   first_point = first_button->GetBoundsInScreen().CenterPoint();
1503   last_point = last_button->GetBoundsInScreen().CenterPoint();
1504   EXPECT_FALSE(drag_reinsert_bounds.Contains(first_point));
1505   EXPECT_TRUE(drag_reinsert_bounds.Contains(last_point));
1506 }
1507
1508 // Check the drag insertion bounds of shelf view in multi monitor environment.
1509 TEST_F(ShelfViewTest, CheckDragInsertBoundsWithMultiMonitor) {
1510   // win8-aura doesn't support multiple display.
1511   if (!SupportsMultipleDisplays())
1512     return;
1513
1514   UpdateDisplay("800x600,800x600");
1515   Shelf* secondary_shelf = Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
1516   ShelfView* shelf_view_for_secondary =
1517       ShelfTestAPI(secondary_shelf).shelf_view();
1518
1519   // The bounds should be big enough for 4 buttons + overflow chevron.
1520   shelf_view_for_secondary->SetBounds(0, 0, 500, kShelfSize);
1521
1522   ShelfViewTestAPI test_api_for_secondary(shelf_view_for_secondary);
1523   // Speeds up animation for test.
1524   test_api_for_secondary.SetAnimationDuration(1);
1525
1526   AddButtonsUntilOverflow();
1527
1528   // Test #1: Test drag insertion bounds of primary shelf.
1529   // Show overflow bubble.
1530   test_api_->ShowOverflowBubble();
1531   ASSERT_TRUE(test_api_->overflow_bubble() &&
1532               test_api_->overflow_bubble()->IsShowing());
1533
1534   ShelfViewTestAPI test_api_for_overflow_view(
1535       test_api_->overflow_bubble()->shelf_view());
1536
1537   ShelfButton* button = test_api_for_overflow_view.GetButton(
1538       test_api_for_overflow_view.GetLastVisibleIndex());
1539
1540   // Checks that a point in shelf is contained in drag insert bounds.
1541   gfx::Point point_in_shelf_view = button->GetBoundsInScreen().CenterPoint();
1542   gfx::Rect drag_reinsert_bounds =
1543       test_api_for_overflow_view.GetBoundsForDragInsertInScreen();
1544   EXPECT_TRUE(drag_reinsert_bounds.Contains(point_in_shelf_view));
1545   // Checks that a point out of shelf is not contained in drag insert bounds.
1546   EXPECT_FALSE(drag_reinsert_bounds.Contains(
1547       gfx::Point(point_in_shelf_view.x(), 0)));
1548
1549   // Test #2: Test drag insertion bounds of secondary shelf.
1550   // Show overflow bubble.
1551   test_api_for_secondary.ShowOverflowBubble();
1552   ASSERT_TRUE(test_api_for_secondary.overflow_bubble() &&
1553               test_api_for_secondary.overflow_bubble()->IsShowing());
1554
1555   ShelfViewTestAPI test_api_for_overflow_view_of_secondary(
1556       test_api_for_secondary.overflow_bubble()->shelf_view());
1557
1558   ShelfButton* button_in_secondary =
1559       test_api_for_overflow_view_of_secondary.GetButton(
1560           test_api_for_overflow_view_of_secondary.GetLastVisibleIndex());
1561
1562   // Checks that a point in shelf is contained in drag insert bounds.
1563   gfx::Point point_in_secondary_shelf_view =
1564       button_in_secondary->GetBoundsInScreen().CenterPoint();
1565   gfx::Rect drag_reinsert_bounds_in_secondary =
1566       test_api_for_overflow_view_of_secondary.GetBoundsForDragInsertInScreen();
1567   EXPECT_TRUE(drag_reinsert_bounds_in_secondary.Contains(
1568       point_in_secondary_shelf_view));
1569   // Checks that a point out of shelf is not contained in drag insert bounds.
1570   EXPECT_FALSE(drag_reinsert_bounds_in_secondary.Contains(
1571       gfx::Point(point_in_secondary_shelf_view.x(), 0)));
1572   // Checks that a point of overflow bubble in primary shelf should not be
1573   // contained by insert bounds of secondary shelf.
1574   EXPECT_FALSE(drag_reinsert_bounds_in_secondary.Contains(point_in_shelf_view));
1575 }
1576
1577 // Checks the rip an item off from left aligned shelf in secondary monitor.
1578 TEST_F(ShelfViewTest, CheckRipOffFromLeftShelfAlignmentWithMultiMonitor) {
1579   // win8-aura doesn't support multiple display.
1580   if (!SupportsMultipleDisplays())
1581     return;
1582
1583   UpdateDisplay("800x600,800x600");
1584   ASSERT_EQ(2U, Shell::GetAllRootWindows().size());
1585
1586   aura::Window* second_root = Shell::GetAllRootWindows()[1];
1587
1588   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT, second_root);
1589   ASSERT_EQ(SHELF_ALIGNMENT_LEFT,
1590             Shell::GetInstance()->GetShelfAlignment(second_root));
1591
1592   // Initially, app list and browser shortcut are added.
1593   EXPECT_EQ(2, model_->item_count());
1594   int browser_index = model_->GetItemIndexForType(TYPE_BROWSER_SHORTCUT);
1595   EXPECT_GT(browser_index, 0);
1596
1597   Shelf* secondary_shelf = Shelf::ForWindow(second_root);
1598   ShelfView* shelf_view_for_secondary =
1599       ShelfTestAPI(secondary_shelf).shelf_view();
1600
1601   ShelfViewTestAPI test_api_for_secondary_shelf_view(shelf_view_for_secondary);
1602   ShelfButton* button =
1603       test_api_for_secondary_shelf_view.GetButton(browser_index);
1604
1605   // Fetch the start point of dragging.
1606   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
1607   wm::ConvertPointFromScreen(second_root, &start_point);
1608
1609   aura::test::EventGenerator generator(second_root, start_point);
1610
1611   // Rip off the browser item.
1612   generator.PressLeftButton();
1613   generator.MoveMouseTo(start_point.x() + 400, start_point.y());
1614   test_api_for_secondary_shelf_view.RunMessageLoopUntilAnimationsDone();
1615   EXPECT_TRUE(test_api_for_secondary_shelf_view.IsRippedOffFromShelf());
1616 }
1617
1618 // Checks various drag and drop operations from OverflowBubble to Shelf.
1619 TEST_F(ShelfViewTest, CheckDragAndDropFromOverflowBubbleToShelf) {
1620   // Replace current ShelfDelegate with TestShelfDelegateForShelfView.
1621   ReplaceShelfDelegateForRipOffTest();
1622
1623   AddButtonsUntilOverflow();
1624
1625   TestDraggingAnItemFromOverflowToShelf(false);
1626   TestDraggingAnItemFromOverflowToShelf(true);
1627 }
1628
1629 class ShelfViewVisibleBoundsTest : public ShelfViewTest,
1630                                    public testing::WithParamInterface<bool> {
1631  public:
1632   ShelfViewVisibleBoundsTest() : text_direction_change_(GetParam()) {}
1633
1634   void CheckAllItemsAreInBounds() {
1635     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
1636     gfx::Rect shelf_bounds = shelf_view_->GetBoundsInScreen();
1637     EXPECT_TRUE(shelf_bounds.Contains(visible_bounds));
1638     for (int i = 0; i < test_api_->GetButtonCount(); ++i)
1639       if (ShelfButton* button = test_api_->GetButton(i))
1640         EXPECT_TRUE(visible_bounds.Contains(button->GetBoundsInScreen()));
1641     CheckAppListButtonIsInBounds();
1642   }
1643
1644   void CheckAppListButtonIsInBounds() {
1645     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
1646     gfx::Rect app_list_button_bounds = shelf_view_->GetAppListButtonView()->
1647        GetBoundsInScreen();
1648     EXPECT_TRUE(visible_bounds.Contains(app_list_button_bounds));
1649   }
1650
1651  private:
1652   ScopedTextDirectionChange text_direction_change_;
1653
1654   DISALLOW_COPY_AND_ASSIGN(ShelfViewVisibleBoundsTest);
1655 };
1656
1657 TEST_P(ShelfViewVisibleBoundsTest, ItemsAreInBounds) {
1658   // Adding elements leaving some empty space.
1659   for (int i = 0; i < 3; i++) {
1660     AddAppShortcut();
1661   }
1662   test_api_->RunMessageLoopUntilAnimationsDone();
1663   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
1664   CheckAllItemsAreInBounds();
1665   // Same for overflow case.
1666   while (!test_api_->IsOverflowButtonVisible()) {
1667     AddAppShortcut();
1668   }
1669   test_api_->RunMessageLoopUntilAnimationsDone();
1670   CheckAllItemsAreInBounds();
1671 }
1672
1673 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
1674 INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
1675     testing::Bool());
1676
1677 }  // namespace test
1678 }  // namespace ash