Remove the apps grid page switcher from the experimental app list.

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 44 matching lines @@
 
 // Distance a drag needs to be from the app grid to be considered 'outside', at
 // which point we rearrange the apps to their pre-drag configuration, as a drop
 // then would be canceled. We have a buffer to make it easier to drag apps to
 // other pages.
 const int kDragBufferPx = 20;
 
 // Padding space in pixels for fixed layout.
 const int kLeftRightPadding = 20;
 const int kTopPadding = 1;
+const int kBottomPadding = 24;
 
 // Padding space in pixels between pages.
 const int kPagePadding = 40;
 
 // Preferred tile size when showing in fixed layout.
 const int kPreferredTileWidth = 88;
 const int kPreferredTileHeight = 98;
 
 // Width in pixels of the area on the sides that triggers a page flip.
 const int kPageFlipZoneSize = 40;
@@ skipping 290 matching lines @@
                                            kOverscrollPageTransitionDurationMs);
 
   pagination_model_.AddObserver(this);
   // The experimental app list transitions vertically.
   PaginationController::ScrollAxis scroll_axis =
       app_list::switches::IsExperimentalAppListEnabled()
           ? PaginationController::SCROLL_AXIS_VERTICAL
           : PaginationController::SCROLL_AXIS_HORIZONTAL;
   pagination_controller_.reset(
       new PaginationController(&pagination_model_, scroll_axis));
-  page_switcher_view_ = new PageSwitcher(&pagination_model_);
-  AddChildView(page_switcher_view_);
+  if (!switches::IsExperimentalAppListEnabled()) {
+    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);
 
@@ skipping 228 matching lines @@
   last_drag_point_ = point;
   const Index last_drop_target = drop_target_;
   DropAttempt last_drop_attempt = drop_attempt_;
   CalculateDropTarget(last_drag_point_, false);
 
   if (IsPointWithinDragBuffer(last_drag_point_))
     MaybeStartPageFlipTimer(last_drag_point_);
   else
     StopPageFlipTimer();
 
-  gfx::Point page_switcher_point(last_drag_point_);
-  views::View::ConvertPointToTarget(this, page_switcher_view_,
-                                    &page_switcher_point);
-  page_switcher_view_->UpdateUIForDragPoint(page_switcher_point);
+  if (page_switcher_view_) {
+    gfx::Point page_switcher_point(last_drag_point_);
+    views::View::ConvertPointToTarget(
+        this, page_switcher_view_, &page_switcher_point);
+    page_switcher_view_->UpdateUIForDragPoint(page_switcher_point);
+  }
 
   if (!EnableFolderDragDropUI()) {
     if (last_drop_target != drop_target_)
       AnimateToIdealBounds();
     drag_view_->SetPosition(drag_view_start_ + drag_vector);
     return;
   }
 
   // Update drag with folder UI enabled.
   if (last_drop_target != drop_target_ ||
@@ skipping 229 matching lines @@
 }
 
 bool AppsGridView::IsAnimatingView(views::View* view) {
   return bounds_animator_.IsAnimating(view);
 }
 
 gfx::Size AppsGridView::GetPreferredSize() const {
   const gfx::Insets insets(GetInsets());
   const gfx::Size tile_size = gfx::Size(kPreferredTileWidth,
                                         kPreferredTileHeight);
-  const int page_switcher_height =
-      page_switcher_view_->GetPreferredSize().height();
+  int page_switcher_height = kBottomPadding;
+  if (page_switcher_view_)
+    page_switcher_height = page_switcher_view_->GetPreferredSize().height();
   return gfx::Size(
       tile_size.width() * cols_ + insets.width(),
       tile_size.height() * rows_per_page_ +
           page_switcher_height + insets.height());
 }
 
 bool AppsGridView::GetDropFormats(
     int* formats,
     std::set<OSExchangeData::CustomFormat>* custom_formats) {
   // TODO(koz): Only accept a specific drag type for app shortcuts.
@@ skipping 14 matching lines @@
     bounds_animator_.Cancel();
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
     views::View* view = view_model_.view_at(i);
     if (view != drag_view_)
       view->SetBoundsRect(view_model_.ideal_bounds(i));
   }
   views::ViewModelUtils::SetViewBoundsToIdealBounds(pulsing_blocks_model_);
 
-  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);
+  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);
 
   if (!handled) {
     const int forward_dir = base::i18n::IsRTL() ? -1 : 1;
     switch (event.key_code()) {
@@ skipping 427 matching lines @@
     return;
   }
 
   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 &&
+  if (use_page_button_hovering && page_switcher_view_ &&
       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)) {
       drop_target_.page = page;
       drop_target_.slot = tiles_per_page() - 1;
     }
   } else {
@@ skipping 18 matching lines @@
 
 
 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 &&
+  if (use_page_button_hovering && page_switcher_view_ &&
       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))
       drop_attempt_ = DROP_FOR_NONE;
   } else {
     DCHECK(drag_view_);
     // Try to find the nearest target for folder dropping or re-ordering.
@@ skipping 220 matching lines @@
       }
     }
   }
 }
 
 void AppsGridView::MaybeStartPageFlipTimer(const gfx::Point& drag_point) {
   if (!IsPointWithinDragBuffer(drag_point))
     StopPageFlipTimer();
   int new_page_flip_target = -1;
 
-  if (page_switcher_view_->bounds().Contains(drag_point)) {
+  if (page_switcher_view_ &&
+      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;
@@ skipping 560 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