[exp] Browser-side fling in aura.

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 48 matching lines @@
 }
 
 double InSecondsF(const base::TimeTicks& time) {
   return (time - base::TimeTicks()).InSecondsF();
 }
 
 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);
+  DCHECK(WebInputEvent::GestureScrollUpdate == scroll_update_event.type ||
+         WebInputEvent::GestureScrollUpdateWithoutPropagation ==
+             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)
     return false;
 
   if (time_since_last_boost_event < 0.001)
     return true;
 
   // TODO(jdduke): Use |scroll_update_event.data.scrollUpdate.velocity{X,Y}|.
@@ skipping 200 matching lines @@
         return DID_HANDLE;
       case cc::InputHandler::ScrollUnknown:
       case cc::InputHandler::ScrollOnMainThread:
         return DID_NOT_HANDLE;
       case cc::InputHandler::ScrollIgnored:
         return DROP_EVENT;
       case cc::InputHandler::ScrollStatusCount:
         NOTREACHED();
         break;
     }
-  } else if (event.type == WebInputEvent::GestureScrollUpdate) {
+  } else if (event.type == WebInputEvent::GestureScrollUpdate ||
+             event.type ==
+                 WebInputEvent::GestureScrollUpdateWithoutPropagation) {
 #ifndef NDEBUG
     DCHECK(expect_scroll_update_end_);
 #endif
 
     if (!gesture_scroll_on_impl_thread_ && !gesture_pinch_on_impl_thread_)
       return DID_NOT_HANDLE;
 
     const WebGestureEvent& gesture_event =
         *static_cast<const WebGestureEvent*>(&event);
     bool did_scroll = input_handler_->ScrollBy(
@@ skipping 202 matching lines @@
                   : cc::InputHandler::Gesture)) {
         CancelCurrentFling();
         return false;
       }
 
       // TODO(jdduke): Use |gesture_event.data.scrollBegin.delta{X,Y}Hint| to
       // determine if the ScrollBegin should immediately cancel the fling.
       ExtendBoostedFlingTimeout(gesture_event);
       return true;
 
+    case WebInputEvent::GestureScrollUpdateWithoutPropagation:
     case WebInputEvent::GestureScrollUpdate: {
       const double time_since_last_boost_event =
           event.timeStampSeconds - last_fling_boost_event_.timeStampSeconds;
       if (ShouldSuppressScrollForFlingBoosting(current_fling_velocity_,
                                                gesture_event,
                                                time_since_last_boost_event)) {
         ExtendBoostedFlingTimeout(gesture_event);
         return true;
       }
 
@@ skipping 182 matching lines @@
   gesture_scroll_on_impl_thread_ = false;
   current_fling_velocity_ = gfx::Vector2dF();
   fling_parameters_ = blink::WebActiveWheelFlingParameters();
 
   if (deferred_fling_cancel_time_seconds_) {
     deferred_fling_cancel_time_seconds_ = 0;
 
     WebGestureEvent last_fling_boost_event = last_fling_boost_event_;
     last_fling_boost_event_ = WebGestureEvent();
     if (last_fling_boost_event.type == WebInputEvent::GestureScrollBegin ||
+        last_fling_boost_event.type ==
+            WebInputEvent::GestureScrollUpdateWithoutPropagation ||
         last_fling_boost_event.type == WebInputEvent::GestureScrollUpdate) {
       // Synthesize a GestureScrollBegin, as the original was suppressed.
       HandleInputEvent(ObtainGestureScrollBegin(last_fling_boost_event));
     }
   }
 
   return had_fling_animation;
 }
 
 bool InputHandlerProxy::TouchpadFlingScroll(
@@ skipping 84 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