app_list: Add sync animation.

ui/app_list/apps_grid_view_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/app_list/apps_grid_view.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 77 matching lines @@
 
 }  // namespace
 
 class AppsGridViewTest : public testing::Test {
  public:
   AppsGridViewTest() {}
   virtual ~AppsGridViewTest() {}
 
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
-    apps_model_.reset(new AppListModel::Apps);
+    model_.reset(new AppListModel);
     pagination_model_.reset(new PaginationModel);
 
     apps_grid_view_.reset(new AppsGridView(NULL, pagination_model_.get()));
     apps_grid_view_->SetLayout(kIconDimension, kCols, kRows);
     apps_grid_view_->SetBoundsRect(gfx::Rect(gfx::Size(kWidth, kHeight)));
-    apps_grid_view_->SetModel(apps_model_.get());
+    apps_grid_view_->SetModel(model_.get());
 
     test_api_.reset(new AppsGridViewTestApi(apps_grid_view_.get()));
   }
   virtual void TearDown() OVERRIDE {
     apps_grid_view_.reset();  // Release apps grid view before models.
   }
 
  protected:
   void PopulateApps(int n) {
     for (int i = 0; i < n; ++i) {
       std::string title = base::StringPrintf("Item %d", i);
-      apps_model_->Add(CreateItem(title));
+      model_->apps()->Add(CreateItem(title));
     }
   }
 
   // Get a string of all apps in |model| joined with ','.
   std::string GetModelContent() {
     std::string content;
-    for (size_t i = 0; i < apps_model_->item_count(); ++i) {
+    for (size_t i = 0; i < model_->apps()->item_count(); ++i) {
       if (i > 0)
         content += ',';
-      content += apps_model_->GetItemAt(i)->title();
+      content += model_->apps()->GetItemAt(i)->title();
     }
     return content;
   }
 
   AppListItemModel* CreateItem(const std::string& title) {
     AppListItemModel* item = new AppListItemModel;
     item->SetTitle(title);
     return item;
   }
 
   void HighlightItemAt(int index) {
-    AppListItemModel* item = apps_model_->GetItemAt(index);
+    AppListItemModel* item = model_->apps()->GetItemAt(index);
     item->SetHighlighted(true);
   }
 
   AppListItemView* GetItemViewAt(int index) {
     return static_cast<AppListItemView*>(
         test_api_->GetViewAtModelIndex(index));
   }
 
   AppListItemView* GetItemViewForPoint(const gfx::Point& point) {
-    for (size_t i = 0; i < apps_model_->item_count(); ++i) {
+    for (size_t i = 0; i < model_->apps()->item_count(); ++i) {
       AppListItemView* view = GetItemViewAt(i);
       if (view->bounds().Contains(point))
         return view;
     }
     return NULL;
   }
 
   gfx::Rect GetItemTileRectAt(int row, int col) {
-    DCHECK_GT(apps_model_->item_count(), 0u);
+    DCHECK_GT(model_->apps()->item_count(), 0u);
 
     gfx::Insets insets(apps_grid_view_->GetInsets());
     gfx::Rect rect(gfx::Point(insets.left(), insets.top()),
                    GetItemViewAt(0)->bounds().size());
     rect.Offset(col * rect.width(), row * rect.height());
     return rect;
   }
 
   // Points are in |apps_grid_view_|'s coordinates.
   void SimulateDrag(AppsGridView::Pointer pointer,
                     const gfx::Point& from,
                     const gfx::Point& to) {
     AppListItemView* view = GetItemViewForPoint(from);
     DCHECK(view);
 
-    gfx::Point translated_from = from.Subtract(view->bounds().origin());
-    gfx::Point translated_to = to.Subtract(view->bounds().origin());
+    gfx::Point translated_from = gfx::PointAtOffsetFromOrigin(
+        from - view->bounds().origin());
+    gfx::Point translated_to = gfx::PointAtOffsetFromOrigin(
+        to - view->bounds().origin());
 
     ui::MouseEvent pressed_event(ui::ET_MOUSE_PRESSED,
                                  translated_from, translated_from, 0);
     apps_grid_view_->InitiateDrag(view, pointer, pressed_event);
 
     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED,
                               translated_to, translated_to, 0);
     apps_grid_view_->UpdateDrag(view, pointer, drag_event);
   }
 
-  scoped_ptr<AppListModel::Apps> apps_model_;
+  scoped_ptr<AppListModel> model_;
   scoped_ptr<PaginationModel> pagination_model_;
   scoped_ptr<AppsGridView> apps_grid_view_;
   scoped_ptr<AppsGridViewTestApi> test_api_;
 
   MessageLoopForUI message_loop_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppsGridViewTest);
 };
 
 TEST_F(AppsGridViewTest, CreatePage) {
   // Fully populates a page.
   const int kPages = 1;
   PopulateApps(kPages * kTilesPerPage);
   EXPECT_EQ(kPages, pagination_model_->total_pages());
 
   // Adds one more and gets a new page created.
-  apps_model_->Add(CreateItem(std::string("Extra")));
+  model_->apps()->Add(CreateItem(std::string("Extra")));
   EXPECT_EQ(kPages + 1, pagination_model_->total_pages());
 }
 
 TEST_F(AppsGridViewTest, EnsureHighlightedVisible) {
   const int kPages = 3;
   PopulateApps(kPages * kTilesPerPage);
   EXPECT_EQ(kPages, pagination_model_->total_pages());
   EXPECT_EQ(0, pagination_model_->selected_page());
 
   // Highlight first one and last one one first page and first page should be
   // selected.
   HighlightItemAt(0);
   EXPECT_EQ(0, pagination_model_->selected_page());
   HighlightItemAt(kTilesPerPage - 1);
   EXPECT_EQ(0, pagination_model_->selected_page());
 
   // Highlight first one on 2nd page and 2nd page should be selected.
   HighlightItemAt(kTilesPerPage + 1);
   EXPECT_EQ(1, pagination_model_->selected_page());
 
   // Highlight last one in the model and last page should be selected.
-  HighlightItemAt(apps_model_->item_count() - 1);
+  HighlightItemAt(model_->apps()->item_count() - 1);
   EXPECT_EQ(kPages - 1, pagination_model_->selected_page());
 }
 
 TEST_F(AppsGridViewTest, RemoveSelectedLastApp) {
   const int kTotalItems = 2;
   const int kLastItemIndex = kTotalItems - 1;
 
   PopulateApps(kTotalItems);
 
   AppListItemView* last_view = GetItemViewAt(kLastItemIndex);
   apps_grid_view_->SetSelectedView(last_view);
-  apps_model_->DeleteAt(kLastItemIndex);
+  model_->apps()->DeleteAt(kLastItemIndex);
 
   EXPECT_FALSE(apps_grid_view_->IsSelectedView(last_view));
 
   // No crash happens.
   AppListItemView* view = GetItemViewAt(0);
   apps_grid_view_->SetSelectedView(view);
   EXPECT_TRUE(apps_grid_view_->IsSelectedView(view));
 }
 
 TEST_F(AppsGridViewTest, MouseDrag) {
@@ skipping 14 matching lines @@
 
   // Canceling drag should keep existing order.
   SimulateDrag(AppsGridView::MOUSE, from, to);
   apps_grid_view_->EndDrag(true);
   EXPECT_EQ(std::string("Item 1,Item 0,Item 2,Item 3"),
             GetModelContent());
   test_api_->LayoutToIdealBounds();
 
   // Deleting an item keeps remaining intact.
   SimulateDrag(AppsGridView::MOUSE, from, to);
-  apps_model_->DeleteAt(1);
+  model_->apps()->DeleteAt(1);
   apps_grid_view_->EndDrag(false);
   EXPECT_EQ(std::string("Item 1,Item 2,Item 3"),
             GetModelContent());
   test_api_->LayoutToIdealBounds();
 
   // Adding a launcher item cancels the drag and respects the order.
   SimulateDrag(AppsGridView::MOUSE, from, to);
-  apps_model_->Add(CreateItem(std::string("Extra")));
+  model_->apps()->Add(CreateItem(std::string("Extra")));
   apps_grid_view_->EndDrag(false);
   EXPECT_EQ(std::string("Item 1,Item 2,Item 3,Extra"),
             GetModelContent());
   test_api_->LayoutToIdealBounds();
 }
 
 TEST_F(AppsGridViewTest, MouseDragFlipPage) {
   test_api_->SetPageFlipDelay(10);
   pagination_model_->SetTransitionDuration(10);
 
@@ skipping 68 matching lines @@
   SimulateDrag(AppsGridView::MOUSE, mouse_from, mouse_to);
   // Finishes the drag and touch drag wins.
   apps_grid_view_->EndDrag(false);
   EXPECT_EQ(std::string("Item 1,Item 0,Item 3,Item 2"),
             GetModelContent());
   test_api_->LayoutToIdealBounds();
 }
 
 }  // namespace test
 }  // namespace app_list