AppsGridView: Use specific types instead of views::View*.

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>
 
@@ skipping 447 matching lines @@
 
 void AppsGridView::SetItemList(AppListItemList* item_list) {
   if (item_list_)
     item_list_->RemoveObserver(this);
   item_list_ = item_list;
   if (item_list_)
     item_list_->AddObserver(this);
   Update();
 }
 
-void AppsGridView::SetSelectedView(views::View* view) {
+void AppsGridView::SetSelectedView(AppListItemView* view) {
   if (IsSelectedView(view) || IsDraggedView(view))
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     SetSelectedItemByIndex(index);
 }
 
-void AppsGridView::ClearSelectedView(views::View* view) {
+void AppsGridView::ClearSelectedView(AppListItemView* view) {
   if (view && IsSelectedView(view)) {
     selected_view_->SchedulePaint();
     selected_view_ = NULL;
   }
 }
 
 void AppsGridView::ClearAnySelectedView() {
   if (selected_view_) {
     selected_view_->SchedulePaint();
     selected_view_ = NULL;
   }
 }
 
-bool AppsGridView::IsSelectedView(const views::View* view) const {
+bool AppsGridView::IsSelectedView(const AppListItemView* view) const {
   return selected_view_ == view;
 }
 
-void AppsGridView::EnsureViewVisible(const views::View* view) {
+void AppsGridView::EnsureViewVisible(const AppListItemView* view) {
   if (pagination_model_.has_transition())
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     pagination_model_.SelectPage(index.page, false);
 }
 
 void AppsGridView::InitiateDrag(AppListItemView* view,
                                 Pointer pointer,
@@ skipping 249 matching lines @@
   if (folder_delegate_ && !IsDraggingForReparentInHiddenGridView())
     folder_delegate_->UpdateFolderViewBackground(false);
 }
 
 void AppsGridView::StopPageFlipTimer() {
   page_flip_timer_.Stop();
   page_flip_target_ = -1;
 }
 
 AppListItemView* AppsGridView::GetItemViewAt(int index) const {
-  DCHECK(index >= 0 && index < view_model_.view_size());
   return static_cast<AppListItemView*>(view_model_.view_at(index));
 }
 
 void AppsGridView::SetTopItemViewsVisible(bool visible) {
   int top_item_count = std::min(static_cast<int>(kNumFolderTopItems),
                                 view_model_.view_size());
   for (int i = 0; i < top_item_count; ++i)
     GetItemViewAt(i)->icon()->SetVisible(visible);
 }
 
@@ skipping 59 matching lines @@
                                               const gfx::Point& drag_point) {
   // Note that if a cancel ocurrs while reparenting, the |drag_view_| in both
   // root and folder grid views is cleared, so the check in UpdateDragFromItem()
   // for |drag_view_| being NULL (in the folder grid) is sufficient.
   DCHECK(drag_view_);
   DCHECK(IsDraggingForReparentInRootLevelGridView());
 
   UpdateDrag(pointer, drag_point);
 }
 
-bool AppsGridView::IsDraggedView(const views::View* view) const {
+bool AppsGridView::IsDraggedView(const AppListItemView* view) const {
   return drag_view_ == view;
 }
 
 void AppsGridView::ClearDragState() {
   drop_attempt_ = DROP_FOR_NONE;
   drag_pointer_ = NONE;
   reorder_drop_target_ = Index();
   folder_drop_target_ = Index();
   reorder_placeholder_ = Index();
   drag_start_grid_view_ = gfx::Point();
@@ skipping 21 matching lines @@
     ApplicationDragAndDropHost* drag_and_drop_host) {
   drag_and_drop_host_ = drag_and_drop_host;
 }
 
 void AppsGridView::Prerender() {
   Layout();
   int selected_page = std::max(0, pagination_model_.selected_page());
   int start = std::max(0, (selected_page - kPrerenderPages) * tiles_per_page());
   int end = std::min(view_model_.view_size(),
                      (selected_page + 1 + kPrerenderPages) * tiles_per_page());
-  for (int i = start; i < end; i++) {
-    AppListItemView* v = static_cast<AppListItemView*>(view_model_.view_at(i));
-    v->Prerender();
-  }
+  for (int i = start; i < end; i++)
+    GetItemViewAt(i)->Prerender();
 }
 
-bool AppsGridView::IsAnimatingView(views::View* view) {
+bool AppsGridView::IsAnimatingView(AppListItemView* view) {
   return bounds_animator_.IsAnimating(view);
 }
 
 gfx::Size AppsGridView::GetPreferredSize() const {
   const gfx::Insets insets(GetInsets());
   int page_switcher_height = 0;
   if (page_switcher_view_)
     page_switcher_height = page_switcher_view_->GetPreferredSize().height();
   gfx::Size size = GetTileGridSize();
   size.Enlarge(insets.width(), insets.height() + page_switcher_height);
@@ skipping 15 matching lines @@
 int AppsGridView::OnDragUpdated(const ui::DropTargetEvent& event) {
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 void AppsGridView::Layout() {
   if (bounds_animator_.IsAnimating())
     bounds_animator_.Cancel();
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
-    views::View* view = view_model_.view_at(i);
+    AppListItemView* view = GetItemViewAt(i);
     if (view != drag_view_)
       view->SetBoundsRect(view_model_.ideal_bounds(i));
   }
   views::ViewModelUtils::SetViewBoundsToIdealBounds(pulsing_blocks_model_);
 
   if (page_switcher_view_) {
     const int page_switcher_height =
         page_switcher_view_->GetPreferredSize().height();
     gfx::Rect rect(GetContentsBounds());
     rect.set_y(rect.bottom() - page_switcher_height);
     rect.set_height(page_switcher_height);
     page_switcher_view_->SetBoundsRect(rect);
   }
 }
 
 bool AppsGridView::OnKeyPressed(const ui::KeyEvent& event) {
   bool handled = false;
   if (selected_view_)
-    handled = selected_view_->OnKeyPressed(event);
+    handled = static_cast<views::View*>(selected_view_)->OnKeyPressed(event);
 
   if (!handled) {
     const int forward_dir = base::i18n::IsRTL() ? -1 : 1;
     switch (event.key_code()) {
       case ui::VKEY_LEFT:
         MoveSelected(0, -forward_dir, 0);
         return true;
       case ui::VKEY_RIGHT:
         MoveSelected(0, forward_dir, 0);
         return true;
@@ skipping 65 matching lines @@
     event->StopPropagation();
   }
 }
 
 void AppsGridView::Update() {
   DCHECK(!selected_view_ && !drag_view_);
   view_model_.Clear();
   if (!item_list_ || !item_list_->item_count())
     return;
   for (size_t i = 0; i < item_list_->item_count(); ++i) {
-    views::View* view = CreateViewForItemAtIndex(i);
+    AppListItemView* view = CreateViewForItemAtIndex(i);
     view_model_.Add(view, i);
     AddChildView(view);
   }
   UpdatePaging();
   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);
 }
 
 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)
     return;
 
   while (pulsing_blocks_model_.view_size() > desired) {
-    views::View* view = pulsing_blocks_model_.view_at(0);
+    PulsingBlockView* view = GetPulsingBlockViewAt(0);
     pulsing_blocks_model_.Remove(0);
     delete view;
   }
 
   while (pulsing_blocks_model_.view_size() < desired) {
-    views::View* view = new PulsingBlockView(GetTotalTileSize(), true);
+    PulsingBlockView* view = new PulsingBlockView(GetTotalTileSize(), true);
     pulsing_blocks_model_.Add(view, 0);
     AddChildView(view);
   }
 }
 
-views::View* AppsGridView::CreateViewForItemAtIndex(size_t index) {
+PulsingBlockView* AppsGridView::GetPulsingBlockViewAt(int index) const {
+  return static_cast<PulsingBlockView*>(pulsing_blocks_model_.view_at(index));
+}
+
+AppListItemView* AppsGridView::CreateViewForItemAtIndex(size_t index) {
   // The drag_view_ might be pending for deletion, therefore view_model_
   // may have one more item than item_list_.
   DCHECK_LE(index, item_list_->item_count());
   AppListItemView* view = new AppListItemView(this,
                                               item_list_->item_at(index));
   view->SetPaintToLayer(true);
   view->SetFillsBoundsOpaquely(false);
   return view;
 }
 
 AppsGridView::Index AppsGridView::GetIndexFromModelIndex(
     int model_index) const {
   return Index(model_index / tiles_per_page(), model_index % tiles_per_page());
 }
 
 int AppsGridView::GetModelIndexFromIndex(const Index& index) const {
   return index.page * tiles_per_page() + index.slot;
 }
 
 void AppsGridView::SetSelectedItemByIndex(const Index& index) {
   if (GetIndexOfView(selected_view_) == index)
     return;
 
-  views::View* new_selection = GetViewAtIndex(index);
+  AppListItemView* new_selection = GetViewAtIndex(index);
   if (!new_selection)
     return;  // Keep current selection.
 
   if (selected_view_)
     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() &&
          index.slot >= 0 && index.slot < tiles_per_page() &&
          GetModelIndexFromIndex(index) < view_model_.view_size();
 }
 
 AppsGridView::Index AppsGridView::GetIndexOfView(
-    const views::View* view) const {
+    const AppListItemView* 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 {
+AppListItemView* AppsGridView::GetViewAtIndex(const Index& index) const {
   if (!IsValidIndex(index))
     return NULL;
 
   const int model_index = GetModelIndexFromIndex(index);
-  return view_model_.view_at(model_index);
+  return GetItemViewAt(model_index);
 }
 
 AppsGridView::Index AppsGridView::GetLastViewIndex() const {
   DCHECK_LT(0, view_model_.view_size());
   int view_index = view_model_.view_size() - 1;
   return Index(view_index / tiles_per_page(), view_index % tiles_per_page());
 }
 
 void AppsGridView::MoveSelected(int page_delta,
                                 int slot_x_delta,
@@ skipping 113 matching lines @@
 
     ++slot_index;
   }
 }
 
 void AppsGridView::AnimateToIdealBounds() {
   const gfx::Rect visible_bounds(GetVisibleBounds());
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
-    views::View* view = view_model_.view_at(i);
+    AppListItemView* view = GetItemViewAt(i);
     if (view == drag_view_)
       continue;
 
     const gfx::Rect& target = view_model_.ideal_bounds(i);
     if (bounds_animator_.GetTargetBounds(view) == target)
       continue;
 
     const gfx::Rect& current = view->bounds();
     const bool current_visible = visible_bounds.Intersects(current);
     const bool target_visible = visible_bounds.Intersects(target);
@@ skipping 11 matching lines @@
       bounds_animator_.SetAnimationDelegate(
           view,
           scoped_ptr<gfx::AnimationDelegate>(
               new ItemMoveAnimationDelegate(view)));
     } else {
       view->SetBoundsRect(target);
     }
   }
 }
 
-void AppsGridView::AnimationBetweenRows(views::View* view,
+void AppsGridView::AnimationBetweenRows(AppListItemView* view,
                                         bool animate_current,
                                         const gfx::Rect& current,
                                         bool animate_target,
                                         const gfx::Rect& target) {
   // Determine page of |current| and |target|. -1 means in the left invisible
   // page, 0 is the center visible page and 1 means in the right invisible page.
   const int current_page = current.x() < 0 ? -1 :
       current.x() >= width() ? 1 : 0;
   const int target_page = target.x() < 0 ? -1 :
       target.x() >= width() ? 1 : 0;
@@ skipping 396 matching lines @@
           this, &AppsGridView::OnPageFlipTimer);
     }
   }
 }
 
 void AppsGridView::OnPageFlipTimer() {
   DCHECK(pagination_model_.is_valid_page(page_flip_target_));
   pagination_model_.SelectPage(page_flip_target_, true);
 }
 
-void AppsGridView::MoveItemInModel(views::View* item_view,
+void AppsGridView::MoveItemInModel(AppListItemView* 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);
 }
 
-void AppsGridView::MoveItemToFolder(views::View* item_view,
+void AppsGridView::MoveItemToFolder(AppListItemView* item_view,
                                     const Index& target) {
-  const std::string& source_item_id =
-      static_cast<AppListItemView*>(item_view)->item()->id();
+  const std::string& source_item_id = item_view->item()->id();
   AppListItemView* target_view =
-      static_cast<AppListItemView*>(GetViewAtSlotOnCurrentPage(target.slot));
-  const std::string&  target_view_item_id = target_view->item()->id();
+      GetViewDisplayedAtSlotOnCurrentPage(target.slot);
+  const std::string& target_view_item_id = target_view->item()->id();
 
   // Make change to data model.
   item_list_->RemoveObserver(this);
   std::string folder_item_id =
       model_->MergeItems(target_view_item_id, source_item_id);
   item_list_->AddObserver(this);
   if (folder_item_id.empty()) {
     LOG(ERROR) << "Unable to merge into item id: " << target_view_item_id;
     return;
   }
   if (folder_item_id != target_view_item_id) {
     // New folder was created, change the view model to replace the old target
     // view with the new folder item view.
     size_t folder_item_index;
     if (item_list_->FindItemIndex(folder_item_id, &folder_item_index)) {
       int target_view_index = view_model_.GetIndexOfView(target_view);
       gfx::Rect target_view_bounds = target_view->bounds();
       DeleteItemViewAtIndex(target_view_index);
-      views::View* target_folder_view =
+      AppListItemView* target_folder_view =
           CreateViewForItemAtIndex(folder_item_index);
       target_folder_view->SetBoundsRect(target_view_bounds);
       view_model_.Add(target_folder_view, target_view_index);
       AddChildView(target_folder_view);
     } else {
       LOG(ERROR) << "Folder no longer in item_list: " << folder_item_id;
     }
   }
 
   // Fade out the drag_view_ and delete it when animation ends.
   int drag_view_index = view_model_.GetIndexOfView(drag_view_);
   view_model_.Remove(drag_view_index);
   bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
   bounds_animator_.SetAnimationDelegate(
       drag_view_,
       scoped_ptr<gfx::AnimationDelegate>(
           new ItemRemoveAnimationDelegate(drag_view_)));
   UpdatePaging();
 }
 
-void AppsGridView::ReparentItemForReorder(views::View* item_view,
+void AppsGridView::ReparentItemForReorder(AppListItemView* item_view,
                                           const Index& target) {
   item_list_->RemoveObserver(this);
   model_->RemoveObserver(this);
 
-  AppListItem* reparent_item = static_cast<AppListItemView*>(item_view)->item();
+  AppListItem* reparent_item = item_view->item();
   DCHECK(reparent_item->IsInFolder());
   const std::string source_folder_id = reparent_item->folder_id();
   AppListFolderItem* source_folder =
       static_cast<AppListFolderItem*>(item_list_->FindItem(source_folder_id));
 
   int target_model_index = GetModelIndexFromIndex(target);
 
   // Remove the source folder view if there is only 1 item in it, since the
   // source folder will be deleted after its only child item removed from it.
   if (source_folder->ChildItemCount() == 1u) {
@@ skipping 16 matching lines @@
   model_->MoveItemToFolderAt(reparent_item, "", target_position);
   view_model_.Move(current_model_index, target_model_index);
 
   RemoveLastItemFromReparentItemFolderIfNecessary(source_folder_id);
 
   item_list_->AddObserver(this);
   model_->AddObserver(this);
   UpdatePaging();
 }
 
-void AppsGridView::ReparentItemToAnotherFolder(views::View* item_view,
+void AppsGridView::ReparentItemToAnotherFolder(AppListItemView* item_view,
                                                const Index& target) {
   DCHECK(IsDraggingForReparentInRootLevelGridView());
 
   AppListItemView* target_view =
-      static_cast<AppListItemView*>(GetViewAtSlotOnCurrentPage(target.slot));
+      GetViewDisplayedAtSlotOnCurrentPage(target.slot);
   if (!target_view)
     return;
 
   // Make change to data model.
   item_list_->RemoveObserver(this);
 
-  AppListItem* reparent_item = static_cast<AppListItemView*>(item_view)->item();
+  AppListItem* reparent_item = item_view->item();
   DCHECK(reparent_item->IsInFolder());
   const std::string source_folder_id = reparent_item->folder_id();
   AppListFolderItem* source_folder =
       static_cast<AppListFolderItem*>(item_list_->FindItem(source_folder_id));
 
   // Remove the source folder view if there is only 1 item in it, since the
   // source folder will be deleted after its only child item merged into the
   // target item.
   if (source_folder->ChildItemCount() == 1u)
     DeleteItemViewAtIndex(
@@ skipping 11 matching lines @@
   }
 
   if (target_id_after_merge != target_item->id()) {
     // New folder was created, change the view model to replace the old target
     // view with the new folder item view.
     const std::string& new_folder_id = reparent_item->folder_id();
     size_t new_folder_index;
     if (item_list_->FindItemIndex(new_folder_id, &new_folder_index)) {
       int target_view_index = view_model_.GetIndexOfView(target_view);
       DeleteItemViewAtIndex(target_view_index);
-      views::View* new_folder_view =
+      AppListItemView* new_folder_view =
           CreateViewForItemAtIndex(new_folder_index);
       view_model_.Add(new_folder_view, target_view_index);
       AddChildView(new_folder_view);
     } else {
       LOG(ERROR) << "Folder no longer in item_list: " << new_folder_id;
     }
   }
 
   RemoveLastItemFromReparentItemFolderIfNecessary(source_folder_id);
 
@@ skipping 29 matching lines @@
   AppListItem* last_item = source_folder->item_list()->item_at(0);
   model_->MoveItemToFolderAt(last_item, "", source_folder->position());
 
   // Create a new item view for the last item in folder.
   size_t last_item_index;
   if (!item_list_->FindItemIndex(last_item->id(), &last_item_index) ||
       last_item_index > static_cast<size_t>(view_model_.view_size())) {
     NOTREACHED();
     return;
   }
-  views::View* last_item_view = CreateViewForItemAtIndex(last_item_index);
+  AppListItemView* last_item_view = CreateViewForItemAtIndex(last_item_index);
   view_model_.Add(last_item_view, last_item_index);
   AddChildView(last_item_view);
 }
 
 void AppsGridView::CancelFolderItemReparent(AppListItemView* drag_item_view) {
   // The icon of the dragged item must target to its final ideal bounds after
   // the animation completes.
   CalculateIdealBounds();
 
   gfx::Rect target_icon_rect =
       GetTargetIconRectInFolder(drag_item_view, activated_folder_item_view_);
 
   gfx::Rect drag_view_icon_to_grid =
       drag_item_view->ConvertRectToParent(drag_item_view->GetIconBounds());
   drag_view_icon_to_grid.ClampToCenteredSize(
       gfx::Size(kGridIconDimension, kGridIconDimension));
   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 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();
-  }
+  for (int i = start; i < end; ++i)
+    GetItemViewAt(i)->CancelContextMenu();
 }
 
 void AppsGridView::DeleteItemViewAtIndex(int index) {
-  views::View* item_view = view_model_.view_at(index);
+  AppListItemView* item_view = GetItemViewAt(index);
   view_model_.Remove(index);
   if (item_view == drag_view_)
     drag_view_ = NULL;
   delete item_view;
 }
 
 bool AppsGridView::IsPointWithinDragBuffer(const gfx::Point& point) const {
   gfx::Rect rect(GetLocalBounds());
   rect.Inset(-kDragBufferPx, -kDragBufferPx, -kDragBufferPx, -kDragBufferPx);
   return rect.Contains(point);
 }
 
 void AppsGridView::ButtonPressed(views::Button* sender,
                                  const ui::Event& event) {
   if (dragging())
     return;
 
   if (strcmp(sender->GetClassName(), AppListItemView::kViewClassName))
     return;
+  AppListItemView* pressed_item_view = static_cast<AppListItemView*>(sender);
 
   if (delegate_) {
     // Always set the previous activated_folder_item_view_ to be visible. This
     // prevents a case where the item would remain hidden due the
     // |activated_folder_item_view_| changing during the animation. We only
     // need to track |activated_folder_item_view_| in the root level grid view.
     if (!folder_delegate_) {
       if (activated_folder_item_view_)
         activated_folder_item_view_->SetVisible(true);
-      AppListItemView* pressed_item_view =
-          static_cast<AppListItemView*>(sender);
       if (IsFolderItem(pressed_item_view->item()))
         activated_folder_item_view_ = pressed_item_view;
       else
         activated_folder_item_view_ = NULL;
     }
-    delegate_->ActivateApp(static_cast<AppListItemView*>(sender)->item(),
-                           event.flags());
+    delegate_->ActivateApp(pressed_item_view->item(), event.flags());
   }
 }
 
 void AppsGridView::OnListItemAdded(size_t index, AppListItem* item) {
   EndDrag(true);
 
-  views::View* view = CreateViewForItemAtIndex(index);
+  AppListItemView* view = CreateViewForItemAtIndex(index);
   view_model_.Add(view, index);
   AddChildView(view);
 
   UpdatePaging();
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 void AppsGridView::OnListItemRemoved(size_t index, AppListItem* item) {
@@ skipping 43 matching lines @@
   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) {
+void AppsGridView::SetViewHidden(AppListItemView* view,
+                                 bool hide,
+                                 bool immediate) {
   ui::ScopedLayerAnimationSettings animator(view->layer()->GetAnimator());
   animator.SetPreemptionStrategy(
       immediate ? ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET :
                   ui::LayerAnimator::BLEND_WITH_CURRENT_ANIMATION);
   view->layer()->SetOpacity(hide ? 0 : 1);
 }
 
 void AppsGridView::OnImplicitAnimationsCompleted() {
   if (layer()->opacity() == 0.0f)
     SetVisible(false);
 }
 
 bool AppsGridView::EnableFolderDragDropUI() {
   // Enable drag and drop folder UI only if it is at the app list root level
   // and the switch is on.
   return model_->folders_enabled() && !folder_delegate_;
 }
 
 bool AppsGridView::CanDropIntoTarget(const Index& drop_target) const {
-  views::View* target_view = GetViewAtIndex(drop_target);
+  AppListItemView* target_view = GetViewAtIndex(drop_target);
   if (!target_view)
     return false;
 
-  AppListItem* target_item =
-      static_cast<AppListItemView*>(target_view)->item();
+  AppListItem* target_item = target_view->item();
   // Items can be dropped into non-folders (which have no children) or folders
   // that have fewer than the max allowed items.
   // OEM folder does not allow to drag/drop other items in it.
   return target_item->ChildItemCount() < kMaxFolderItems &&
          !IsOEMFolderItem(target_item);
 }
 
 AppsGridView::Index AppsGridView::GetNearestTileIndexForPoint(
     const gfx::Point& point) const {
   gfx::Rect bounds = GetContentsBounds();
@@ skipping 21 matching lines @@
 gfx::Rect AppsGridView::GetExpectedTileBounds(int row, int col) const {
   gfx::Rect bounds(GetContentsBounds());
   gfx::Size total_tile_size = GetTotalTileSize();
   gfx::Rect tile_bounds(gfx::Point(bounds.x() + col * total_tile_size.width(),
                                    bounds.y() + row * total_tile_size.height()),
                         total_tile_size);
   tile_bounds.ClampToCenteredSize(GetTileViewSize());
   return tile_bounds;
 }
 
-views::View* AppsGridView::GetViewAtSlotOnCurrentPage(int slot) {
+AppListItemView* AppsGridView::GetViewDisplayedAtSlotOnCurrentPage(int slot) {
   if (slot < 0)
     return NULL;
 
   // Calculate the original bound of the tile at |index|.
   int row = slot / cols_;
   int col = slot % cols_;
   gfx::Rect tile_rect = GetExpectedTileBounds(row, col);
 
   for (int i = 0; i < view_model_.view_size(); ++i) {
-    views::View* view = view_model_.view_at(i);
+    AppListItemView* view = GetItemViewAt(i);
     if (view->bounds() == tile_rect && view != drag_view_)
       return view;
   }
   return NULL;
 }
 
 void AppsGridView::SetAsFolderDroppingTarget(const Index& target_index,
                                              bool is_target_folder) {
   AppListItemView* target_view =
-      static_cast<AppListItemView*>(
-          GetViewAtSlotOnCurrentPage(target_index.slot));
+      GetViewDisplayedAtSlotOnCurrentPage(target_index.slot);
   if (target_view)
     target_view->SetAsAttemptedFolderTarget(is_target_folder);
 }
 
 }  // namespace app_list