Make apps grid view scroll vertically in 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 1115 matching lines @@
   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.
+  // Page size including padding pixels. A tile.x + page_width means the same
+  // tile slot in the next page; similarly for tile.y + page_height.
   const int page_width = grid_rect.width() + kPagePadding;
+  const int page_height = grid_rect.height() + kPagePadding;

[calamity, 2014/09/01 00:58:12]

You can move these down closer to where they're used.

[Matt Giuca, 2014/09/01 01:28:29]

Nah, this shouldn't be moved inside the for loop since it's the same for all
iterations. I could move it down closer to the start of the for loop, but
there's no reason to have these come after any of the other variables being
pre-computed before the loop.

 
   // If there is a transition, calculates offset for current and target 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);
 
-  // Transition to right means negative offset.
+  // Transition to previous page 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) {
     if (i < view_model_.view_size() && view_model_.view_at(i) == drag_view_) {
       if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER)
         ++slot_index;
       continue;
     }
 
     Index view_index = GetIndexFromModelIndex(slot_index);
 
     if (drop_target_ == view_index) {
       if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER) {
         view_index = GetIndexFromModelIndex(slot_index);
       } else if (!EnableFolderDragDropUI() ||
                  drop_attempt_ == DROP_FOR_REORDER) {
         ++slot_index;
         view_index = GetIndexFromModelIndex(slot_index);
       }
     }
 
-    // Decides an x_offset for current item.
+    // Decide the x or y offset for current item.
     int x_offset = 0;
-    if (view_index.page < current_page)
-      x_offset = -page_width;
-    else if (view_index.page > current_page)
-      x_offset = page_width;
+    int y_offset = 0;
 
-    if (is_valid) {
-      if (view_index.page == current_page ||
-          view_index.page == transition.target_page) {
-        x_offset += transition_offset;
+    if (app_list::switches::IsExperimentalAppListEnabled()) {
+      // The experimental app list transitions vertically.
+      if (view_index.page < current_page)
+        y_offset = -page_height;
+      else if (view_index.page > current_page)
+        y_offset = page_height;
+
+      if (is_valid) {
+        if (view_index.page == current_page ||
+            view_index.page == transition.target_page) {
+          y_offset += transition.progress * page_height * dir;
+        }
+      }
+    } else {
+      // The normal app list transitions horizontally.
+      if (view_index.page < current_page)
+        x_offset = -page_width;
+      else if (view_index.page > current_page)
+        x_offset = page_width;
+
+      if (is_valid) {
+        if (view_index.page == current_page ||
+            view_index.page == transition.target_page) {
+          x_offset += transition.progress * page_width * dir;
+        }
       }
     }
 
     const int row = view_index.slot / cols_;
     const int col = view_index.slot % cols_;
     gfx::Rect tile_slot(
         gfx::Point(grid_rect.x() + col * tile_size.width() + x_offset,
-                   grid_rect.y() + row * tile_size.height()),
+                   grid_rect.y() + row * tile_size.height() + y_offset),
         tile_size);
     if (i < view_model_.view_size()) {
       view_model_.set_ideal_bounds(i, tile_slot);
     } else {
       pulsing_blocks_model_.set_ideal_bounds(i - view_model_.view_size(),
                                              tile_slot);
     }
 
     ++slot_index;
   }
@@ skipping 969 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