Refactor app list so AppsGridView owns the PaginationModel.

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"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "base/command_line.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/pagination_model.h"
+#include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/app_list_view.h"
+#include "ui/app_list/views/apps_container_view.h"

[tapted, 2014/06/02 08:36:49]

nit: these 3 includes, and app_list_main_view.h above might be unnecessary now

[Matt Giuca, 2014/06/03 01:52:36]

Done.

+#include "ui/app_list/views/apps_grid_view.h"
+#include "ui/app_list/views/contents_view.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/views/widget/widget.h"
 
@@ skipping 116 matching lines @@
 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_visible_(false),
       is_centered_(false),
       view_(NULL),
+      current_app_page_(-1),
       should_snap_back_(false) {
   Shell::GetInstance()->AddShellObserver(this);
-  pagination_model_->AddObserver(this);
 }
 
 AppListController::~AppListController() {
   // Ensures app list view goes before the controller since pagination model
   // lives in the controller and app list view would access it on destruction.
-  if (view_ && view_->GetWidget())
-    view_->GetWidget()->CloseNow();
+  if (view_) {
+    view_->GetAppsPaginationModel()->RemoveObserver(this);
+    if (view_->GetWidget())
+      view_->GetWidget()->CloseNow();
+  }
 
   Shell::GetInstance()->RemoveShellObserver(this);
-  pagination_model_->RemoveObserver(this);
 }
 
 void AppListController::SetVisible(bool visible, aura::Window* window) {
   if (visible == is_visible_)
     return;
 
   is_visible_ = visible;
 
   // App list needs to know the new shelf layout in order to calculate its
   // UI layout when AppListView visibility changes.
@@ skipping 18 matching lines @@
     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->SetAnchorPoint(GetCenterOfDisplayForView(
           applist_button, GetMinimumBoundsHeightForAppList(view)));
     } 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(),
           GetAnchorPositionOffsetToShelf(applist_button_bounds,
               Shelf::ForWindow(container)->GetAppListButtonView()->
                   GetWidget()),
           GetBubbleArrow(container),
           true /* border_accepts_events */);
       view->SetArrowPaintType(views::BubbleBorder::PAINT_NONE);
     }
     SetView(view);
     // By setting us as DnD recipient, the app list knows that we can
@@ skipping 31 matching lines @@
   widget->AddObserver(this);
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller)
     keyboard_controller->AddObserver(this);
   Shell::GetInstance()->AddPreTargetHandler(this);
   Shelf::ForWindow(widget->GetNativeWindow())->AddIconObserver(this);
   widget->GetNativeView()->GetRootWindow()->AddObserver(this);
   aura::client::GetFocusClient(widget->GetNativeView())->AddObserver(this);
 
+  app_list::PaginationModel* pagination_model = view_->GetAppsPaginationModel();
+  pagination_model->AddObserver(this);
+  if (pagination_model->is_valid_page(current_app_page_))
+    pagination_model->SelectPage(current_app_page_, false);
+
   view_->ShowWhenReady();
 }
 
 void AppListController::ResetView() {
   if (!view_)
     return;
 
   views::Widget* widget = view_->GetWidget();
   widget->RemoveObserver(this);
   GetLayer(widget)->GetAnimator()->RemoveObserver(this);
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller)
     keyboard_controller->RemoveObserver(this);
   Shell::GetInstance()->RemovePreTargetHandler(this);
   Shelf::ForWindow(widget->GetNativeWindow())->RemoveIconObserver(this);
   widget->GetNativeView()->GetRootWindow()->RemoveObserver(this);
   aura::client::GetFocusClient(widget->GetNativeView())->RemoveObserver(this);
+
+  view_->GetAppsPaginationModel()->RemoveObserver(this);
+
   view_ = NULL;
 }
 
 void AppListController::ScheduleAnimation() {
   // Stop observing previous animation.
   StopObservingImplicitAnimations();
 
   views::Widget* widget = view_->GetWidget();
   ui::Layer* layer = GetLayer(widget);
   layer->GetAnimator()->StopAnimating();
@@ skipping 134 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AppListController, PaginationModelObserver implementation:
 
 void AppListController::TotalPagesChanged() {
 }
 
 void AppListController::SelectedPageChanged(int old_selected,
                                             int new_selected) {
+  current_app_page_ = new_selected;
 }
 
 void AppListController::TransitionStarted() {
 }
 
 void AppListController::TransitionChanged() {
   // |view_| could be NULL when app list is closed with a running transition.
   if (!view_)
     return;
 
+  app_list::PaginationModel* pagination_model = view_->GetAppsPaginationModel();
+
   const app_list::PaginationModel::Transition& transition =
-      pagination_model_->transition();
-  if (pagination_model_->is_valid_page(transition.target_page))
+      pagination_model->transition();
+  if (pagination_model->is_valid_page(transition.target_page))
     return;
 
   views::Widget* widget = view_->GetWidget();
   ui::LayerAnimator* widget_animator = GetLayer(widget)->GetAnimator();
-  if (!pagination_model_->IsRevertingCurrentTransition()) {
+  if (!pagination_model->IsRevertingCurrentTransition()) {
     // Update cached |view_bounds_| if it is the first over-scroll move and
     // widget does not have running animations.
     if (!should_snap_back_ && !widget_animator->is_animating())
       view_bounds_ = widget->GetWindowBoundsInScreen();
 
-    const int current_page = pagination_model_->selected_page();
+    const int current_page = pagination_model->selected_page();
     const int dir = transition.target_page > current_page ? -1 : 1;
 
     const double progress = 1.0 - pow(1.0 - transition.progress, 4);
     const int shift = kMaxOverScrollShift * progress * dir;
 
     gfx::Rect shifted(view_bounds_);
     shifted.set_x(shifted.x() + shift);
     widget->SetBounds(shifted);
     should_snap_back_ = true;
   } 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