Refactor app list so AppsGridView owns the PaginationModel.

ui/app_list/views/apps_grid_view.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 <algorithm>
 #include <set>
 #include <string>
 
 #include "base/guid.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_switches.h"
-#include "ui/app_list/pagination_model.h"
 #include "ui/app_list/views/app_list_drag_and_drop_host.h"
 #include "ui/app_list/views/app_list_folder_view.h"
 #include "ui/app_list/views/app_list_item_view.h"
 #include "ui/app_list/views/apps_grid_view_delegate.h"
 #include "ui/app_list/views/page_switcher.h"
 #include "ui/app_list/views/pulsing_block_view.h"
 #include "ui/app_list/views/top_icon_animation_view.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/gfx/animation/animation.h"
@@ skipping 300 matching lines @@
   gfx::Point drag_view_offset_;
   bool has_shortcut_path_;
   base::FilePath shortcut_path_;
   bool running_;
   bool canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(SynchronousDrag);
 };
 #endif  // defined(OS_WIN)
 
-AppsGridView::AppsGridView(AppsGridViewDelegate* delegate,
-                           PaginationModel* pagination_model)
+AppsGridView::AppsGridView(AppsGridViewDelegate* delegate)
     : model_(NULL),
       item_list_(NULL),
       delegate_(delegate),
       folder_delegate_(NULL),
-      pagination_model_(pagination_model),
-      page_switcher_view_(new PageSwitcher(pagination_model)),
+      page_switcher_view_(NULL),
       cols_(0),
       rows_per_page_(0),
       selected_view_(NULL),
       drag_view_(NULL),
       drag_start_page_(-1),
 #if defined(OS_WIN)
       use_synchronous_drag_(true),
 #endif
       drag_pointer_(NONE),
       drop_attempt_(DROP_FOR_NONE),
       drag_and_drop_host_(NULL),
       forward_events_to_drag_and_drop_host_(false),
       page_flip_target_(-1),
       page_flip_delay_in_ms_(kPageFlipDelayInMs),
       bounds_animator_(this),
       activated_folder_item_view_(NULL),
       dragging_for_reparent_item_(false) {
   SetPaintToLayer(true);
   // Clip any icons that are outside the grid view's bounds. These icons would
   // otherwise be visible to the user when the grid view is off screen.
   layer()->SetMasksToBounds(true);
   SetFillsBoundsOpaquely(false);
 
-  pagination_model_->AddObserver(this);
+  pagination_model_.SetTransitionDurations(kPageTransitionDurationInMs,
+                                           kOverscrollPageTransitionDurationMs);
+
+  pagination_model_.AddObserver(this);
+  page_switcher_view_ = new PageSwitcher(&pagination_model_);
   AddChildView(page_switcher_view_);
 }
 
 AppsGridView::~AppsGridView() {
   // Coming here |drag_view_| should already be canceled since otherwise the
   // drag would disappear after the app list got animated away and closed,
   // which would look odd.
   DCHECK(!drag_view_);
   if (drag_view_)
     EndDrag(true);
 
   if (model_)
     model_->RemoveObserver(this);
-  pagination_model_->RemoveObserver(this);
+  pagination_model_.RemoveObserver(this);
 
   if (item_list_)
     item_list_->RemoveObserver(this);
+
+  // Make sure |page_switcher_view_| is deleted before |pagination_model_|.
+  view_model_.Clear();
+  RemoveAllChildViews(true);
 }
 
 void AppsGridView::SetLayout(int icon_size, int cols, int rows_per_page) {
   icon_size_.SetSize(icon_size, icon_size);
   cols_ = cols;
   rows_per_page_ = rows_per_page;
 
   SetBorder(views::Border::CreateEmptyBorder(
       kTopPadding, kLeftRightPadding, 0, kLeftRightPadding));
 }
