Refactor GestureNavigation to eliminate code redundancy

content/browser/web_contents/web_contents_view_aura.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 "content/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/download/drag_download_util.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/browser/web_contents/aura/gesture_nav_simple.h"
 #include "content/browser/web_contents/aura/overscroll_navigation_overlay.h"
-#include "content/browser/web_contents/aura/shadow_layer_delegate.h"
-#include "content/browser/web_contents/aura/window_slider.h"
+#include "content/browser/web_contents/aura/overscroll_window_animation.h"
 #include "content/browser/web_contents/touch_editable_impl_aura.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_view_delegate.h"
 #include "content/public/browser/web_drag_dest_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/drop_data.h"
 #include "net/base/filename_util.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/aura/window_tree_host_observer.h"
-#include "ui/aura_extra/image_window_delegate.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/public/drag_drop_client.h"
 #include "ui/wm/public/drag_drop_delegate.h"
 
 namespace content {
 WebContentsView* CreateWebContentsView(
     WebContentsImpl* web_contents,
     WebContentsViewDelegate* delegate,
     RenderViewHostDelegateView** render_view_host_delegate_view) {
   WebContentsViewAura* rv = new WebContentsViewAura(web_contents, delegate);
   *render_view_host_delegate_view = rv;
   return rv;
 }
 
 namespace {
 
 bool IsScrollEndEffectEnabled() {
   return base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kScrollEndEffect) == "1";
 }
 
-bool ShouldNavigateForward(const NavigationController& controller,
-                           OverscrollMode mode) {
-  return mode == (base::i18n::IsRTL() ? OVERSCROLL_EAST : OVERSCROLL_WEST) &&
-         controller.CanGoForward();
-}
-
-bool ShouldNavigateBack(const NavigationController& controller,
-                        OverscrollMode mode) {
-  return mode == (base::i18n::IsRTL() ? OVERSCROLL_WEST : OVERSCROLL_EAST) &&
-         controller.CanGoBack();
-}
-
 RenderWidgetHostViewAura* ToRenderWidgetHostViewAura(
     RenderWidgetHostView* view) {
   if (!view || RenderViewHostFactory::has_factory())
     return NULL;  // Can't cast to RenderWidgetHostViewAura in unit tests.
 
   RenderViewHost* rvh = RenderViewHost::From(view->GetRenderWidgetHost());
   WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
       rvh ? WebContents::FromRenderViewHost(rvh) : NULL);
   if (BrowserPluginGuest::IsGuest(web_contents))
     return NULL;
   return static_cast<RenderWidgetHostViewAura*>(view);
 }
 
