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"
+#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),
+      pagination_model_(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_) {
+    DCHECK(pagination_model_);
+    pagination_model_->RemoveObserver(this);
+    if (view_->GetWidget())
+      view_->GetWidget()->CloseNow();
+  } else {
+    DCHECK(!pagination_model_);
+  }
 
   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 17 matching lines @@
 // AppListController, private:
 
 void AppListController::SetDragAndDropHostOfCurrentAppList(
     app_list::ApplicationDragAndDropHost* drag_and_drop_host) {
   if (view_ && is_visible_)
     view_->SetDragAndDropHostOfCurrentAppList(drag_and_drop_host);
 }
 
 void AppListController::SetView(app_list::AppListView* view) {
   DCHECK(view_ == NULL);
+  DCHECK(pagination_model_ == NULL);
   DCHECK(is_visible_);
 
   view_ = view;
   views::Widget* widget = view_->GetWidget();
   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);
 
+  pagination_model_ = view_->app_list_main_view()

[tapted, 2014/06/02 04:02:21]

I think this justifies a GetPaginationModel() accessor on AppListView :) - you
can get rid of a lot of #includes that way. And even remove the
pagination_model_ member on AppListController; relying instead on
view_->GetPaginationModel()

[Matt Giuca, 2014/06/02 07:11:23]

Done & Done.

+                          ->contents_view()
+                          ->apps_container_view()
+                          ->apps_grid_view()
+                          ->GetPaginationModel();
+  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);
+
+  DCHECK(pagination_model_);
+  pagination_model_->RemoveObserver(this);
+  pagination_model_ = NULL;
+
   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;
 
+  DCHECK(pagination_model_);
+
   const app_list::PaginationModel::Transition& transition =
       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()) {
     // Update cached |view_bounds_| if it is the first over-scroll move and
     // widget does not have running animations.
@@ skipping 13 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