@@ skipping 53 matching lines @@
     selected_view_->SchedulePaint();
     selected_view_ = NULL;
   }
 }
 
 bool AppsGridView::IsSelectedView(const views::View* view) const {
   return selected_view_ == view;
 }
 
 void AppsGridView::EnsureViewVisible(const views::View* view) {
-  if (pagination_model_->has_transition())
+  if (pagination_model_.has_transition())
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
-    pagination_model_->SelectPage(index.page, false);
+    pagination_model_.SelectPage(index.page, false);
 }
 
 void AppsGridView::InitiateDrag(AppListItemView* view,
                                 Pointer pointer,
                                 const ui::LocatedEvent& event) {
   DCHECK(view);
   if (drag_view_ || pulsing_blocks_model_.view_size())
     return;
 
   drag_view_ = view;
   drag_view_init_index_ = GetIndexOfView(drag_view_);
   drag_view_offset_ = event.location();
-  drag_start_page_ = pagination_model_->selected_page();
+  drag_start_page_ = pagination_model_.selected_page();
   ExtractDragLocation(event, &drag_start_grid_view_);
   drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
 }
 
 void AppsGridView::StartSettingUpSynchronousDrag() {
 #if defined(OS_WIN)
   if (!delegate_ || !use_synchronous_drag_)
     return;
 
   // Folders can't be integrated with the OS.
@@ skipping 289 matching lines @@
   drag_view_->SetDragUIState();  // Hide the title of the drag_view_.
 
   // Hide the drag_view_ for drag icon proxy.
   SetViewHidden(drag_view_,
                 true /* hide */,
                 true /* no animate */);
 
   // Add drag_view_ to the end of the view_model_.
   view_model_.Add(drag_view_, view_model_.view_size());
 
-  drag_start_page_ = pagination_model_->selected_page();
+  drag_start_page_ = pagination_model_.selected_page();
   drag_start_grid_view_ = drag_point;
 
   drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
 
   // Set the flag in root level grid view.
   dragging_for_reparent_item_ = true;
 }
 
 void AppsGridView::UpdateDragFromReparentItem(Pointer pointer,
                                               const gfx::Point& drag_point) {
@@ skipping 176 matching lines @@
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 void AppsGridView::UpdatePaging() {
   int total_page = view_model_.view_size() && tiles_per_page()
                        ? (view_model_.view_size() - 1) / tiles_per_page() + 1
                        : 0;
 
-  pagination_model_->SetTotalPages(total_page);
+  pagination_model_.SetTotalPages(total_page);
 }
 
 void AppsGridView::UpdatePulsingBlockViews() {
   const int existing_items = item_list_ ? item_list_->item_count() : 0;
   const int available_slots =
       tiles_per_page() - existing_items % tiles_per_page();
   const int desired = model_->status() == AppListModel::STATUS_SYNCING ?
       available_slots : 0;
 
   if (pulsing_blocks_model_.view_size() == desired)
@@ skipping 48 matching lines @@
     selected_view_->SchedulePaint();
 
   EnsureViewVisible(new_selection);
   selected_view_ = new_selection;
   selected_view_->SchedulePaint();
   selected_view_->NotifyAccessibilityEvent(
       ui::AX_EVENT_FOCUS, true);
 }
 
 bool AppsGridView::IsValidIndex(const Index& index) const {
-  return index.page >= 0 && index.page < pagination_model_->total_pages() &&
+  return index.page >= 0 && index.page < pagination_model_.total_pages() &&
          index.slot >= 0 && index.slot < tiles_per_page() &&
          GetModelIndexFromIndex(index) < view_model_.view_size();
 }
 
 AppsGridView::Index AppsGridView::GetIndexOfView(
     const views::View* view) const {
   const int model_index = view_model_.GetIndexOfView(view);
   if (model_index == -1)
     return Index();
 
   return GetIndexFromModelIndex(model_index);
 }
 
 views::View* AppsGridView::GetViewAtIndex(const Index& index) const {
   if (!IsValidIndex(index))
     return NULL;
 
   const int model_index = GetModelIndexFromIndex(index);
   return view_model_.view_at(model_index);
 }
 
 void AppsGridView::MoveSelected(int page_delta,
                                 int slot_x_delta,
                                 int slot_y_delta) {
   if (!selected_view_)
-    return SetSelectedItemByIndex(Index(pagination_model_->selected_page(), 0));
+    return SetSelectedItemByIndex(Index(pagination_model_.selected_page(), 0));
 
   const Index& selected = GetIndexOfView(selected_view_);
   int target_slot = selected.slot + slot_x_delta + slot_y_delta * cols_;
 
   if (selected.slot % cols_ == 0 && slot_x_delta == -1) {
     if (selected.page > 0) {
       page_delta = -1;
       target_slot = selected.slot + cols_ - 1;
     } else {
       target_slot = selected.slot;
     }
   }
 
   if (selected.slot % cols_ == cols_ - 1 && slot_x_delta == 1) {
-    if (selected.page < pagination_model_->total_pages() - 1) {
+    if (selected.page < pagination_model_.total_pages() - 1) {
       page_delta = 1;
       target_slot = selected.slot - cols_ + 1;
     } else {
       target_slot = selected.slot;
     }
   }
 
   // Clamp the target slot to the last item if we are moving to the last page
   // but our target slot is past the end of the item list.
   if (page_delta &&
-      selected.page + page_delta == pagination_model_->total_pages() - 1) {
+      selected.page + page_delta == pagination_model_.total_pages() - 1) {
     int last_item_slot = (view_model_.view_size() - 1) % tiles_per_page();
     if (last_item_slot < target_slot) {
       target_slot = last_item_slot;
     }
   }
 
-  int target_page = std::min(pagination_model_->total_pages() - 1,
+  int target_page = std::min(pagination_model_.total_pages() - 1,
                              std::max(selected.page + page_delta, 0));
   SetSelectedItemByIndex(Index(target_page, target_slot));
 }
 
 void AppsGridView::CalculateIdealBounds() {
   gfx::Rect rect(GetContentsBounds());
   if (rect.IsEmpty())
     return;
 
   gfx::Size tile_size(kPreferredTileWidth, kPreferredTileHeight);
 
   gfx::Rect grid_rect(gfx::Size(tile_size.width() * cols_,
                                 tile_size.height() * rows_per_page_));
   grid_rect.Intersect(rect);
 
   // Page width including padding pixels. A tile.x + page_width means the same
   // tile slot in the next page.
   const int page_width = grid_rect.width() + kPagePadding;
 
   // If there is a transition, calculates offset for current and target page.
-  const int current_page = pagination_model_->selected_page();
+  const int current_page = pagination_model_.selected_page();
   const PaginationModel::Transition& transition =
-      pagination_model_->transition();
-  const bool is_valid =
-      pagination_model_->is_valid_page(transition.target_page);
+      pagination_model_.transition();
+  const bool is_valid = pagination_model_.is_valid_page(transition.target_page);
 
   // Transition to right means negative offset.
   const int dir = transition.target_page > current_page ? -1 : 1;
   const int transition_offset = is_valid ?
       transition.progress * page_width * dir : 0;
 
   const int total_views =
       view_model_.view_size() + pulsing_blocks_model_.view_size();
   int slot_index = 0;
   for (int i = 0; i < total_views; ++i) {
@@ skipping 150 matching lines @@
 #endif
 }
 
 void AppsGridView::CalculateDropTarget(const gfx::Point& drag_point,
                                        bool use_page_button_hovering) {
   if (EnableFolderDragDropUI()) {
     CalculateDropTargetWithFolderEnabled(drag_point, use_page_button_hovering);
     return;
   }
 
-  int current_page = pagination_model_->selected_page();
+  int current_page = pagination_model_.selected_page();
   gfx::Point point(drag_point);
   if (!IsPointWithinDragBuffer(drag_point)) {
     point = drag_start_grid_view_;
     current_page = drag_start_page_;
   }
 
   if (use_page_button_hovering &&
       page_switcher_view_->bounds().Contains(point)) {
     gfx::Point page_switcher_point(point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     int page = page_switcher_view_->GetPageForPoint(page_switcher_point);
-    if (pagination_model_->is_valid_page(page)) {
+    if (pagination_model_.is_valid_page(page)) {
       drop_target_.page = page;
       drop_target_.slot = tiles_per_page() - 1;
     }
   } else {
     gfx::Rect bounds(GetContentsBounds());
     const int drop_row = (point.y() - bounds.y()) / kPreferredTileHeight;
     const int drop_col = std::min(cols_ - 1,
         (point.x() - bounds.x()) / kPreferredTileWidth);
 
     drop_target_.page = current_page;
     drop_target_.slot = std::max(0, std::min(
         tiles_per_page() - 1,
         drop_row * cols_ + drop_col));
   }
 
   // Limits to the last possible slot on last page.
-  if (drop_target_.page == pagination_model_->total_pages() - 1) {
+  if (drop_target_.page == pagination_model_.total_pages() - 1) {
     drop_target_.slot = std::min(
         (view_model_.view_size() - 1) % tiles_per_page(),
         drop_target_.slot);
   }
 }
 
 
 void AppsGridView::CalculateDropTargetWithFolderEnabled(
     const gfx::Point& drag_point,
     bool use_page_button_hovering) {
   gfx::Point point(drag_point);
   if (!IsPointWithinDragBuffer(drag_point)) {
     point = drag_start_grid_view_;
   }
 
   if (use_page_button_hovering &&
       page_switcher_view_->bounds().Contains(point)) {
     gfx::Point page_switcher_point(point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     int page = page_switcher_view_->GetPageForPoint(page_switcher_point);
-    if (pagination_model_->is_valid_page(page))
+    if (pagination_model_.is_valid_page(page))
       drop_attempt_ = DROP_FOR_NONE;
   } else {
     DCHECK(drag_view_);
     // Try to find the nearest target for folder dropping or re-ordering.
     drop_target_ = GetNearestTileForDragView();
   }
 }
 
 void AppsGridView::OnReorderTimer() {
   if (drop_attempt_ == DROP_FOR_REORDER)
@@ skipping 224 matching lines @@
   if (page_switcher_view_->bounds().Contains(drag_point)) {
     gfx::Point page_switcher_point(drag_point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     new_page_flip_target =
         page_switcher_view_->GetPageForPoint(page_switcher_point);
   }
 
   // TODO(xiyuan): Fix this for RTL.
   if (new_page_flip_target == -1 && drag_point.x() < kPageFlipZoneSize)
-    new_page_flip_target = pagination_model_->selected_page() - 1;
+    new_page_flip_target = pagination_model_.selected_page() - 1;
 
   if (new_page_flip_target == -1 &&
       drag_point.x() > width() - kPageFlipZoneSize) {
-    new_page_flip_target = pagination_model_->selected_page() + 1;
+    new_page_flip_target = pagination_model_.selected_page() + 1;
   }
 
   if (new_page_flip_target == page_flip_target_)
     return;
 
   StopPageFlipTimer();
-  if (pagination_model_->is_valid_page(new_page_flip_target)) {
+  if (pagination_model_.is_valid_page(new_page_flip_target)) {
     page_flip_target_ = new_page_flip_target;
 
-    if (page_flip_target_ != pagination_model_->selected_page()) {
+    if (page_flip_target_ != pagination_model_.selected_page()) {
       page_flip_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(page_flip_delay_in_ms_),
           this, &AppsGridView::OnPageFlipTimer);
     }
   }
 }
 
 void AppsGridView::OnPageFlipTimer() {
-  DCHECK(pagination_model_->is_valid_page(page_flip_target_));
-  pagination_model_->SelectPage(page_flip_target_, true);
+  DCHECK(pagination_model_.is_valid_page(page_flip_target_));
+  pagination_model_.SelectPage(page_flip_target_, true);
 }
 
 void AppsGridView::MoveItemInModel(views::View* item_view,
                                    const Index& target) {
   int current_model_index = view_model_.GetIndexOfView(item_view);
   DCHECK_GE(current_model_index, 0);
 
   int target_model_index = GetModelIndexFromIndex(target);
   if (target_model_index == current_model_index)
     return;
 
   item_list_->RemoveObserver(this);
   item_list_->MoveItem(current_model_index, target_model_index);
   view_model_.Move(current_model_index, target_model_index);
   item_list_->AddObserver(this);
 
-  if (pagination_model_->selected_page() != target.page)
-    pagination_model_->SelectPage(target.page, false);
+  if (pagination_model_.selected_page() != target.page)
+    pagination_model_.SelectPage(target.page, false);
 }
 
 void AppsGridView::MoveItemToFolder(views::View* item_view,
                                     const Index& target) {
   const std::string& source_item_id =
       static_cast<AppListItemView*>(item_view)->item()->id();
   AppListItemView* target_view =
       static_cast<AppListItemView*>(GetViewAtSlotOnCurrentPage(target.slot));
   const std::string&  target_view_item_id = target_view->item()->id();
 
@@ skipping 187 matching lines @@
   TopIconAnimationView* icon_view = new TopIconAnimationView(
       drag_item_view->item()->icon(),
       target_icon_rect,
       false);    /* animate like closing folder */
   AddChildView(icon_view);
   icon_view->SetBoundsRect(drag_view_icon_to_grid);
   icon_view->TransformView();
 }
 
 void AppsGridView::CancelContextMenusOnCurrentPage() {
-  int start = pagination_model_->selected_page() * tiles_per_page();
+  int start = pagination_model_.selected_page() * tiles_per_page();
   int end = std::min(view_model_.view_size(), start + tiles_per_page());
   for (int i = start; i < end; ++i) {
     AppListItemView* view =
         static_cast<AppListItemView*>(view_model_.view_at(i));
     view->CancelContextMenu();
   }
 }
 
 void AppsGridView::DeleteItemViewAtIndex(int index) {
   views::View* item_view = view_model_.view_at(index);
@@ skipping 86 matching lines @@
 }
 
 void AppsGridView::TransitionStarted() {
   CancelContextMenusOnCurrentPage();
 }
 
 void AppsGridView::TransitionChanged() {
   // Update layout for valid page transition only since over-scroll no longer
   // animates app icons.
   const PaginationModel::Transition& transition =
-      pagination_model_->transition();
-  if (pagination_model_->is_valid_page(transition.target_page))
+      pagination_model_.transition();
+  if (pagination_model_.is_valid_page(transition.target_page))
     Layout();
 }
 
 void AppsGridView::OnAppListModelStatusChanged() {
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 void AppsGridView::SetViewHidden(views::View* view, bool hide, bool immediate) {
@@ skipping 140 matching lines @@
     return gfx::Rect();
 
   // Calculate which tile |point| is enclosed in.
   int x = point.x();
   int y = point.y();
   int col = (x - bounds.x()) / kPreferredTileWidth;
   int row = (y - bounds.y()) / kPreferredTileHeight;
   gfx::Rect tile_rect = GetTileBounds(row, col);
 
   // Check if |point| is outside a valid item's tile.
-  Index index(pagination_model_->selected_page(), row * cols_ + col);
+  Index index(pagination_model_.selected_page(), row * cols_ + col);
   *tile_index = index;
   return tile_rect;
 }
 
 gfx::Rect AppsGridView::GetTileBounds(int row, int col) const {
   gfx::Rect bounds(GetContentsBounds());
   gfx::Size tile_size(kPreferredTileWidth, kPreferredTileHeight);
   gfx::Rect grid_rect(gfx::Size(tile_size.width() * cols_,
                                 tile_size.height() * rows_per_page_));
   grid_rect.Intersect(bounds);
   gfx::Rect tile_rect(
       gfx::Point(grid_rect.x() + col * tile_size.width(),
                  grid_rect.y() + row * tile_size.height()),
       tile_size);
   return tile_rect;
 }
 
 bool AppsGridView::IsLastPossibleDropTarget(const Index& index) const {
   int last_possible_slot = view_model_.view_size() % tiles_per_page();
-  return (index.page == pagination_model_->total_pages() - 1 &&
+  return (index.page == pagination_model_.total_pages() - 1 &&
           index.slot == last_possible_slot + 1);
 }
 
 views::View* AppsGridView::GetViewAtSlotOnCurrentPage(int slot) {
   if (slot < 0)
     return NULL;
 
   // Calculate the original bound of the tile at |index|.
   int row = slot / cols_;
   int col = slot % cols_;
@@ skipping 10 matching lines @@
 void AppsGridView::SetAsFolderDroppingTarget(const Index& target_index,
                                              bool is_target_folder) {
   AppListItemView* target_view =
       static_cast<AppListItemView*>(
           GetViewAtSlotOnCurrentPage(target_index.slot));
   if (target_view)
     target_view->SetAsAttemptedFolderTarget(is_target_folder);
 }
 
 }  // namespace app_list