Add deprecation warning banner to App Launcher on Mac.

ui/app_list/cocoa/apps_grid_controller.mm

 // Copyright 2013 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.
 
 #import "ui/app_list/cocoa/apps_grid_controller.h"
 
+#include "base/command_line.h"
 #include "base/mac/foundation_util.h"
 #include "base/macros.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/app_list_model_observer.h"
 #include "ui/app_list/app_list_view_delegate.h"
 #import "ui/app_list/cocoa/apps_collection_view_drag_manager.h"
 #import "ui/app_list/cocoa/apps_grid_view_item.h"
 #import "ui/app_list/cocoa/apps_pagination_model_observer.h"
 #include "ui/base/models/list_model_observer.h"
 
 namespace {
 
-// OSX app list has hardcoded rows and columns for now.
-const int kFixedRows = 4;
+// OSX app list has hardcoded columns for now.
 const int kFixedColumns = 4;
-const int kItemsPerPage = kFixedRows * kFixedColumns;
 
 // Padding space in pixels for fixed layout.
 const CGFloat kGridTopPadding = 1;
 const CGFloat kLeftRightPadding = 21;
 const CGFloat kScrollerPadding = 16;
 
 // Preferred tile size when showing in fixed layout. These should be even
 // numbers to ensure that if they are grown 50% they remain integers.
 const CGFloat kPreferredTileWidth = 88;
 const CGFloat kPreferredTileHeight = 98;
 
 const CGFloat kViewWidth =
     kFixedColumns * kPreferredTileWidth + 2 * kLeftRightPadding;
-const CGFloat kViewHeight = kFixedRows * kPreferredTileHeight;
 
 const NSTimeInterval kScrollWhileDraggingDelay = 1.0;
 NSTimeInterval g_scroll_duration = 0.18;
 
+const char kTestType[] = "test-type";
+
+int DetermineFixedRowCount() {
+  // This needs to be called before a delegate exists, since it is needed to
+  // determine the height of the view.
+  return [AppsGridController hasFewerRows] ? 3 : 4;
+}
+
+int RowCount() {
+  static const int row_count = DetermineFixedRowCount();
+  return row_count;
+}
+
+int ItemsPerPage() {
+  return RowCount() * kFixedColumns;
+}
+
+CGFloat ViewHeight() {
+  return RowCount() * kPreferredTileHeight;
+}
+
 }  // namespace
 
 @interface AppsGridController ()
 
 - (void)scrollToPageWithTimer:(size_t)targetPage;
 - (void)onTimer:(NSTimer*)theTimer;
 
 // Cancel a currently running scroll animation.
 - (void)cancelScrollAnimation;
 
@@ skipping 60 matching lines @@
     [parent_ listItemMovedFromIndex:from_index
                        toModelIndex:to_index];
   }
   void OnAppListItemHighlight(size_t index, bool highlight) override {
     // NSCollectionView (or -[AppsGridController scrollToPage]) ensures only one
     // item is highlighted, so clearing a highlight isn't necessary.
     if (!highlight)
       return;
 
     [parent_ selectItemAtIndex:index];
-    [parent_ scrollToPage:index / kItemsPerPage];
+    [parent_ scrollToPage:index / ItemsPerPage()];
   }
 
   AppsGridController* parent_;  // Weak, owns us.
 
   DISALLOW_COPY_AND_ASSIGN(AppsGridDelegateBridge);
 };
 
 }  // namespace app_list
 
 @interface PageContainerView : NSView;
@@ skipping 12 matching lines @@
 @implementation AppsGridController
 
 + (void)setScrollAnimationDuration:(NSTimeInterval)duration {
   g_scroll_duration = duration;
 }
 
 + (CGFloat)scrollerPadding {
   return kScrollerPadding;
 }
 
