Revert 230227 "Implement app list folder management page UI, inc..."

trunk/src/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 "content/public/browser/web_contents.h"
 #include "ui/app_list/app_list_item_model.h"
@@ skipping 219 matching lines @@
   bool canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(SynchronousDrag);
 };
 #endif  // defined(OS_WIN) && !defined(USE_AURA)
 
 AppsGridView::AppsGridView(AppsGridViewDelegate* delegate,
                            PaginationModel* pagination_model,
                            content::WebContents* start_page_contents)
     : model_(NULL),
-      apps_(NULL),
       delegate_(delegate),
       pagination_model_(pagination_model),
       page_switcher_view_(new PageSwitcher(pagination_model)),
       start_page_view_(NULL),
       cols_(0),
       rows_per_page_(0),
       selected_view_(NULL),
       drag_view_(NULL),
       drag_start_page_(-1),
       drag_pointer_(NONE),
@@ skipping 15 matching lines @@
 }
 
 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_)
+  if (model_) {
     model_->RemoveObserver(this);
+    model_->apps()->RemoveObserver(this);
+  }
   pagination_model_->RemoveObserver(this);
-
-  if (apps_)
-    apps_->RemoveObserver(this);
 }
 
 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;
 
   set_border(views::Border::CreateEmptyBorder(kTopPadding,
                                               kLeftRightPadding,
                                               0,
                                               kLeftRightPadding));
 }
 
 void AppsGridView::SetModel(AppListModel* model) {
-  if (model_)
+  if (model_) {
     model_->RemoveObserver(this);
+    model_->apps()->RemoveObserver(this);
+  }
 
   model_ = model;
-  if (model_)
+  if (model_) {
     model_->AddObserver(this);
-
-  Update();
-}
-
-void AppsGridView::SetApps(AppListModel::Apps* apps) {
-  if (apps_)
-    apps_->RemoveObserver(this);
-
-  apps_ = apps;
-  apps_->AddObserver(this);
+    model_->apps()->AddObserver(this);
+  }
   Update();
 }
 
 void AppsGridView::SetSelectedView(views::View* view) {
   if (IsSelectedView(view) || IsDraggedView(view))
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     SetSelectedItemByIndex(index);
@@ skipping 304 matching lines @@
     if (selected_view_ == details.child)
       selected_view_ = NULL;
 
     if (drag_view_ == details.child)
       EndDrag(true);
 
     bounds_animator_.StopAnimatingView(details.child);
   }
 }
 
+// static
+AppsGridView* AppsGridView::GetLastGridViewForTest() {
+  return last_created_grid_view_for_test;
+}
+
 void AppsGridView::Update() {
   DCHECK(!selected_view_ && !drag_view_);
-  if (!apps_)
-    return;
 
   view_model_.Clear();
-  if (apps_ && apps_->item_count())
-    ListItemsAdded(0, apps_->item_count());
+  if (model_ && model_->apps()->item_count())
+    ListItemsAdded(0, model_->apps()->item_count());
 }
 
 void AppsGridView::UpdatePaging() {
   int total_page = start_page_view_ ? 1 : 0;
   if (view_model_.view_size() && tiles_per_page())
     total_page += (view_model_.view_size() - 1) / tiles_per_page() + 1;
 
   pagination_model_->SetTotalPages(total_page);
 }
 
 void AppsGridView::UpdatePulsingBlockViews() {
   const int available_slots =
-      tiles_per_page() - apps_->item_count() % tiles_per_page();
+      tiles_per_page() - model_->apps()->item_count() % 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);
     pulsing_blocks_model_.Remove(0);
     delete view;
   }
 
   while (pulsing_blocks_model_.view_size() < desired) {
     views::View* view = new PulsingBlockView(
         gfx::Size(kPreferredTileWidth, kPreferredTileHeight), true);
     pulsing_blocks_model_.Add(view, 0);
     AddChildView(view);
   }
 }
 
 views::View* AppsGridView::CreateViewForItemAtIndex(size_t index) {
-  DCHECK_LT(index, apps_->item_count());
+  DCHECK_LT(index, model_->apps()->item_count());
   AppListItemView* view = new AppListItemView(this,
-                                              apps_->GetItemAt(index));
+                                              model_->apps()->GetItemAt(index));
   view->SetIconSize(icon_size_);
 #if defined(USE_AURA)
   view->SetPaintToLayer(true);
   view->SetFillsBoundsOpaquely(false);
 #endif
   return view;
 }
 
 AppsGridView::Index AppsGridView::GetIndexFromModelIndex(
     int model_index) const {
@@ skipping 414 matching lines @@
 
 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;
 
-  apps_->RemoveObserver(this);
-  apps_->Move(current_model_index, target_model_index);
+  model_->apps()->RemoveObserver(this);
+  model_->apps()->Move(current_model_index, target_model_index);
   view_model_.Move(current_model_index, target_model_index);
-  apps_->AddObserver(this);
+  model_->apps()->AddObserver(this);
 
   if (pagination_model_->selected_page() != target.page)
     pagination_model_->SelectPage(target.page, false);
 }
 
 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 =
@@ skipping 124 matching lines @@
 #if defined(USE_AURA)
   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);
 #endif
 }
 
 }  // namespace app_list