Store AppItems as pages in AppListModel.

ui/app_list/cocoa/apps_grid_controller.mm

 // Copyright 2013 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.
 
 #import "ui/app_list/cocoa/apps_grid_controller.h"
 
 #include "base/mac/foundation_util.h"
 #include "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/app_list_model_observer.h"
@@ skipping 75 matching lines @@
 - (void)listItemMovedFromIndex:(size_t)fromIndex
                   toModelIndex:(size_t)toIndex;
 
 // Moves the selection by |indexDelta| items.
 - (BOOL)moveSelectionByDelta:(int)indexDelta;
 
 @end
 
 namespace app_list {
 
-class AppsGridDelegateBridge : public ui::ListModelObserver {
+class AppsGridDelegateBridge : public AppListModelObserver {
  public:
   AppsGridDelegateBridge(AppsGridController* parent) : parent_(parent) {}
 
  private:
   // Overridden from ui::ListModelObserver:
-  virtual void ListItemsAdded(size_t start, size_t count) OVERRIDE {
-    [parent_ listItemsAdded:start
+  virtual void OnListItemsAdded(size_t page_index,
+                                size_t start, size_t count) OVERRIDE {
+    size_t start_index = page_index * kItemsPerPage + start;
+    [parent_ listItemsAdded:start_index
                       count:count];
   }
-  virtual void ListItemsRemoved(size_t start, size_t count) OVERRIDE {
-    [parent_ listItemsRemoved:start
+  virtual void OnListItemsRemoved(size_t page_index,
+                                  size_t start, size_t count) OVERRIDE {
+    size_t start_index = page_index * kItemsPerPage + start;
+    [parent_ listItemsRemoved:start_index
                         count:count];
   }
-  virtual void ListItemMoved(size_t index, size_t target_index) OVERRIDE {
-    [parent_ listItemMovedFromIndex:index
-                       toModelIndex:target_index];
-  }
-  virtual void ListItemsChanged(size_t start, size_t count) OVERRIDE {
-    NOTREACHED();
+  virtual void OnListItemMoved(size_t page_index,
+                               size_t index, size_t target_index) OVERRIDE {
+    size_t from_index = page_index * kItemsPerPage + index;
+    size_t to_index = page_index * kItemsPerPage + target_index;
+    [parent_ listItemMovedFromIndex:from_index
+                       toModelIndex:to_index];
   }
 
   AppsGridController* parent_;  // Weak, owns us.
 
   DISALLOW_COPY_AND_ASSIGN(AppsGridDelegateBridge);
 };
 
 }  // namespace app_list
 
 @interface PageContainerView : NSView;
@@ skipping 55 matching lines @@
   }
   return NSNotFound;
 }
 
 - (app_list::AppListModel*)model {
   return model_.get();
 }
 
 - (void)setModel:(scoped_ptr<app_list::AppListModel>)newModel {
   if (model_) {
-    model_->apps()->RemoveObserver(bridge_.get());
+    model_->RemoveObserver(bridge_.get());
 
     // Since the model is about to be deleted, and the AppKit objects might be
     // sitting in an NSAutoreleasePool, ensure there are no references to the
     // model.
     for (size_t i = 0; i < [items_ count]; ++i)
       [[self itemAtIndex:i] setModel:NULL];
 
     [items_ removeAllObjects];
     [self updatePages:0];
     [self scrollToPage:0];
   }
 
   model_.reset(newModel.release());
   if (!model_)
     return;
 
-  model_->apps()->AddObserver(bridge_.get());
-  [self listItemsAdded:0
-                 count:model_->apps()->item_count()];
+  model_->AddObserver(bridge_.get());
+  for (size_t p = 0; p < model_->GetNumAppPages(); ++p) {
+    size_t start_index = p * kItemsPerPage;
+    [self listItemsAdded:start_index
+                   count:model_->GetAppItemsForPage(p).item_count()];
+  }
 }
 
 - (void)setDelegate:(app_list::AppListViewDelegate*)newDelegate {
   scoped_ptr<app_list::AppListModel> newModel(new app_list::AppListModel);
   delegate_ = newDelegate;
   if (delegate_)
     delegate_->InitModel(newModel.get());  // Populates items.
   [self setModel:newModel.Pass()];
 }
 
@@ skipping 294 matching lines @@
   }
 }
 
 // Compare with views implementation in AppsGridView::MoveItemInModel().
 - (void)moveItemWithIndex:(size_t)itemIndex
              toModelIndex:(size_t)modelIndex {
   // Ingore no-op moves. Note that this is always the case when canceled.
   if (itemIndex == modelIndex)
     return;
 
-  model_->apps()->RemoveObserver(bridge_.get());
-  model_->apps()->Move(itemIndex, modelIndex);
-  model_->apps()->AddObserver(bridge_.get());
+  size_t itemPageIndex = itemIndex / kItemsPerPage;
+  itemIndex -= itemPageIndex * kItemsPerPage;
+  size_t modelPageIndex = modelIndex / kItemsPerPage;
+  modelIndex -= modelPageIndex * kItemsPerPage;
+  model_->RemoveObserver(bridge_.get());
+  model_->MoveItem(itemPageIndex, itemIndex, modelPageIndex, modelIndex);
+  model_->AddObserver(bridge_.get());
 }
 
 - (AppsCollectionViewDragManager*)dragManager {
   return dragManager_;
 }
 
 - (size_t)scheduledScrollPage {
   return scheduledScrollPage_;
 }
 
 - (void)listItemsAdded:(size_t)start
                  count:(size_t)count {
   // Cancel any drag, to ensure the model stays consistent.
   [dragManager_ cancelDrag];
 
   for (size_t i = start; i < start + count; ++i) {
-    app_list::AppListItemModel* itemModel = model_->apps()->GetItemAt(i);
+    size_t page = i / kItemsPerPage;
+    size_t index = i - page * kItemsPerPage;
+    app_list::AppListItemModel* itemModel = model_->GetItemAt(page, index);
     [items_ insertObject:[NSValue valueWithPointer:itemModel]
                  atIndex:i];
   }
 
   [self updatePages:start];
 }
 
 - (void)listItemsRemoved:(size_t)start
                    count:(size_t)count {
   [dragManager_ cancelDrag];
@@ skipping 116 matching lines @@
     return [self moveSelectionByDelta:-kItemsPerPage];
 
   if (command == @selector(pageDown:) ||
       command == @selector(scrollPageDown:))
     return [self moveSelectionByDelta:kItemsPerPage];
 
   return NO;
 }
 
 @end