ChromeOS: The centered app list's top is now forced to be >= 10.

ash/wm/app_list_controller.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 "ash/wm/app_list_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
@@ skipping 26 matching lines @@
 const int kAnimationOffset = 8;
 
 // The maximum shift in pixels when over-scroll happens.
 const int kMaxOverScrollShift = 48;
 
 // The minimal anchor position offset to make sure that the bubble is still on
 // the screen with 8 pixels spacing on the left / right. This constant is a
 // result of minimal bubble arrow sizes and offsets.
 const int kMinimalAnchorPositionOffset = 57;
 
+// The minimal margin (in pixels) around the app list when in centered mode.
+const int kMinimalCenteredAppListMargin = 10;
+
 ui::Layer* GetLayer(views::Widget* widget) {
   return widget->GetNativeView()->layer();
 }
 
 // Gets arrow location based on shelf alignment.
 views::BubbleBorder::Arrow GetBubbleArrow(aura::Window* window) {
   DCHECK(Shell::HasInstance());
   return ShelfLayoutManager::ForShelf(window)->
       SelectValueForShelfAlignment(
           views::BubbleBorder::BOTTOM_CENTER,
@@ skipping 51 matching lines @@
     case SHELF_ALIGNMENT_RIGHT:
       return gfx::Vector2d(
           0, std::max(kMinimalAnchorPositionOffset - anchor.y(), 0));
     default:
       NOTREACHED();
       return gfx::Vector2d();
   }
 }
 
 // Gets the point at the center of the display that a particular view is on.
-// This calculation excludes the virtual keyboard area.
-gfx::Point GetCenterOfDisplayForView(const views::View* view) {
+// This calculation excludes the virtual keyboard area. If the height of the
+// display area is less than |minimum_height|, its bottom will be extended to
+// that height (so that the app list never starts above the top of the screen).
+gfx::Point GetCenterOfDisplayForView(const views::View* view,
+                                     int minimum_height) {
   gfx::Rect bounds = Shell::GetScreen()->GetDisplayNearestWindow(
       view->GetWidget()->GetNativeView()).bounds();
 
   // If the virtual keyboard is active, subtract it from the display bounds, so
   // that the app list is centered in the non-keyboard area of the display.
   // (Note that work_area excludes the keyboard, but it doesn't get updated
   // until after this function is called.)
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller && keyboard_controller->keyboard_visible())
     bounds.Subtract(keyboard_controller->current_keyboard_bounds());
 
+  // Apply the |minimum_height|.
+  if (bounds.height() < minimum_height)
+    bounds.set_height(minimum_height);
+
   return bounds.CenterPoint();
 }
 
+// Gets the minimum height of the rectangle to center the app list in.
+int GetMinimumBoundsHeightForAppList(const app_list::AppListView* app_list) {
+  return app_list->bounds().height() + 2 * kMinimalCenteredAppListMargin;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // AppListController, public:
 
 AppListController::AppListController()
     : pagination_model_(new app_list::PaginationModel),
       is_visible_(false),
       is_centered_(false),
       view_(NULL),
@@ skipping 37 matching lines @@
     // will be released with AppListView on close.
     app_list::AppListView* view = new app_list::AppListView(
         Shell::GetInstance()->delegate()->CreateAppListViewDelegate());
     aura::Window* root_window = window->GetRootWindow();
     aura::Window* container = GetRootWindowController(root_window)->
         GetContainer(kShellWindowId_AppListContainer);
     views::View* applist_button =
         Shelf::ForWindow(container)->GetAppListButtonView();
     is_centered_ = view->ShouldCenterWindow();
     if (is_centered_) {
+      // Note: We can't center the app list until we have its dimensions, so we
+      // init at (0, 0) and then reset its anchor point.
+      view->InitAsBubbleAtFixedLocation(
+          container,
+          pagination_model_.get(),
+          gfx::Point(),
+          views::BubbleBorder::FLOAT,
+          true /* border_accepts_events */);
       // The experimental app list is centered over the display of the app list
       // button that was pressed (if triggered via keyboard, this is the display
       // with the currently focused window).
-      view->InitAsBubbleAtFixedLocation(
-          container,
-          pagination_model_.get(),
-          GetCenterOfDisplayForView(applist_button),
-          views::BubbleBorder::FLOAT,
-          true /* border_accepts_events */);
+      view->SetAnchorPoint(GetCenterOfDisplayForView(
+          applist_button, GetMinimumBoundsHeightForAppList(view)));

[varkha, 2014/05/13 03:25:31]

Would it be clearer if s/applist_button/view?

[Matt Giuca, 2014/05/13 04:02:12]

Yes, but it *has* to be the button, or we regress http://crbug.com/368974. The
reason we use the button is because we want the app launcher to open on the same
display that the button that the user clicked is on.

If we use view here (which would nicely simplify the code), we would create the
view at (0, 0) and then move it to the center of the display with (0, 0) on it.

[varkha, 2014/05/13 04:40:11]

I see. I guess UpdateBounds never moves to another display so that's OK.

     } else {
       gfx::Rect applist_button_bounds = applist_button->GetBoundsInScreen();
       // We need the location of the button within the local screen.
       applist_button_bounds = ScreenUtil::ConvertRectFromScreen(
           root_window,
           applist_button_bounds);
       view->InitAsBubbleAttachedToAnchor(
           container,
           pagination_model_.get(),
           Shelf::ForWindow(container)->GetAppListButtonView(),
@@ skipping 122 matching lines @@
     SetVisible(false, window);
 }
 
 void AppListController::UpdateBounds() {
   if (!view_ || !is_visible_)
     return;
 
   view_->UpdateBounds();
 
   if (is_centered_)
-    view_->SetAnchorPoint(GetCenterOfDisplayForView(view_));
+    view_->SetAnchorPoint(GetCenterOfDisplayForView(
+        view_, GetMinimumBoundsHeightForAppList(view_)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AppListController, aura::EventFilter implementation:
 
 void AppListController::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED)
     ProcessLocatedEvent(event);
 }
 
@@ skipping 111 matching lines @@
   } else if (should_snap_back_) {
     should_snap_back_ = false;
     ui::ScopedLayerAnimationSettings animation(widget_animator);
     animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
         app_list::kOverscrollPageTransitionDurationMs));
     widget->SetBounds(view_bounds_);
   }
 }
 
 }  // namespace ash