Prevent orthogonal fling accumulation

content/renderer/input/input_handler_proxy.cc

 // Copyright 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/input/input_handler_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 52 matching lines @@
 }
 
 bool ShouldSuppressScrollForFlingBoosting(
     const gfx::Vector2dF& current_fling_velocity,
     const WebGestureEvent& scroll_update_event,
     double time_since_last_boost_event) {
   DCHECK_EQ(WebInputEvent::GestureScrollUpdate, scroll_update_event.type);
 
   gfx::Vector2dF dx(scroll_update_event.data.scrollUpdate.deltaX,
                     scroll_update_event.data.scrollUpdate.deltaY);
-  if (gfx::DotProduct(current_fling_velocity, dx) < 0)
+  if (gfx::DotProduct(current_fling_velocity, dx) <= 0)
     return false;
 
   if (time_since_last_boost_event < 0.001)
     return true;
 
   // TODO(jdduke): Use |scroll_update_event.data.scrollUpdate.velocity{X,Y}|.
   // The scroll must be of sufficient velocity to maintain the active fling.
   const gfx::Vector2dF scroll_velocity =
       gfx::ScaleVector2d(dx, 1. / time_since_last_boost_event);
   if (scroll_velocity.LengthSquared() < kMinBoostTouchScrollSpeedSquare)
     return false;
 
   return true;
 }
 
 bool ShouldBoostFling(const gfx::Vector2dF& current_fling_velocity,
                       const WebGestureEvent& fling_start_event) {
   DCHECK_EQ(WebInputEvent::GestureFlingStart, fling_start_event.type);
 
   gfx::Vector2dF new_fling_velocity(
       fling_start_event.data.flingStart.velocityX,
       fling_start_event.data.flingStart.velocityY);
 
-  if (gfx::DotProduct(current_fling_velocity, new_fling_velocity) < 0)
+  if (gfx::DotProduct(current_fling_velocity, new_fling_velocity) <= 0)
     return false;
 
   if (current_fling_velocity.LengthSquared() < kMinBoostFlingSpeedSquare)
     return false;
 
   if (new_fling_velocity.LengthSquared() < kMinBoostFlingSpeedSquare)
     return false;
 
   return true;
 }
@@ skipping 435 matching lines @@
           gesture_event.data.flingStart.velocityY);
 
       if (fling_boosted)
         current_fling_velocity_ += new_fling_velocity;
       else
         current_fling_velocity_ = new_fling_velocity;
 
       WebFloatPoint velocity(current_fling_velocity_.x(),
                              current_fling_velocity_.y());
       deferred_fling_cancel_time_seconds_ = 0;
+      disallow_horizontal_fling_scroll_ = !velocity.x;
+      disallow_vertical_fling_scroll_ = !velocity.y;
       last_fling_boost_event_ = WebGestureEvent();
       fling_curve_.reset(client_->CreateFlingAnimationCurve(
           gesture_event.sourceDevice,
           velocity,
           blink::WebSize()));
       fling_parameters_.startTime = gesture_event.timeStampSeconds;
       fling_parameters_.delta = velocity;
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
@@ skipping 246 matching lines @@
   // trigger a scroll, e.g., with a trivial time delta between fling updates.
   // Return true in this case to prevent early fling termination.
   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
       std::abs(clipped_increment.height) < kScrollEpsilon)
     return true;
 
   return did_scroll;
 }
 
 }  // namespace content