Revert of 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/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),
       touch_editable_(TouchEditableImplAura::Create()),
       is_or_was_visible_(false) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, private:
 
 WebContentsViewAura::~WebContentsViewAura() {
   if (!window_)
     return;
@@ skipping 44 matching lines @@
     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_, window_.get()));
+  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);
   }
 }
 
 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();
 
-  navigation_overlay_->relay_delegate()->OnOverscrollComplete(mode);
+  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);
 }
 
 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)
     navigation_overlay_.reset();
-  if (!navigation_overlay_) {
-    navigation_overlay_.reset(
-        new OverscrollNavigationOverlay(web_contents_, window_.get()));
-  }
+  else if (!navigation_overlay_)
+    navigation_overlay_.reset(new OverscrollNavigationOverlay(web_contents_));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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(delta_y);
-    return delta_y != 0;
+    OverscrollUpdateForWebContentsDelegate(translate.y());
+  } else {
+    // Only horizontal overscrolls participate in the navigation gesture.
+    transform.Translate(translate.x(), translate.y());
+    target->SetTransform(transform);
+    UpdateOverscrollWindowBrightness(delta_x);
   }
-  return navigation_overlay_->relay_delegate()->OnOverscrollUpdate(delta_x,
-                                                                   delta_y);
+
+  return !translate.IsZero();
 }
 
 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();
   }
-  CompleteOverscrollNavigation(mode);
+  NavigationControllerImpl& controller = web_contents_->GetController();
+  if (ShouldNavigateForward(controller, mode) ||
+      ShouldNavigateBack(controller, mode)) {
+    CompleteOverscrollNavigation(mode);
+    return;
+  }
+
+  ResetOverscrollTransform();
 }
 
 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 (current_overscroll_gesture_ == OVERSCROLL_NONE &&
-      new_mode != OVERSCROLL_NONE) {
+  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();
+
     UMA_HISTOGRAM_ENUMERATION("Overscroll.Started", new_mode, OVERSCROLL_COUNT);
   }
-  current_overscroll_gesture_ = new_mode;
-  navigation_overlay_->relay_delegate()->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();
 }
 
 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