overscroll: Fix an issue where the overscroll window could get stuck.

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/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/dip_util.h"
@@ skipping 82 matching lines @@
 }
 
 // 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::WindowDelegate {
  public:
   OverscrollWindowDelegate(WebContentsImpl* web_contents,
                            OverscrollMode overscroll_mode)
       : web_contents_(web_contents),
-        show_shadow_(false) {
+        show_shadow_(false),
+        forward_events_(true) {
     const NavigationControllerImpl& controller = web_contents->GetController();
     const NavigationEntryImpl* entry = NULL;
     if (ShouldNavigateForward(controller, overscroll_mode)) {
       entry = NavigationEntryImpl::FromNavigationEntry(
           controller.GetEntryAtOffset(1));
     } else if (ShouldNavigateBack(controller, overscroll_mode)) {
       entry = NavigationEntryImpl::FromNavigationEntry(
           controller.GetEntryAtOffset(-1));
     }
     if (!entry || !entry->screenshot())
       return;
 
     std::vector<gfx::ImagePNGRep> image_reps;
     image_reps.push_back(gfx::ImagePNGRep(entry->screenshot(),
           ui::GetScaleFactorForNativeView(web_contents_window())));
     image_ = gfx::Image(image_reps);
     if (image_.AsImageSkia().size() != web_contents_window()->bounds().size())
       image_ = gfx::Image();
   }
 
   bool has_screenshot() const { return !image_.IsEmpty(); }
 
   void set_show_shadow(bool show) {
     show_shadow_ = show;
   }
 
+  void stop_forwarding_events() { forward_events_ = false; }
+
  private:
   virtual ~OverscrollWindowDelegate() {}
 
   aura::Window* web_contents_window() {
     return web_contents_->GetView()->GetContentNativeView();
   }
 
   // aura::WindowDelegate implementation:
   virtual gfx::Size GetMinimumSize() const OVERRIDE {
     return gfx::Size();
@@ skipping 77 matching lines @@
 
   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {
   }
 
   virtual scoped_refptr<ui::Texture> CopyTexture() OVERRIDE {
     return scoped_refptr<ui::Texture>();
   }
 
   // Overridden from ui::EventHandler.
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
-    if (web_contents_window())
+    if (forward_events_ && web_contents_window())
       web_contents_window()->delegate()->OnScrollEvent(event);
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
-    if (web_contents_window())
+    if (forward_events_ && web_contents_window())
       web_contents_window()->delegate()->OnGestureEvent(event);
   }
 
   WebContents* web_contents_;
   gfx::Image image_;
   bool show_shadow_;
 
+  // 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 MessageLoopForUI::Observer,
                           public NotificationObserver {
  public:
   WebDragSourceAura(aura::Window* window, WebContentsImpl* contents)
       : window_(window),
@@ skipping 340 matching lines @@
 // screenshot window on top of the page until the page has completed loading and
 // painting.
 class OverscrollNavigationOverlay :
     public RenderWidgetHostViewAura::PaintObserver {
  public:
   OverscrollNavigationOverlay()
       : view_(NULL),
         loading_complete_(false),
         received_paint_update_(false),
         compositor_updated_(false),
-        has_screenshot_(false) {
+        has_screenshot_(false),
+        need_paint_update_(true) {
   }
 
   virtual ~OverscrollNavigationOverlay() {
     if (view_)
       view_->set_paint_observer(NULL);
   }
 
   bool has_window() const { return !!window_.get(); }
 
   void StartObservingView(RenderWidgetHostViewAura* view) {
@@ skipping 11 matching lines @@
       window_->parent()->StackChildAtTop(window_.get());
   }
 
   void SetOverlayWindow(scoped_ptr<aura::Window> window, bool has_screenshot) {
     window_ = window.Pass();
     if (window_.get() && window_->parent())
       window_->parent()->StackChildAtTop(window_.get());
     has_screenshot_ = has_screenshot;
   }
 
+  void SetupForTesting() {
+    need_paint_update_ = false;
+  }
+
  private:
   // Stop observing the page if the page-load has completed and the page has
   // been painted.
   void StopObservingIfDone() {
     // If there is a screenshot displayed in the overlay window, then wait for
     // the navigated page to complete loading and some paint update before
     // hiding the overlay.
     // If there is no screenshot in the overlay window, then hide this view
     // as soon as there is any new painting notification.
-    if (!received_paint_update_ || (has_screenshot_ && !loading_complete_))
+    if ((need_paint_update_ && !received_paint_update_) ||
+        (has_screenshot_ && !loading_complete_)) {
       return;
+    }
 
     window_.reset();
     if (view_) {
       view_->set_paint_observer(NULL);
       view_ = NULL;
     }
   }
 
   // Overridden from RenderWidgetHostViewAura::PaintObserver:
   virtual void OnPaintComplete() OVERRIDE {
@@ skipping 21 matching lines @@
     view_ = NULL;
   }
 
   scoped_ptr<aura::Window> window_;
   RenderWidgetHostViewAura* view_;
   bool loading_complete_;
   bool received_paint_update_;
   bool compositor_updated_;
   bool has_screenshot_;
 
+  // During tests, the aura windows don't get any paint updates. So the overlay
+  // container keeps waiting for a paint update it never receives, causing a
+  // timeout. So during tests, disable the wait for paint updates.
+  bool need_paint_update_;
+
   DISALLOW_COPY_AND_ASSIGN(OverscrollNavigationOverlay);
 };
 
 class WebContentsViewAura::WindowObserver
     : public aura::WindowObserver, public aura::RootWindowObserver {
  public:
   explicit WindowObserver(WebContentsViewAura* view)
       : view_(view),
         parent_(NULL) {
     view_->window_->AddObserver(this);
@@ skipping 157 matching lines @@
 
   window_observer_.reset();
 #if defined(OS_WIN)
   child_window_observer_.reset();
 #endif
   // Window needs a valid delegate during its destructor, so we explicitly
   // delete it here.
   window_.reset();
 }
 
+void WebContentsViewAura::SetupOverlayWindowForTesting() {
+  if (navigation_overlay_.get())
+    navigation_overlay_->SetupForTesting();
+}
+
 void WebContentsViewAura::SizeChangedCommon(const gfx::Size& size) {
   if (web_contents_->GetInterstitialPage())
     web_contents_->GetInterstitialPage()->SetSize(size);
   RenderWidgetHostView* rwhv =
       web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
 }
 
 void WebContentsViewAura::EndDrag(WebKit::WebDragOperationsMask ops) {
@@ skipping 173 matching lines @@
       OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER);
   int scroll = GetResistedScrollAmount(abs(delta_x),
                                        static_cast<int>(threshold));
   return gfx::Vector2d(delta_x < 0 ? -scroll : scroll, 0);
 }
 
 void WebContentsViewAura::PrepareOverscrollNavigationOverlay() {
   OverscrollWindowDelegate* delegate = static_cast<OverscrollWindowDelegate*>(
       overscroll_window_->delegate());
   delegate->set_show_shadow(false);
+  delegate->stop_forwarding_events();
   overscroll_window_->SchedulePaintInRect(
       gfx::Rect(overscroll_window_->bounds().size()));
   navigation_overlay_->SetOverlayWindow(overscroll_window_.Pass(),
                                         delegate->has_screenshot());
   navigation_overlay_->StartObservingView(static_cast<
       RenderWidgetHostViewAura*>(web_contents_->GetRenderWidgetHostView()));
 }
 
 void WebContentsViewAura::UpdateOverscrollWindowBrightness(float delta_x) {
   if (!overscroll_change_brightness_)
@@ skipping 308 matching lines @@
   }
 
   ResetOverscrollTransform();
 }
 
 void WebContentsViewAura::OnOverscrollModeChange(OverscrollMode old_mode,
                                                  OverscrollMode new_mode) {
   // Reset any in-progress overscroll animation first.
   ResetOverscrollTransform();
 
-  if (new_mode == OVERSCROLL_NONE) {
+  if (new_mode == OVERSCROLL_NONE ||
+      (navigation_overlay_.get() && navigation_overlay_->has_window())) {
     current_overscroll_gesture_ = OVERSCROLL_NONE;
   } else {
     // Cleanup state of the content window first, because that can reset the
     // value of |current_overscroll_gesture_|.
     PrepareContentWindowForOverscroll();
 
     current_overscroll_gesture_ = new_mode;
     PrepareOverscrollWindow();
 
     UMA_HISTOGRAM_ENUMERATION("Overscroll.Started", new_mode, OVERSCROLL_COUNT);
@@ skipping 208 matching lines @@
       event.location(),
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint(),
       ConvertAuraEventFlagsToWebInputEventModifiers(event.flags()));
   if (drag_dest_delegate_)
     drag_dest_delegate_->OnDrop();
   current_drop_data_.reset();
   return current_drag_op_;
 }
 
 }  // namespace content