Store AppItems as pages in AppListModel.

ui/app_list/views/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/views/apps_grid_view.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/pagination_model.h"
 #include "ui/app_list/test/app_list_test_model.h"
 #include "ui/app_list/views/app_list_item_view.h"
 #include "ui/app_list/views/test/apps_grid_view_test_api.h"
+#include "ui/views/test/views_test_base.h"
 
 namespace app_list {
 namespace test {
 
 namespace {
 
 const int kIconDimension = 48;
 const int kCols = 2;
 const int kRows = 2;
 const int kTilesPerPage = kCols * kRows;
@@ skipping 52 matching lines @@
   PaginationModel* model_;
   bool wait_;
   bool page_changed_;
   base::OneShotTimer<PageFlipWaiter> wait_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(PageFlipWaiter);
 };
 
 }  // namespace
 
-class AppsGridViewTest : public testing::Test {
+class AppsGridViewTest : public views::ViewsTestBase {
  public:
   AppsGridViewTest() {}
   virtual ~AppsGridViewTest() {}
 
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
+    views::ViewsTestBase::SetUp();
     model_.reset(new AppListTestModel);
     pagination_model_.reset(new PaginationModel);
 
     apps_grid_view_.reset(
         new AppsGridView(NULL, pagination_model_.get(), NULL));
     apps_grid_view_->SetLayout(kIconDimension, kCols, kRows);
     apps_grid_view_->SetBoundsRect(gfx::Rect(gfx::Size(kWidth, kHeight)));
     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.
+    views::ViewsTestBase::TearDown();
   }
 
  protected:
   AppListItemView* GetItemViewAt(int index) {
     return static_cast<AppListItemView*>(
         test_api_->GetViewAtModelIndex(index));
   }
 
   AppListItemView* GetItemViewForPoint(const gfx::Point& point) {
-    for (size_t i = 0; i < model_->apps()->item_count(); ++i) {
-      AppListItemView* view = GetItemViewAt(i);
-      if (view->bounds().Contains(point))
-        return view;
+    for (size_t p = 0; p < model_->GetNumAppPages(); ++p) {
+      const AppListModel::AppItems& apps = model_->GetAppItems(p);
+      size_t offset = p * model_->GetNumAppsPerPage();
+      for (size_t i = 0; i < apps.item_count(); ++i) {
+        AppListItemView* view = GetItemViewAt(offset + i);
+        if (view->bounds().Contains(point))
+          return view;
+      }
     }
     return NULL;
   }
 
   gfx::Rect GetItemTileRectAt(int row, int col) {
-    DCHECK_GT(model_->apps()->item_count(), 0u);
+    DCHECK_GT(model_->GetAppItems(0).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,
@@ skipping 19 matching lines @@
   void SimulateKeyPress(ui::KeyboardCode key_code) {
     ui::KeyEvent key_event(ui::ET_KEY_PRESSED, key_code, 0, false);
     apps_grid_view_->OnKeyPressed(key_event);
   }
 
   scoped_ptr<AppListTestModel> model_;
   scoped_ptr<PaginationModel> pagination_model_;
   scoped_ptr<AppsGridView> apps_grid_view_;
   scoped_ptr<AppsGridViewTestApi> test_api_;
 
-  base::MessageLoopForUI message_loop_;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(AppsGridViewTest);
 };
 
 TEST_F(AppsGridViewTest, CreatePage) {
   // Fully populates a page.
   const int kPages = 1;
   model_->PopulateApps(kPages * kTilesPerPage);
   EXPECT_EQ(kPages, pagination_model_->total_pages());
 
   // Adds one more and gets a new page created.
-  model_->AddItem(std::string("Extra"));
+  model_->CreateAndAddItem(std::string("Extra"));
   EXPECT_EQ(kPages + 1, pagination_model_->total_pages());
 }
 
 TEST_F(AppsGridViewTest, EnsureHighlightedVisible) {
   const int kPages = 3;
   model_->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.
   model_->HighlightItemAt(0);
   EXPECT_EQ(0, pagination_model_->selected_page());
   model_->HighlightItemAt(kTilesPerPage - 1);
   EXPECT_EQ(0, pagination_model_->selected_page());
 
   // Highlight first one on 2nd page and 2nd page should be selected.
   model_->HighlightItemAt(kTilesPerPage + 1);
   EXPECT_EQ(1, pagination_model_->selected_page());
 
   // Highlight last one in the model and last page should be selected.
-  model_->HighlightItemAt(model_->apps()->item_count() - 1);
+  model_->HighlightItemAt(kPages * kTilesPerPage - 1);
   EXPECT_EQ(kPages - 1, pagination_model_->selected_page());
 }
 
 TEST_F(AppsGridViewTest, RemoveSelectedLastApp) {
   const int kTotalItems = 2;
   const int kLastItemIndex = kTotalItems - 1;
 
   model_->PopulateApps(kTotalItems);
 
   AppListItemView* last_view = GetItemViewAt(kLastItemIndex);
   apps_grid_view_->SetSelectedView(last_view);
-  model_->apps()->DeleteAt(kLastItemIndex);
+  model_->DeleteItemAt(0, 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"),
             model_->GetModelContent());
   test_api_->LayoutToIdealBounds();
 
   // Deleting an item keeps remaining intact.
   SimulateDrag(AppsGridView::MOUSE, from, to);
-  model_->apps()->DeleteAt(1);
+  model_->DeleteItemAt(0, 1);
   apps_grid_view_->EndDrag(false);
   EXPECT_EQ(std::string("Item 1,Item 2,Item 3"),
             model_->GetModelContent());
   test_api_->LayoutToIdealBounds();
 
   // Adding a launcher item cancels the drag and respects the order.
   SimulateDrag(AppsGridView::MOUSE, from, to);
-  model_->AddItem(std::string("Extra"));
+  model_->CreateAndAddItem(std::string("Extra"));
   apps_grid_view_->EndDrag(false);
   EXPECT_EQ(std::string("Item 1,Item 2,Item 3,Extra"),
             model_->GetModelContent());
   test_api_->LayoutToIdealBounds();
 }
 
 TEST_F(AppsGridViewTest, MouseDragFlipPage) {
   test_api_->SetPageFlipDelay(10);
   pagination_model_->SetTransitionDurations(10, 10);
 
-  PageFlipWaiter page_flip_waiter(&message_loop_,
+  PageFlipWaiter page_flip_waiter(message_loop(),
                                   pagination_model_.get());
 
   const int kPages = 3;
   model_->PopulateApps(kPages * kTilesPerPage);
   EXPECT_EQ(kPages, pagination_model_->total_pages());
   EXPECT_EQ(0, pagination_model_->selected_page());
 
   gfx::Point from = GetItemTileRectAt(0, 0).CenterPoint();
   gfx::Point to = gfx::Point(apps_grid_view_->width(),
                              apps_grid_view_->height() / 2);
@@ skipping 140 matching lines @@
   SimulateKeyPress(ui::VKEY_UP);
   EXPECT_TRUE(apps_grid_view_->IsSelectedView(GetItemViewAt(
       first_index_on_page2)));
 }
 
 TEST_F(AppsGridViewTest, ItemLabelShortNameOverride) {
   // If the app's full name and short name differ, the title label's tooltip
   // should always be the full name of the app.
   std::string expected_text("xyz");
   std::string expected_tooltip("tooltip");
-  model_->AddItem(expected_text, expected_tooltip);
+  model_->CreateAndAddItem(expected_text, expected_tooltip);
 
   string16 actual_tooltip;
   AppListItemView* item_view = GetItemViewAt(0);
   ASSERT_TRUE(item_view);
   const views::Label* title_label = item_view->title();
   EXPECT_TRUE(title_label->GetTooltipText(
       title_label->bounds().CenterPoint(), &actual_tooltip));
   EXPECT_EQ(expected_tooltip, UTF16ToUTF8(actual_tooltip));
   EXPECT_EQ(expected_text, UTF16ToUTF8(title_label->text()));
 }
 
 TEST_F(AppsGridViewTest, ItemLabelNoShortName) {
   // If the app's full name and short name are the same, use the default tooltip
   // behavior of the label (only show a tooltip if the title is truncated).
   std::string title("a");
-  model_->AddItem(title, title);
+  model_->CreateAndAddItem(title, title);
 
   string16 actual_tooltip;
   AppListItemView* item_view = GetItemViewAt(0);
   ASSERT_TRUE(item_view);
   const views::Label* title_label = item_view->title();
   EXPECT_FALSE(title_label->GetTooltipText(
       title_label->bounds().CenterPoint(), &actual_tooltip));
   EXPECT_EQ(title, UTF16ToUTF8(title_label->text()));
 }
 
 }  // namespace test
 }  // namespace app_list