gpu: Avoid flinging beyond content edge

content/renderer/gpu/input_handler_proxy.cc

 // Copyright (c) 2013 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/renderer/gpu/input_handler_proxy.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "content/renderer/gpu/input_handler_proxy_client.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
@@ skipping 11 matching lines @@
 
 InputHandlerProxy::InputHandlerProxy(cc::InputHandler* input_handler)
     : client_(NULL),
       input_handler_(input_handler),
 #ifndef NDEBUG
       expect_scroll_update_end_(false),
       expect_pinch_update_end_(false),
 #endif
       gesture_scroll_on_impl_thread_(false),
       gesture_pinch_on_impl_thread_(false),
-      fling_may_be_active_on_main_thread_(false) {
+      fling_may_be_active_on_main_thread_(false),
+      fling_overscrolled_horizontally_(false),
+      fling_overscrolled_vertically_(false) {
   input_handler_->BindToClient(this);
 }
 
 InputHandlerProxy::~InputHandlerProxy() {}
 
 void InputHandlerProxy::WillShutdown() {
   input_handler_ = NULL;
   DCHECK(client_);
   client_->WillShutdown();
 }
@@ skipping 181 matching lines @@
   switch (scroll_status) {
     case cc::InputHandler::ScrollStarted: {
       if (gesture_event.sourceDevice == WebGestureEvent::Touchpad)
         input_handler_->ScrollEnd();
 
       fling_curve_.reset(client_->CreateFlingAnimationCurve(
           gesture_event.sourceDevice,
           WebFloatPoint(gesture_event.data.flingStart.velocityX,
                         gesture_event.data.flingStart.velocityY),
           WebKit::WebSize()));
+      fling_overscrolled_horizontally_ = false;
+      fling_overscrolled_vertically_ = false;
       TRACE_EVENT_ASYNC_BEGIN0(
           "renderer",
           "InputHandlerProxy::HandleGestureFling::started",
           this);
       fling_parameters_.delta =
           WebFloatPoint(gesture_event.data.flingStart.velocityX,
                         gesture_event.data.flingStart.velocityY);
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
@@ skipping 49 matching lines @@
   }
 }
 
 void InputHandlerProxy::MainThreadHasStoppedFlinging() {
   fling_may_be_active_on_main_thread_ = false;
 }
 
 void InputHandlerProxy::DidOverscroll(gfx::Vector2dF accumulated_overscroll,
                                       gfx::Vector2dF current_fling_velocity) {
   DCHECK(client_);
+  if (fling_curve_) {
+    const int kFlingOverscrollThreshold = 1;

[jamesr, 2013/05/31 18:23:28]

why not static?

+    fling_overscrolled_horizontally_ |=
+        std::abs(accumulated_overscroll.x()) >= kFlingOverscrollThreshold;
+    fling_overscrolled_vertically_ |=
+        std::abs(accumulated_overscroll.y()) >= kFlingOverscrollThreshold;
+  }
+
   client_->DidOverscroll(accumulated_overscroll, current_fling_velocity);
 }
 
 bool InputHandlerProxy::CancelCurrentFling() {
   bool had_fling_animation = fling_curve_;
   if (had_fling_animation &&
       fling_parameters_.sourceDevice == WebGestureEvent::Touchscreen) {
     input_handler_->ScrollEnd();
     TRACE_EVENT_ASYNC_END0(
         "renderer",
@@ skipping 49 matching lines @@
   }
 
   return false;
 }
 
 static gfx::Vector2dF ToClientScrollIncrement(const WebFloatSize& increment) {
   return gfx::Vector2dF(-increment.width, -increment.height);
 }
 
 void InputHandlerProxy::scrollBy(const WebFloatSize& increment) {
-  if (increment == WebFloatSize())
+  WebFloatSize clipped_increment;
+  if (!fling_overscrolled_horizontally_)
+    clipped_increment.width = increment.width;
+  if (!fling_overscrolled_vertically_)
+    clipped_increment.height = increment.height;
+
+  if (clipped_increment == WebFloatSize())
     return;
 
   TRACE_EVENT2("renderer",
                "InputHandlerProxy::scrollBy",
                "x",
-               increment.width,
+               clipped_increment.width,
                "y",
-               increment.height);
+               clipped_increment.height);
 
   bool did_scroll = false;
 
   switch (fling_parameters_.sourceDevice) {
     case WebGestureEvent::Touchpad:
-      did_scroll = TouchpadFlingScroll(increment);
+      did_scroll = TouchpadFlingScroll(clipped_increment);
       break;
     case WebGestureEvent::Touchscreen:
+      clipped_increment = ToClientScrollIncrement(clipped_increment);
       did_scroll = input_handler_->ScrollBy(fling_parameters_.point,
-                                            ToClientScrollIncrement(increment));
+                                            clipped_increment);
       break;
   }
 
   if (did_scroll) {
-    fling_parameters_.cumulativeScroll.width += increment.width;
-    fling_parameters_.cumulativeScroll.height += increment.height;
+    fling_parameters_.cumulativeScroll.width += clipped_increment.width;
+    fling_parameters_.cumulativeScroll.height += clipped_increment.height;
   }
 }
 
 void InputHandlerProxy::notifyCurrentFlingVelocity(
     const WebFloatSize& velocity) {
   TRACE_EVENT2("renderer",
                "InputHandlerProxy::notifyCurrentFlingVelocity",
                "vx",
                velocity.width,
                "vy",
                velocity.height);
   input_handler_->NotifyCurrentFlingVelocity(ToClientScrollIncrement(velocity));
 }
 
 }  // namespace content