-// The window delegate for the overscroll window. This redirects trackpad events
-// to the web-contents window. The delegate destroys itself when the window is
-// destroyed.
-class OverscrollWindowDelegate : public aura_extra::ImageWindowDelegate {
- public:
-  OverscrollWindowDelegate(WebContentsImpl* web_contents,
-                           OverscrollMode overscroll_mode)
-      : web_contents_(web_contents),
-        forward_events_(true) {
-    const NavigationControllerImpl& controller = web_contents->GetController();
-    const NavigationEntryImpl* entry = NULL;
-    if (ShouldNavigateForward(controller, overscroll_mode)) {
-      entry = controller.GetEntryAtOffset(1);
-    } else if (ShouldNavigateBack(controller, overscroll_mode)) {
-      entry = controller.GetEntryAtOffset(-1);
-    }
-
-    gfx::Image image;
-    if (entry && entry->screenshot().get()) {
-      std::vector<gfx::ImagePNGRep> image_reps;
-      image_reps.push_back(gfx::ImagePNGRep(entry->screenshot(), 1.0f));
-      image = gfx::Image(image_reps);
-    }
-    SetImage(image);
-  }
-
-  void stop_forwarding_events() { forward_events_ = false; }
-
- private:
-  ~OverscrollWindowDelegate() override {}
-
-  aura::Window* web_contents_window() {
-    return web_contents_->GetView()->GetContentNativeView();
-  }
-
-  // Overridden from ui::EventHandler.
-  void OnScrollEvent(ui::ScrollEvent* event) override {
-    if (forward_events_ && web_contents_window())
-      web_contents_window()->delegate()->OnScrollEvent(event);
-  }
-
-  void OnGestureEvent(ui::GestureEvent* event) override {
-    if (forward_events_ && web_contents_window())
-      web_contents_window()->delegate()->OnGestureEvent(event);
-  }
-
-  WebContentsImpl* web_contents_;
-
-  // The window is displayed both during the gesture, and after the gesture
-  // while the navigation is in progress. During the gesture, it is necessary to
-  // forward input events to the content page (e.g. when the overscroll window
-  // slides under the cursor and starts receiving scroll events). However, once
-  // the gesture is complete, and the window is being displayed as an overlay
-  // window during navigation, events should not be forwarded anymore.
-  bool forward_events_;
-
-  DISALLOW_COPY_AND_ASSIGN(OverscrollWindowDelegate);
-};
-
 // Listens to all mouse drag events during a drag and drop and sends them to
 // the renderer.
 class WebDragSourceAura : public NotificationObserver {
  public:
   WebDragSourceAura(aura::Window* window, WebContentsImpl* contents)
       : window_(window),
         contents_(contents) {
     registrar_.Add(this,
                    NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                    Source<WebContents>(contents));
@@ skipping 539 matching lines @@
   // The parent window that hosts the constrained windows. We cache the old host
   // view so that we can unregister when it's not the parent anymore.
   aura::Window* host_window_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, public:
 
-WebContentsViewAura::WebContentsViewAura(
-    WebContentsImpl* web_contents,
-    WebContentsViewDelegate* delegate)
+WebContentsViewAura::WebContentsViewAura(WebContentsImpl* web_contents,
+                                         WebContentsViewDelegate* delegate)
     : web_contents_(web_contents),
       delegate_(delegate),
       current_drag_op_(blink::WebDragOperationNone),
       drag_dest_delegate_(NULL),
       current_rvh_for_drag_(NULL),
-      overscroll_change_brightness_(false),
       current_overscroll_gesture_(OVERSCROLL_NONE),
       completed_overscroll_gesture_(OVERSCROLL_NONE),
+      navigation_overlay_(nullptr),
+      overscroll_window_animation_(nullptr),
       touch_editable_(TouchEditableImplAura::Create()),
       is_or_was_visible_(false) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, private:
 
 WebContentsViewAura::~WebContentsViewAura() {
   if (!window_)
     return;
@@ skipping 34 matching lines @@
   web_contents_->DragSourceEndedAt(client_loc.x(), client_loc.y(),
       screen_loc.x(), screen_loc.y(), ops);
 }
 
 void WebContentsViewAura::InstallOverscrollControllerDelegate(
     RenderWidgetHostViewAura* view) {
   const std::string value = base::CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kOverscrollHistoryNavigation);
   if (value == "0") {
     navigation_overlay_.reset();
+    overscroll_window_animation_ = nullptr;
     return;
   }
   if (value == "2") {
     navigation_overlay_.reset();
     if (!gesture_nav_simple_)
       gesture_nav_simple_.reset(new GestureNavSimple(web_contents_));
     view->overscroll_controller()->set_delegate(gesture_nav_simple_.get());
     return;
   }
   view->overscroll_controller()->set_delegate(this);
-  if (!navigation_overlay_)
-    navigation_overlay_.reset(new OverscrollNavigationOverlay(web_contents_));
-}
-
-void WebContentsViewAura::PrepareOverscrollWindow() {
-  // If there is an existing |overscroll_window_| which is in the middle of an
-  // animation, then destroying the window here causes the animation to be
-  // completed immediately, which triggers |OnImplicitAnimationsCompleted()|
-  // callback, and that tries to reset |overscroll_window_| again, causing a
-  // double-free. So use a temporary variable here.
-  if (overscroll_window_) {
-    base::AutoReset<OverscrollMode> reset_state(&current_overscroll_gesture_,
-                                                current_overscroll_gesture_);
-    scoped_ptr<aura::Window> reset_window(overscroll_window_.release());
-  }
-
-  OverscrollWindowDelegate* overscroll_delegate = new OverscrollWindowDelegate(
-      web_contents_,
-      current_overscroll_gesture_);
-  overscroll_window_.reset(new aura::Window(overscroll_delegate));
-  overscroll_window_->SetType(ui::wm::WINDOW_TYPE_CONTROL);
-  overscroll_window_->SetTransparent(true);
-  overscroll_window_->Init(ui::LAYER_TEXTURED);
-  overscroll_window_->layer()->SetMasksToBounds(false);
-  overscroll_window_->SetName("OverscrollOverlay");
-
-  overscroll_change_brightness_ = overscroll_delegate->has_image();
-  window_->AddChild(overscroll_window_.get());
-
-  gfx::Rect bounds = gfx::Rect(window_->bounds().size());
-  if (ShouldNavigateForward(web_contents_->GetController(),
-                            current_overscroll_gesture_)) {
-    // The overlay will be sliding in from the right edge towards the left in
-    // non-RTL, or sliding in from the left edge towards the right in RTL.
-    // So position the overlay window accordingly.
-    bounds.Offset(base::i18n::IsRTL() ? -bounds.width() : bounds.width(), 0);
-  }
-
-  aura::Window* animate_window = GetWindowToAnimateForOverscroll();
-  if (animate_window == overscroll_window_)
-    window_->StackChildAbove(overscroll_window_.get(), GetContentNativeView());
-  else
-    window_->StackChildBelow(overscroll_window_.get(), GetContentNativeView());
-
-  UpdateOverscrollWindowBrightness(0.f);
-
-  overscroll_window_->SetBounds(bounds);
-  overscroll_window_->Show();
-
-  overscroll_shadow_.reset(new ShadowLayerDelegate(animate_window->layer()));
-}
-
-void WebContentsViewAura::PrepareContentWindowForOverscroll() {
-  StopObservingImplicitAnimations();
-  aura::Window* content = GetContentNativeView();
-  content->layer()->GetAnimator()->AbortAllAnimations();
-  content->SetTransform(gfx::Transform());
-  content->layer()->SetLayerBrightness(0.f);
-}
-
-void WebContentsViewAura::ResetOverscrollTransform() {
-  if (!web_contents_->GetRenderWidgetHostView())
-    return;
-  aura::Window* target = GetWindowToAnimateForOverscroll();
-  if (!target)
-    return;
-  {
-    ui::ScopedLayerAnimationSettings settings(target->layer()->GetAnimator());
-    settings.SetPreemptionStrategy(
-        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-    settings.SetTweenType(gfx::Tween::EASE_OUT);
-    settings.AddObserver(this);
-    target->SetTransform(gfx::Transform());
-  }
-  {
-    ui::ScopedLayerAnimationSettings settings(target->layer()->GetAnimator());
-    settings.SetPreemptionStrategy(
-        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-    settings.SetTweenType(gfx::Tween::EASE_OUT);
-    UpdateOverscrollWindowBrightness(0.f);
+  if (!navigation_overlay_) {
+    navigation_overlay_.reset(
+        new OverscrollNavigationOverlay(web_contents_, window_.get()));
+    overscroll_window_animation_ = navigation_overlay_->owa();
   }
 }
 
 void WebContentsViewAura::CompleteOverscrollNavigation(OverscrollMode mode) {
   if (!web_contents_->GetRenderWidgetHostView())
     return;
 
-  // Animate out the current view first. Navigate to the requested history at
-  // the end of the animation.
-  if (current_overscroll_gesture_ == OVERSCROLL_NONE)
-    return;
-
   UMA_HISTOGRAM_ENUMERATION("Overscroll.Navigated",
                             current_overscroll_gesture_, OVERSCROLL_COUNT);
-  OverscrollWindowDelegate* delegate = static_cast<OverscrollWindowDelegate*>(
-      overscroll_window_->delegate());
-  delegate->stop_forwarding_events();
 
-  completed_overscroll_gesture_ = mode;
-  aura::Window* target = GetWindowToAnimateForOverscroll();
-  ui::ScopedLayerAnimationSettings settings(target->layer()->GetAnimator());
-  settings.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  settings.SetTweenType(gfx::Tween::EASE_OUT);
-  settings.AddObserver(this);
-  gfx::Transform transform;
-  int content_width =
-      web_contents_->GetRenderWidgetHostView()->GetViewBounds().width();
-  float translate_x = static_cast<float>(mode == OVERSCROLL_WEST ?
-      -content_width : content_width);
-  transform.Translate(translate_x, 0);
-  target->SetTransform(transform);
-  UpdateOverscrollWindowBrightness(translate_x);
-}
-
-aura::Window* WebContentsViewAura::GetWindowToAnimateForOverscroll() {
-  if (current_overscroll_gesture_ == OVERSCROLL_NONE)
-    return NULL;
-
-  return ShouldNavigateForward(web_contents_->GetController(),
-                               current_overscroll_gesture_) ?
-      overscroll_window_.get() : GetContentNativeView();
-}
-
-gfx::Vector2dF WebContentsViewAura::GetTranslationForOverscroll(float delta_x,
-                                                                float delta_y) {
-  if (current_overscroll_gesture_ == OVERSCROLL_NORTH ||
-      current_overscroll_gesture_ == OVERSCROLL_SOUTH) {
-    return gfx::Vector2dF(0, delta_y);
-  }
-  // For horizontal overscroll, scroll freely if a navigation is possible. Do a
-  // resistive scroll otherwise.
-  const NavigationControllerImpl& controller = web_contents_->GetController();
-  const gfx::Rect& bounds = GetViewBounds();
-  const float bounds_width = static_cast<float>(bounds.width());
-  if (ShouldNavigateForward(controller, current_overscroll_gesture_))
-    return gfx::Vector2dF(std::max(-bounds_width, delta_x), 0);
-  else if (ShouldNavigateBack(controller, current_overscroll_gesture_))
-    return gfx::Vector2dF(std::min(bounds_width, delta_x), 0);
-  return gfx::Vector2dF();
-}
-
-void WebContentsViewAura::PrepareOverscrollNavigationOverlay() {
-  OverscrollWindowDelegate* delegate = static_cast<OverscrollWindowDelegate*>(
-      overscroll_window_->delegate());
-  overscroll_window_->SchedulePaintInRect(
-      gfx::Rect(overscroll_window_->bounds().size()));
-  overscroll_window_->SetBounds(gfx::Rect(window_->bounds().size()));
-  overscroll_window_->SetTransform(gfx::Transform());
-  navigation_overlay_->SetOverlayWindow(overscroll_window_.Pass(),
-                                        delegate);
-  navigation_overlay_->StartObserving();
-}
-
-void WebContentsViewAura::UpdateOverscrollWindowBrightness(float delta_x) {
-  if (!overscroll_change_brightness_)
-    return;
-
-  const float kBrightnessMin = -.1f;
-  const float kBrightnessMax = -.01f;
-
-  float ratio = fabs(delta_x) / GetViewBounds().width();
-  ratio = std::min(1.f, ratio);
-  if (base::i18n::IsRTL())
-    ratio = 1.f - ratio;
-  float brightness = current_overscroll_gesture_ == OVERSCROLL_WEST ?
-      kBrightnessMin + ratio * (kBrightnessMax - kBrightnessMin) :
-      kBrightnessMax - ratio * (kBrightnessMax - kBrightnessMin);
-  brightness = std::max(kBrightnessMin, brightness);
-  brightness = std::min(kBrightnessMax, brightness);
-  aura::Window* window = GetWindowToAnimateForOverscroll();
-  window->layer()->SetLayerBrightness(brightness);
+  overscroll_window_animation_->OnOverscrollComplete(mode);
 }
 
 void WebContentsViewAura::AttachTouchEditableToRenderView() {
   if (!touch_editable_)
     return;
   RenderWidgetHostViewAura* rwhva = ToRenderWidgetHostViewAura(
       web_contents_->GetRenderWidgetHostView());
   touch_editable_->AttachToView(rwhva);
 }
 
@@ skipping 138 matching lines @@
     DCHECK(RenderViewHostFactory::has_factory());
     return static_cast<RenderWidgetHostViewBase*>(
         render_widget_host->GetView());
   }
 
   RenderWidgetHostViewAura* view =
       new RenderWidgetHostViewAura(render_widget_host, is_guest_view_hack);
   view->InitAsChild(NULL);
   GetNativeView()->AddChild(view->GetNativeView());
 
-  if (navigation_overlay_.get() && navigation_overlay_->has_window()) {
-    navigation_overlay_->StartObserving();
-  }
-
   RenderWidgetHostImpl* host_impl =
       RenderWidgetHostImpl::From(render_widget_host);
 
   if (!host_impl->is_hidden())
     view->Show();
 
   // We listen to drag drop events in the newly created view's window.
   aura::client::SetDragDropDelegate(view->GetNativeView(), this);
 
   if (view->overscroll_controller() &&
@@ skipping 12 matching lines @@
 }
 
 void WebContentsViewAura::SetPageTitle(const base::string16& title) {
   window_->SetTitle(title);
 }
 
 void WebContentsViewAura::RenderViewCreated(RenderViewHost* host) {
 }
 
 void WebContentsViewAura::RenderViewSwappedIn(RenderViewHost* host) {
-  if (navigation_overlay_.get() && navigation_overlay_->has_window())
-    navigation_overlay_->StartObserving();
   AttachTouchEditableToRenderView();
 }
 
 void WebContentsViewAura::SetOverscrollControllerEnabled(bool enabled) {
   RenderWidgetHostViewAura* view =
       ToRenderWidgetHostViewAura(web_contents_->GetRenderWidgetHostView());
   if (view) {
     view->SetOverscrollControllerEnabled(enabled);
     if (enabled)
       InstallOverscrollControllerDelegate(view);
   }
 
-  if (!enabled)
+  if (!enabled) {
     navigation_overlay_.reset();
-  else if (!navigation_overlay_)
-    navigation_overlay_.reset(new OverscrollNavigationOverlay(web_contents_));
+    overscroll_window_animation_ = nullptr;
+  }
+  if (!navigation_overlay_) {
+    navigation_overlay_.reset(
+        new OverscrollNavigationOverlay(web_contents_, window_.get()));
+    overscroll_window_animation_ = navigation_overlay_->owa();
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, RenderViewHostDelegateView implementation:
 
 void WebContentsViewAura::ShowContextMenu(RenderFrameHost* render_frame_host,
                                           const ContextMenuParams& params) {
   if (touch_editable_) {
     touch_editable_->EndTouchEditing(false);
   }
@@ skipping 105 matching lines @@
   if (!rwhv || !rwhv->IsShowing())
     return gfx::Rect();
 
   return rwhv->GetViewBounds();
 }
 
 bool WebContentsViewAura::OnOverscrollUpdate(float delta_x, float delta_y) {
   if (current_overscroll_gesture_ == OVERSCROLL_NONE)
     return false;
 
-  aura::Window* target = GetWindowToAnimateForOverscroll();
-  gfx::Vector2dF translate = GetTranslationForOverscroll(delta_x, delta_y);
-  gfx::Transform transform;
-
   if (current_overscroll_gesture_ == OVERSCROLL_NORTH ||
       current_overscroll_gesture_ == OVERSCROLL_SOUTH) {
-    OverscrollUpdateForWebContentsDelegate(translate.y());
-  } else {
-    // Only horizontal overscrolls participate in the navigation gesture.
-    transform.Translate(translate.x(), translate.y());
-    target->SetTransform(transform);
-    UpdateOverscrollWindowBrightness(delta_x);
+    OverscrollUpdateForWebContentsDelegate(delta_y);
+    return delta_y != 0;
   }
-
-  return !translate.IsZero();
+  return overscroll_window_animation_->OnOverscrollUpdate(delta_x, delta_y);
 }
 
 void WebContentsViewAura::OnOverscrollComplete(OverscrollMode mode) {
   UMA_HISTOGRAM_ENUMERATION("Overscroll.Completed", mode, OVERSCROLL_COUNT);
   if (web_contents_->GetDelegate() &&
       IsScrollEndEffectEnabled() &&
       (mode == OVERSCROLL_NORTH || mode == OVERSCROLL_SOUTH)) {
     web_contents_->GetDelegate()->OverscrollComplete();
   }
-  NavigationControllerImpl& controller = web_contents_->GetController();
-  if (ShouldNavigateForward(controller, mode) ||
-      ShouldNavigateBack(controller, mode)) {
-    CompleteOverscrollNavigation(mode);
-    return;
-  }
-
-  ResetOverscrollTransform();
+  CompleteOverscrollNavigation(mode);
 }
 
 void WebContentsViewAura::OnOverscrollModeChange(OverscrollMode old_mode,
                                                  OverscrollMode new_mode) {
-  // Reset any in-progress overscroll animation first.
-  ResetOverscrollTransform();
-
   if (old_mode == OVERSCROLL_NORTH || old_mode == OVERSCROLL_SOUTH)
     OverscrollUpdateForWebContentsDelegate(0);
 
   if (new_mode != OVERSCROLL_NONE && touch_editable_)
     touch_editable_->OverscrollStarted();
 
-  if (new_mode == OVERSCROLL_NONE ||
-      !GetContentNativeView() ||
-      ((new_mode == OVERSCROLL_EAST || new_mode == OVERSCROLL_WEST) &&
-       navigation_overlay_.get() && navigation_overlay_->has_window())) {
-    current_overscroll_gesture_ = OVERSCROLL_NONE;
-  } else {
-    aura::Window* target = GetWindowToAnimateForOverscroll();
-    if (target) {
-      StopObservingImplicitAnimations();
-      target->layer()->GetAnimator()->AbortAllAnimations();
-    }
-    // Cleanup state of the content window first, because that can reset the
-    // value of |current_overscroll_gesture_|.
-    PrepareContentWindowForOverscroll();
-
-    current_overscroll_gesture_ = new_mode;
-    if (current_overscroll_gesture_ == OVERSCROLL_EAST ||
-        current_overscroll_gesture_ == OVERSCROLL_WEST)
-      PrepareOverscrollWindow();
-
+  if (current_overscroll_gesture_ == OVERSCROLL_NONE &&
+      new_mode != OVERSCROLL_NONE) {
     UMA_HISTOGRAM_ENUMERATION("Overscroll.Started", new_mode, OVERSCROLL_COUNT);
   }
+  current_overscroll_gesture_ = new_mode;
+  overscroll_window_animation_->OnOverscrollModeChange(old_mode, new_mode);
   completed_overscroll_gesture_ = OVERSCROLL_NONE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// WebContentsViewAura, ui::ImplicitAnimationObserver implementation:
-
-void WebContentsViewAura::OnImplicitAnimationsCompleted() {
-  overscroll_shadow_.reset();
-
-  if (ShouldNavigateForward(web_contents_->GetController(),
-                            completed_overscroll_gesture_)) {
-    web_contents_->GetController().GoForward();
-    PrepareOverscrollNavigationOverlay();
-  } else if (ShouldNavigateBack(web_contents_->GetController(),
-                                completed_overscroll_gesture_)) {
-    web_contents_->GetController().GoBack();
-    PrepareOverscrollNavigationOverlay();
-  } else {
-    if (touch_editable_)
-      touch_editable_->OverscrollCompleted();
-  }
-
-  aura::Window* content = GetContentNativeView();
-  if (content) {
-    content->SetTransform(gfx::Transform());
-    content->layer()->SetLayerBrightness(0.f);
-  }
-  current_overscroll_gesture_ = OVERSCROLL_NONE;
-  completed_overscroll_gesture_ = OVERSCROLL_NONE;
-  overscroll_window_.reset();
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, aura::WindowDelegate implementation:
 
 gfx::Size WebContentsViewAura::GetMinimumSize() const {
   return gfx::Size();
 }
 
 gfx::Size WebContentsViewAura::GetMaximumSize() const {
   return gfx::Size();
 }
 
@@ skipping 56 matching lines @@
     float device_scale_factor) {
 }
 
 void WebContentsViewAura::OnWindowDestroying(aura::Window* window) {
   // This means the destructor is going to be called soon. If there is an
   // overscroll gesture in progress (i.e. |overscroll_window_| is not NULL),
   // then destroying it in the WebContentsViewAura destructor can trigger other
   // virtual functions to be called (e.g. OnImplicitAnimationsCompleted()). So
   // destroy the overscroll window here.
   navigation_overlay_.reset();
-  overscroll_window_.reset();
+  overscroll_window_animation_ = nullptr;

[sadrul, 2015/04/07 17:10:08]

Instead of keeping this pointer |overscroll_window_animation_| in WCVA, access
it through navigation_overlay_ when needed.

[Nina, 2015/04/07 19:08:56]

Done.

 }
 
 void WebContentsViewAura::OnWindowDestroyed(aura::Window* window) {
 }
 
 void WebContentsViewAura::OnWindowTargetVisibilityChanged(bool visible) {
 }
 
 bool WebContentsViewAura::HasHitTestMask() const {
   return false;
@@ skipping 141 matching lines @@
   if (visible) {
     if (!web_contents_->should_normally_be_visible())
       web_contents_->WasShown();
   } else {
     if (web_contents_->should_normally_be_visible())
       web_contents_->WasHidden();
   }
 }
 
 }  // namespace content