++ (BOOL)hasFewerRows {
+  return !base::CommandLine::ForCurrentProcess()->HasSwitch(kTestType);
+}
+
 @synthesize paginationObserver = paginationObserver_;
 
 - (id)init {
   if ((self = [super init])) {
     bridge_.reset(new app_list::AppsGridDelegateBridge(self));
     NSSize cellSize = NSMakeSize(kPreferredTileWidth, kPreferredTileHeight);
-    dragManager_.reset(
-        [[AppsCollectionViewDragManager alloc] initWithCellSize:cellSize
-                                                           rows:kFixedRows
-                                                        columns:kFixedColumns
-                                                 gridController:self]);
+    dragManager_.reset([[AppsCollectionViewDragManager alloc]
+        initWithCellSize:cellSize
+                    rows:RowCount()
+                 columns:kFixedColumns
+          gridController:self]);
     pages_.reset([[NSMutableArray alloc] init]);
     items_.reset([[NSMutableArray alloc] init]);
     [self loadAndSetView];
     [self updatePages:0];
   }
   return self;
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
@@ skipping 174 matching lines @@
   } else {
     [self scrollToPage:[self nearestPageIndex]];
   }
 }
 
 - (void)loadAndSetView {
   base::scoped_nsobject<PageContainerView> pagesContainer(
       [[PageContainerView alloc] initWithFrame:NSZeroRect]);
 
   NSRect scrollFrame = NSMakeRect(0, kGridTopPadding, kViewWidth,
-                                  kViewHeight + kScrollerPadding);
+                                  ViewHeight() + kScrollerPadding);
   base::scoped_nsobject<ScrollViewWithNoScrollbars> scrollView(
       [[ScrollViewWithNoScrollbars alloc] initWithFrame:scrollFrame]);
   [scrollView setBorderType:NSNoBorder];
   [scrollView setLineScroll:kViewWidth];
   [scrollView setPageScroll:kViewWidth];
   [scrollView setDelegate:self];
   [scrollView setDocumentView:pagesContainer];
   [scrollView setDrawsBackground:NO];
 
   [[NSNotificationCenter defaultCenter]
@@ skipping 25 matching lines @@
   }
 }
 
 - (AppsGridViewItem*)itemAtPageIndex:(size_t)pageIndex
                          indexInPage:(size_t)indexInPage {
   return base::mac::ObjCCastStrict<AppsGridViewItem>(
       [[self collectionViewAtPageIndex:pageIndex] itemAtIndex:indexInPage]);
 }
 
 - (AppsGridViewItem*)itemAtIndex:(size_t)itemIndex {
-  const size_t pageIndex = itemIndex / kItemsPerPage;
+  const size_t pageIndex = itemIndex / ItemsPerPage();
   return [self itemAtPageIndex:pageIndex
-                   indexInPage:itemIndex - pageIndex * kItemsPerPage];
+                   indexInPage:itemIndex - pageIndex * ItemsPerPage()];
 }
 
 - (NSUInteger)selectedItemIndex {
   NSCollectionView* page = [self collectionViewAtPageIndex:visiblePage_];
   NSUInteger indexOnPage = [[page selectionIndexes] firstIndex];
   if (indexOnPage == NSNotFound)
     return NSNotFound;
 
-  return indexOnPage + visiblePage_ * kItemsPerPage;
+  return indexOnPage + visiblePage_ * ItemsPerPage();
 }
 
 - (NSButton*)selectedButton {
   NSUInteger index = [self selectedItemIndex];
   if (index == NSNotFound)
     return nil;
 
   return [[self itemAtIndex:index] button];
 }
 
 - (NSScrollView*)gridScrollView {
   return base::mac::ObjCCastStrict<NSScrollView>([self view]);
 }
 
 - (NSView*)pagesContainerView {
   return [[self gridScrollView] documentView];
 }
 
 - (void)updatePages:(size_t)startItemIndex {
   // Note there is always at least one page.
   size_t targetPages = 1;
   if ([items_ count] != 0)
-    targetPages = ([items_ count] - 1) / kItemsPerPage + 1;
+    targetPages = ([items_ count] - 1) / ItemsPerPage() + 1;
 
   const size_t currentPages = [self pageCount];
   // First see if the number of pages have changed.
   if (targetPages != currentPages) {
     if (targetPages < currentPages) {
       // Pages need to be removed.
       [pages_ removeObjectsInRange:NSMakeRange(targetPages,
                                                currentPages - targetPages)];
     } else {
       // Pages need to be added.
       for (size_t i = currentPages; i < targetPages; ++i) {
-        NSRect pageFrame = NSMakeRect(
-            kLeftRightPadding + kViewWidth * i, 0,
-            kViewWidth, kViewHeight);
+        NSRect pageFrame = NSMakeRect(kLeftRightPadding + kViewWidth * i, 0,
+                                      kViewWidth, ViewHeight());
         [pages_ addObject:[dragManager_ makePageWithFrame:pageFrame]];
       }
     }
 
     [[self pagesContainerView] setSubviews:pages_];
-    NSSize pagesSize = NSMakeSize(kViewWidth * targetPages, kViewHeight);
+    NSSize pagesSize = NSMakeSize(kViewWidth * targetPages, ViewHeight());
     [[self pagesContainerView] setFrameSize:pagesSize];
     [paginationObserver_ totalPagesChanged];
   }
 
-  const size_t startPage = startItemIndex / kItemsPerPage;
+  const size_t startPage = startItemIndex / ItemsPerPage();
   // All pages on or after |startPage| may need items added or removed.
   for (size_t pageIndex = startPage; pageIndex < targetPages; ++pageIndex) {
     [self updatePageContent:pageIndex
                  resetModel:YES];
   }
 }
 
 - (void)updatePageContent:(size_t)pageIndex
                resetModel:(BOOL)resetModel {
   NSCollectionView* pageView = [self collectionViewAtPageIndex:pageIndex];
   if (resetModel) {
     // Clear the models first, otherwise removed items could be autoreleased at
     // an unknown point in the future, when the model owner may have gone away.
     for (size_t i = 0; i < [[pageView content] count]; ++i) {
       AppsGridViewItem* gridItem = base::mac::ObjCCastStrict<AppsGridViewItem>(
           [pageView itemAtIndex:i]);
       [gridItem setModel:NULL];
     }
   }
 
   NSRange inPageRange = NSIntersectionRange(
-      NSMakeRange(pageIndex * kItemsPerPage, kItemsPerPage),
+      NSMakeRange(pageIndex * ItemsPerPage(), ItemsPerPage()),
       NSMakeRange(0, [items_ count]));
   NSArray* pageContent = [items_ subarrayWithRange:inPageRange];
   [pageView setContent:pageContent];
   if (!resetModel)
     return;
 
   for (size_t i = 0; i < [pageContent count]; ++i) {
     AppsGridViewItem* gridItem = base::mac::ObjCCastStrict<AppsGridViewItem>(
         [pageView itemAtIndex:i]);
     [gridItem setModel:static_cast<app_list::AppListItem*>(
         [[pageContent objectAtIndex:i] pointerValue])];
   }
 }
 
 - (void)moveItemInView:(size_t)fromIndex
            toItemIndex:(size_t)toIndex {
   base::scoped_nsobject<NSValue> item(
       [[items_ objectAtIndex:fromIndex] retain]);
   [items_ removeObjectAtIndex:fromIndex];
   [items_ insertObject:item
                atIndex:toIndex];
 
-  size_t fromPageIndex = fromIndex / kItemsPerPage;
-  size_t toPageIndex = toIndex / kItemsPerPage;
+  size_t fromPageIndex = fromIndex / ItemsPerPage();
+  size_t toPageIndex = toIndex / ItemsPerPage();
   if (fromPageIndex == toPageIndex) {
     [self updatePageContent:fromPageIndex
                  resetModel:NO];  // Just reorder items.
     return;
   }
 
   if (fromPageIndex > toPageIndex)
     std::swap(fromPageIndex, toPageIndex);
 
   for (size_t i = fromPageIndex; i <= toPageIndex; ++i) {
@@ skipping 74 matching lines @@
 }
 
 - (BOOL)moveSelectionByDelta:(int)indexDelta {
   if (indexDelta == 0)
     return NO;
 
   NSUInteger oldIndex = [self selectedItemIndex];
 
   // If nothing is currently selected, select the first item on the page.
   if (oldIndex == NSNotFound) {
-    [self selectItemAtIndex:visiblePage_ * kItemsPerPage];
+    [self selectItemAtIndex:visiblePage_ * ItemsPerPage()];
     return YES;
   }
 
   // Can't select a negative index.
   if (indexDelta < 0 && static_cast<NSUInteger>(-indexDelta) > oldIndex)
     return NO;
 
   // Can't select an index greater or equal to the number of items.
   if (oldIndex + indexDelta >= [items_ count]) {
     if (visiblePage_ == [pages_ count] - 1)
       return NO;
 
     // If we're not on the last page, then select the last item.
     [self selectItemAtIndex:[items_ count] - 1];
     return YES;
   }
 
   [self selectItemAtIndex:oldIndex + indexDelta];
   return YES;
 }
 
 - (void)selectItemAtIndex:(NSUInteger)index {
   if (index >= [items_ count])
     return;
 
-  if (index / kItemsPerPage != visiblePage_)
-    [self scrollToPage:index / kItemsPerPage];
+  if (index / ItemsPerPage() != visiblePage_)
+    [self scrollToPage:index / ItemsPerPage()];
 
   [[self itemAtIndex:index] setSelected:YES];
 }
 
 - (BOOL)handleCommandBySelector:(SEL)command {
   if (command == @selector(insertNewline:) ||
       command == @selector(insertLineBreak:)) {
     [self activateSelection];
     return YES;
   }
 
   NSUInteger oldIndex = [self selectedItemIndex];
   // If nothing is currently selected, select the first item on the page.
   if (oldIndex == NSNotFound) {
-    [self selectItemAtIndex:visiblePage_ * kItemsPerPage];
+    [self selectItemAtIndex:visiblePage_ * ItemsPerPage()];
     return YES;
   }
 
   if (command == @selector(moveLeft:)) {
-    return oldIndex % kFixedColumns == 0 ?
-        [self moveSelectionByDelta:-kItemsPerPage + kFixedColumns - 1] :
-        [self moveSelectionByDelta:-1];
+    return oldIndex % kFixedColumns == 0
+               ? [self moveSelectionByDelta:-ItemsPerPage() + kFixedColumns - 1]
+               : [self moveSelectionByDelta:-1];
   }
 
   if (command == @selector(moveRight:)) {
-    return oldIndex % kFixedColumns == kFixedColumns - 1 ?
-        [self moveSelectionByDelta:+kItemsPerPage - kFixedColumns + 1] :
-        [self moveSelectionByDelta:1];
+    return oldIndex % kFixedColumns == kFixedColumns - 1
+               ? [self moveSelectionByDelta:+ItemsPerPage() - kFixedColumns + 1]
+               : [self moveSelectionByDelta:1];
   }
 
   if (command == @selector(moveUp:)) {
-    return oldIndex / kFixedColumns % kFixedRows == 0 ?
-        NO : [self moveSelectionByDelta:-kFixedColumns];
+    return oldIndex / kFixedColumns % RowCount() == 0
+               ? NO
+               : [self moveSelectionByDelta:-kFixedColumns];
   }
 
   if (command == @selector(moveDown:)) {
-    return oldIndex / kFixedColumns % kFixedRows == kFixedRows - 1 ?
-        NO : [self moveSelectionByDelta:kFixedColumns];
+    return oldIndex / kFixedColumns % RowCount() == RowCount() - 1
+               ? NO
+               : [self moveSelectionByDelta:kFixedColumns];
   }
 
   if (command == @selector(pageUp:) ||
       command == @selector(scrollPageUp:))
-    return [self moveSelectionByDelta:-kItemsPerPage];
+    return [self moveSelectionByDelta:-ItemsPerPage()];
 
   if (command == @selector(pageDown:) ||
       command == @selector(scrollPageDown:))
-    return [self moveSelectionByDelta:kItemsPerPage];
+    return [self moveSelectionByDelta:ItemsPerPage()];
 
   return NO;
 }
 
 @end