App list uses PaginationModel to transition between pages.

ui/app_list/pagination_model.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/pagination_model.h"
 
 #include <algorithm>
 
 #include "ui/app_list/pagination_model_observer.h"
 #include "ui/gfx/animation/slide_animation.h"
@@ skipping 81 matching lines @@
     int old_selected = selected_page_;
     selected_page_ = page;
     NotifySelectedPageChanged(old_selected, selected_page_);
   }
 }
 
 void PaginationModel::SelectPageRelative(int delta, bool animate) {
   SelectPage(CalculateTargetPage(delta), animate);
 }
 
+void PaginationModel::FinishAnimation() {
+  SelectPage(SelectedTargetPage(), false);
+}
+
 void PaginationModel::SetTransition(const Transition& transition) {
   // -1 and |total_pages_| is a valid target page, which means user is at
   // the end and there is no target page for this scroll.
   DCHECK(transition.target_page >= -1 &&
          transition.target_page <= total_pages_);
   DCHECK(transition.progress >= 0 && transition.progress <= 1);
 
   if (transition_.Equals(transition))
     return;
 
@@ skipping 58 matching lines @@
 }
 
 void PaginationModel::AddObserver(PaginationModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void PaginationModel::RemoveObserver(PaginationModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+int PaginationModel::SelectedTargetPage() const {
+  // If no animation, or animation is in reverse, just the selected page.
+  if (!transition_animation_ || !transition_animation_->IsShowing())
+    return selected_page_;
+
+  // If, at the end of the current animation, we will animate to another page,
+  // return that eventual page.
+  if (pending_selected_page_ >= 0)
+    return pending_selected_page_;
+
+  // Just the target of the current animation.
+  return transition_.target_page;
+}
+
 void PaginationModel::NotifySelectedPageChanged(int old_selected,
                                                 int new_selected) {
   FOR_EACH_OBSERVER(PaginationModelObserver,
                     observers_,
                     SelectedPageChanged(old_selected, new_selected));
 }
 
 void PaginationModel::NotifyTransitionStarted() {
   FOR_EACH_OBSERVER(PaginationModelObserver, observers_, TransitionStarted());
 }
 
 void PaginationModel::NotifyTransitionChanged() {
   FOR_EACH_OBSERVER(PaginationModelObserver, observers_, TransitionChanged());
 }
 
 int PaginationModel::CalculateTargetPage(int delta) const {
   DCHECK_GT(total_pages_, 0);
-
-  int current_page = selected_page_;
-  if (transition_animation_ && transition_animation_->IsShowing()) {
-    current_page = pending_selected_page_ >= 0 ?
-        pending_selected_page_ : transition_.target_page;
-  }
-
-  const int target_page = current_page + delta;
+  const int target_page = SelectedTargetPage() + delta;
 
   int start_page = 0;
   int end_page = total_pages_ - 1;
 
   // Use invalid page when |selected_page_| is at ends.
   if (target_page < start_page && selected_page_ == start_page)
     start_page = -1;
   else if (target_page > end_page && selected_page_ == end_page)
     end_page = total_pages_;
 
@@ skipping 48 matching lines @@
   } else if (transition_animation_->GetCurrentValue() == 0) {
     // Hiding animation ends. No page change should happen.
     ResetTransitionAnimation();
   }
 
   if (next_target >= 0)
     SelectPage(next_target, true);
 }
 
 }  // namespace app_list