content/renderer/input/input_handler_proxy.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/input/input_handler_proxy.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "base/command_line.h"
   9 #include "base/location.h"
  10 #include "base/logging.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/trace_event/trace_event.h"
  15 #include "content/common/input/did_overscroll_params.h"
  16 #include "content/common/input/web_input_event_traits.h"
  17 #include "content/public/common/content_switches.h"
  18 #include "content/renderer/input/input_handler_proxy_client.h"
  19 #include "content/renderer/input/input_scroll_elasticity_controller.h"
  20 #include "third_party/WebKit/public/platform/Platform.h"
  21 #include "third_party/WebKit/public/web/WebInputEvent.h"
  22 #include "ui/events/latency_info.h"
  23 #include "ui/gfx/geometry/point_conversions.h"
  24
  25 using blink::WebFloatPoint;
  26 using blink::WebFloatSize;
  27 using blink::WebGestureEvent;
  28 using blink::WebInputEvent;
  29 using blink::WebMouseEvent;
  30 using blink::WebMouseWheelEvent;
  31 using blink::WebPoint;
  32 using blink::WebTouchEvent;
  33 using blink::WebTouchPoint;
  34
  35 namespace {
  36
  37 // Maximum time between a fling event's timestamp and the first |Animate| call
  38 // for the fling curve to use the fling timestamp as the initial animation time.
  39 // Two frames allows a minor delay between event creation and the first animate.
  40 const double kMaxSecondsFromFlingTimestampToFirstAnimate = 2. / 60.;
  41
  42 // Threshold for determining whether a fling scroll delta should have caused the
  43 // client to scroll.
  44 const float kScrollEpsilon = 0.1f;
  45
  46 // Minimum fling velocity required for the active fling and new fling for the
  47 // two to accumulate.
  48 const double kMinBoostFlingSpeedSquare = 350. * 350.;
  49
  50 // Minimum velocity for the active touch scroll to preserve (boost) an active
  51 // fling for which cancellation has been deferred.
  52 const double kMinBoostTouchScrollSpeedSquare = 150 * 150.;
  53
  54 // Timeout window after which the active fling will be cancelled if no scrolls
  55 // or flings of sufficient velocity relative to the current fling are received.
  56 // The default value on Android native views is 40ms, but we use a slightly
  57 // increased value to accomodate small IPC message delays.
  58 const double kFlingBoostTimeoutDelaySeconds = 0.045;
  59
  60 gfx::Vector2dF ToClientScrollIncrement(const WebFloatSize& increment) {
  61   return gfx::Vector2dF(-increment.width, -increment.height);
  62 }
  63
  64 double InSecondsF(const base::TimeTicks& time) {
  65   return (time - base::TimeTicks()).InSecondsF();
  66 }
  67
  68 bool ShouldSuppressScrollForFlingBoosting(
  69     const gfx::Vector2dF& current_fling_velocity,
  70     const WebGestureEvent& scroll_update_event,
  71     double time_since_last_boost_event) {
  72   DCHECK_EQ(WebInputEvent::GestureScrollUpdate, scroll_update_event.type);
  73
  74   gfx::Vector2dF dx(scroll_update_event.data.scrollUpdate.deltaX,
  75                     scroll_update_event.data.scrollUpdate.deltaY);
  76   if (gfx::DotProduct(current_fling_velocity, dx) <= 0)
  77     return false;
  78
  79   if (time_since_last_boost_event < 0.001)
  80     return true;
  81
  82   // TODO(jdduke): Use |scroll_update_event.data.scrollUpdate.velocity{X,Y}|.
  83   // The scroll must be of sufficient velocity to maintain the active fling.
  84   const gfx::Vector2dF scroll_velocity =
  85       gfx::ScaleVector2d(dx, 1. / time_since_last_boost_event);
  86   if (scroll_velocity.LengthSquared() < kMinBoostTouchScrollSpeedSquare)
  87     return false;
  88
  89   return true;
  90 }
  91
  92 bool ShouldBoostFling(const gfx::Vector2dF& current_fling_velocity,
  93                       const WebGestureEvent& fling_start_event) {
  94   DCHECK_EQ(WebInputEvent::GestureFlingStart, fling_start_event.type);
  95
  96   gfx::Vector2dF new_fling_velocity(
  97       fling_start_event.data.flingStart.velocityX,
  98       fling_start_event.data.flingStart.velocityY);
  99
 100   if (gfx::DotProduct(current_fling_velocity, new_fling_velocity) <= 0)
 101     return false;
 102
 103   if (current_fling_velocity.LengthSquared() < kMinBoostFlingSpeedSquare)
 104     return false;
 105
 106   if (new_fling_velocity.LengthSquared() < kMinBoostFlingSpeedSquare)
 107     return false;
 108
 109   return true;
 110 }
 111
 112 WebGestureEvent ObtainGestureScrollBegin(const WebGestureEvent& event) {
 113   WebGestureEvent scroll_begin_event = event;
 114   scroll_begin_event.type = WebInputEvent::GestureScrollBegin;
 115   scroll_begin_event.data.scrollBegin.deltaXHint = 0;
 116   scroll_begin_event.data.scrollBegin.deltaYHint = 0;
 117   return scroll_begin_event;
 118 }
 119
 120 void ReportInputEventLatencyUma(const WebInputEvent& event,
 121                                 const ui::LatencyInfo& latency_info) {
 122   if (!(event.type == WebInputEvent::GestureScrollBegin ||
 123         event.type == WebInputEvent::GestureScrollUpdate ||
 124         event.type == WebInputEvent::GesturePinchBegin ||
 125         event.type == WebInputEvent::GesturePinchUpdate ||
 126         event.type == WebInputEvent::GestureFlingStart)) {
 127     return;
 128   }
 129
 130   ui::LatencyInfo::LatencyMap::const_iterator it =
 131       latency_info.latency_components.find(std::make_pair(
 132           ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0));
 133
 134   if (it == latency_info.latency_components.end())
 135     return;
 136
 137   base::TimeDelta delta = base::TimeTicks::Now() - it->second.event_time;
 138   for (size_t i = 0; i < it->second.event_count; ++i) {
 139     switch (event.type) {
 140       case blink::WebInputEvent::GestureScrollBegin:
 141         UMA_HISTOGRAM_CUSTOM_COUNTS(
 142             "Event.Latency.RendererImpl.GestureScrollBegin",
 143             delta.InMicroseconds(), 1, 1000000, 100);
 144         break;
 145       case blink::WebInputEvent::GestureScrollUpdate:
 146         UMA_HISTOGRAM_CUSTOM_COUNTS(
 147             // So named for historical reasons.
 148             "Event.Latency.RendererImpl.GestureScroll2",
 149             delta.InMicroseconds(), 1, 1000000, 100);
 150         break;
 151       case blink::WebInputEvent::GesturePinchBegin:
 152         UMA_HISTOGRAM_CUSTOM_COUNTS(
 153             "Event.Latency.RendererImpl.GesturePinchBegin",
 154             delta.InMicroseconds(), 1, 1000000, 100);
 155         break;
 156       case blink::WebInputEvent::GesturePinchUpdate:
 157         UMA_HISTOGRAM_CUSTOM_COUNTS(
 158             "Event.Latency.RendererImpl.GesturePinchUpdate",
 159             delta.InMicroseconds(), 1, 1000000, 100);
 160         break;
 161       case blink::WebInputEvent::GestureFlingStart:
 162         UMA_HISTOGRAM_CUSTOM_COUNTS(
 163             "Event.Latency.RendererImpl.GestureFlingStart",
 164             delta.InMicroseconds(), 1, 1000000, 100);
 165         break;
 166       default:
 167         NOTREACHED();
 168         break;
 169     }
 170   }
 171 }
 172
 173 }  // namespace
 174
 175 namespace content {
 176
 177 InputHandlerProxy::InputHandlerProxy(cc::InputHandler* input_handler,
 178                                      InputHandlerProxyClient* client)
 179     : client_(client),
 180       input_handler_(input_handler),
 181       deferred_fling_cancel_time_seconds_(0),
 182 #ifndef NDEBUG
 183       expect_scroll_update_end_(false),
 184 #endif
 185       gesture_scroll_on_impl_thread_(false),
 186       gesture_pinch_on_impl_thread_(false),
 187       fling_may_be_active_on_main_thread_(false),
 188       disallow_horizontal_fling_scroll_(false),
 189       disallow_vertical_fling_scroll_(false),
 190       has_fling_animation_started_(false),
 191       uma_latency_reporting_enabled_(base::TimeTicks::IsHighResolution()) {
 192   DCHECK(client);
 193   input_handler_->BindToClient(this);
 194   smooth_scroll_enabled_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
 195       switches::kEnableSmoothScrolling);
 196   cc::ScrollElasticityHelper* scroll_elasticity_helper =
 197       input_handler_->CreateScrollElasticityHelper();
 198   if (scroll_elasticity_helper) {
 199     scroll_elasticity_controller_.reset(
 200         new InputScrollElasticityController(scroll_elasticity_helper));
 201   }
 202 }
 203
 204 InputHandlerProxy::~InputHandlerProxy() {}
 205
 206 void InputHandlerProxy::WillShutdown() {
 207   scroll_elasticity_controller_.reset();
 208   input_handler_ = NULL;
 209   client_->WillShutdown();
 210 }
 211
 212 InputHandlerProxy::EventDisposition
 213 InputHandlerProxy::HandleInputEventWithLatencyInfo(
 214     const WebInputEvent& event,
 215     ui::LatencyInfo* latency_info) {
 216   DCHECK(input_handler_);
 217
 218   if (uma_latency_reporting_enabled_)
 219     ReportInputEventLatencyUma(event, *latency_info);
 220
 221   TRACE_EVENT_FLOW_STEP0("input,benchmark",
 222                          "LatencyInfo.Flow",
 223                          TRACE_ID_DONT_MANGLE(latency_info->trace_id),
 224                          "HandleInputEventImpl");
 225
 226   scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
 227       input_handler_->CreateLatencyInfoSwapPromiseMonitor(latency_info);
 228   InputHandlerProxy::EventDisposition disposition = HandleInputEvent(event);
 229   return disposition;
 230 }
 231
 232 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleInputEvent(
 233     const WebInputEvent& event) {
 234   DCHECK(input_handler_);
 235   TRACE_EVENT1("input,benchmark", "InputHandlerProxy::HandleInputEvent",
 236                "type", WebInputEventTraits::GetName(event.type));
 237
 238   if (FilterInputEventForFlingBoosting(event))
 239     return DID_HANDLE;
 240
 241   switch (event.type) {
 242     case WebInputEvent::MouseWheel:
 243       return HandleMouseWheel(static_cast<const WebMouseWheelEvent&>(event));
 244
 245     case WebInputEvent::GestureScrollBegin:
 246       return HandleGestureScrollBegin(
 247           static_cast<const WebGestureEvent&>(event));
 248
 249     case WebInputEvent::GestureScrollUpdate:
 250       return HandleGestureScrollUpdate(
 251           static_cast<const WebGestureEvent&>(event));
 252
 253     case WebInputEvent::GestureScrollEnd:
 254       return HandleGestureScrollEnd(static_cast<const WebGestureEvent&>(event));
 255
 256     case WebInputEvent::GesturePinchBegin: {
 257       DCHECK(!gesture_pinch_on_impl_thread_);
 258       const WebGestureEvent& gesture_event =
 259           static_cast<const WebGestureEvent&>(event);
 260       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad &&
 261           input_handler_->HaveWheelEventHandlersAt(
 262               gfx::Point(gesture_event.x, gesture_event.y))) {
 263         return DID_NOT_HANDLE;
 264       } else {
 265         input_handler_->PinchGestureBegin();
 266         gesture_pinch_on_impl_thread_ = true;
 267         return DID_HANDLE;
 268       }
 269     }
 270
 271     case WebInputEvent::GesturePinchEnd:
 272       if (gesture_pinch_on_impl_thread_) {
 273         gesture_pinch_on_impl_thread_ = false;
 274         input_handler_->PinchGestureEnd();
 275         return DID_HANDLE;
 276       } else {
 277         return DID_NOT_HANDLE;
 278       }
 279
 280     case WebInputEvent::GesturePinchUpdate: {
 281       if (gesture_pinch_on_impl_thread_) {
 282         const WebGestureEvent& gesture_event =
 283             static_cast<const WebGestureEvent&>(event);
 284         if (gesture_event.data.pinchUpdate.zoomDisabled)
 285             return DROP_EVENT;
 286         input_handler_->PinchGestureUpdate(
 287             gesture_event.data.pinchUpdate.scale,
 288             gfx::Point(gesture_event.x, gesture_event.y));
 289         return DID_HANDLE;
 290       } else {
 291         return DID_NOT_HANDLE;
 292       }
 293     }
 294
 295     case WebInputEvent::GestureFlingStart:
 296       return HandleGestureFlingStart(
 297           *static_cast<const WebGestureEvent*>(&event));
 298
 299     case WebInputEvent::GestureFlingCancel:
 300       if (CancelCurrentFling())
 301         return DID_HANDLE;
 302       else if (!fling_may_be_active_on_main_thread_)
 303         return DROP_EVENT;
 304       return DID_NOT_HANDLE;
 305
 306     case WebInputEvent::TouchStart:
 307       return HandleTouchStart(static_cast<const WebTouchEvent&>(event));
 308
 309     case WebInputEvent::MouseMove: {
 310       const WebMouseEvent& mouse_event =
 311           static_cast<const WebMouseEvent&>(event);
 312       // TODO(tony): Ignore when mouse buttons are down?
 313       // TODO(davemoore): This should never happen, but bug #326635 showed some
 314       // surprising crashes.
 315       CHECK(input_handler_);
 316       input_handler_->MouseMoveAt(gfx::Point(mouse_event.x, mouse_event.y));
 317       return DID_NOT_HANDLE;
 318     }
 319
 320     default:
 321       if (WebInputEvent::isKeyboardEventType(event.type)) {
 322         // Only call |CancelCurrentFling()| if a fling was active, as it will
 323         // otherwise disrupt an in-progress touch scroll.
 324         if (fling_curve_)
 325           CancelCurrentFling();
 326       }
 327       break;
 328   }
 329
 330   return DID_NOT_HANDLE;
 331 }
 332
 333 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleMouseWheel(
 334     const WebMouseWheelEvent& wheel_event) {
 335   InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
 336   cc::InputHandlerScrollResult scroll_result;
 337
 338   // TODO(ccameron): The rail information should be pushed down into
 339   // InputHandler.
 340   gfx::Vector2dF scroll_delta(
 341       wheel_event.railsMode != WebInputEvent::RailsModeVertical
 342           ? -wheel_event.deltaX
 343           : 0,
 344       wheel_event.railsMode != WebInputEvent::RailsModeHorizontal
 345           ? -wheel_event.deltaY
 346           : 0);
 347
 348   if (wheel_event.scrollByPage) {
 349     // TODO(jamesr): We don't properly handle scroll by page in the compositor
 350     // thread, so punt it to the main thread. http://crbug.com/236639
 351     result = DID_NOT_HANDLE;
 352   } else if (!wheel_event.canScroll) {
 353     // Wheel events with |canScroll| == false will not trigger scrolling,
 354     // only event handlers.  Forward to the main thread.
 355     result = DID_NOT_HANDLE;
 356   } else if (smooth_scroll_enabled_) {
 357     cc::InputHandler::ScrollStatus scroll_status =
 358         input_handler_->ScrollAnimated(gfx::Point(wheel_event.x, wheel_event.y),
 359                                        scroll_delta);
 360     switch (scroll_status) {
 361       case cc::InputHandler::SCROLL_STARTED:
 362         result = DID_HANDLE;
 363         break;
 364       case cc::InputHandler::SCROLL_IGNORED:
 365         result = DROP_EVENT;
 366       default:
 367         result = DID_NOT_HANDLE;
 368         break;
 369     }
 370   } else {
 371     cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
 372         gfx::Point(wheel_event.x, wheel_event.y), cc::InputHandler::WHEEL);
 373     switch (scroll_status) {
 374       case cc::InputHandler::SCROLL_STARTED: {
 375         TRACE_EVENT_INSTANT2("input",
 376                              "InputHandlerProxy::handle_input wheel scroll",
 377                              TRACE_EVENT_SCOPE_THREAD, "deltaX",
 378                              scroll_delta.x(), "deltaY", scroll_delta.y());
 379         gfx::Point scroll_point(wheel_event.x, wheel_event.y);
 380         scroll_result = input_handler_->ScrollBy(scroll_point, scroll_delta);
 381         HandleOverscroll(scroll_point, scroll_result);
 382         input_handler_->ScrollEnd();
 383         result = scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
 384         break;
 385       }
 386       case cc::InputHandler::SCROLL_IGNORED:
 387         // TODO(jamesr): This should be DROP_EVENT, but in cases where we fail
 388         // to properly sync scrollability it's safer to send the event to the
 389         // main thread. Change back to DROP_EVENT once we have synchronization
 390         // bugs sorted out.
 391         result = DID_NOT_HANDLE;
 392         break;
 393       case cc::InputHandler::SCROLL_UNKNOWN:
 394       case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
 395         result = DID_NOT_HANDLE;
 396         break;
 397       case cc::InputHandler::ScrollStatusCount:
 398         NOTREACHED();
 399         break;
 400     }
 401   }
 402
 403   // Send the event and its disposition to the elasticity controller to update
 404   // the over-scroll animation. If the event is to be handled on the main
 405   // thread, the event and its disposition will be sent to the elasticity
 406   // controller after being handled on the main thread.
 407   if (scroll_elasticity_controller_ && result != DID_NOT_HANDLE) {
 408     // Note that the call to the elasticity controller is made asynchronously,
 409     // to minimize divergence between main thread and impl thread event
 410     // handling paths.
 411     base::ThreadTaskRunnerHandle::Get()->PostTask(
 412         FROM_HERE,
 413         base::Bind(&InputScrollElasticityController::ObserveWheelEventAndResult,
 414                    scroll_elasticity_controller_->GetWeakPtr(), wheel_event,
 415                    scroll_result));
 416   }
 417   return result;
 418 }
 419
 420 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollBegin(
 421     const WebGestureEvent& gesture_event) {
 422   DCHECK(!gesture_scroll_on_impl_thread_);
 423 #ifndef NDEBUG
 424   DCHECK(!expect_scroll_update_end_);
 425   expect_scroll_update_end_ = true;
 426 #endif
 427   cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
 428       gfx::Point(gesture_event.x, gesture_event.y), cc::InputHandler::GESTURE);
 429   UMA_HISTOGRAM_ENUMERATION("Renderer4.CompositorScrollHitTestResult",
 430                             scroll_status,
 431                             cc::InputHandler::ScrollStatusCount);
 432   switch (scroll_status) {
 433     case cc::InputHandler::SCROLL_STARTED:
 434       TRACE_EVENT_INSTANT0("input",
 435                            "InputHandlerProxy::handle_input gesture scroll",
 436                            TRACE_EVENT_SCOPE_THREAD);
 437       gesture_scroll_on_impl_thread_ = true;
 438       return DID_HANDLE;
 439     case cc::InputHandler::SCROLL_UNKNOWN:
 440     case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
 441       return DID_NOT_HANDLE;
 442     case cc::InputHandler::SCROLL_IGNORED:
 443       return DROP_EVENT;
 444     case cc::InputHandler::ScrollStatusCount:
 445       NOTREACHED();
 446       break;
 447   }
 448   return DID_NOT_HANDLE;
 449 }
 450
 451 InputHandlerProxy::EventDisposition
 452 InputHandlerProxy::HandleGestureScrollUpdate(
 453   const WebGestureEvent& gesture_event) {
 454 #ifndef NDEBUG
 455   DCHECK(expect_scroll_update_end_);
 456 #endif
 457
 458   if (!gesture_scroll_on_impl_thread_ && !gesture_pinch_on_impl_thread_)
 459     return DID_NOT_HANDLE;
 460
 461   gfx::Point scroll_point(gesture_event.x, gesture_event.y);
 462   gfx::Vector2dF scroll_delta(-gesture_event.data.scrollUpdate.deltaX,
 463                               -gesture_event.data.scrollUpdate.deltaY);
 464   cc::InputHandlerScrollResult scroll_result = input_handler_->ScrollBy(
 465       scroll_point, scroll_delta);
 466   HandleOverscroll(scroll_point, scroll_result);
 467   return scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
 468 }
 469
 470 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollEnd(
 471   const WebGestureEvent& gesture_event) {
 472 #ifndef NDEBUG
 473   DCHECK(expect_scroll_update_end_);
 474   expect_scroll_update_end_ = false;
 475 #endif
 476   input_handler_->ScrollEnd();
 477   if (!gesture_scroll_on_impl_thread_)
 478     return DID_NOT_HANDLE;
 479   gesture_scroll_on_impl_thread_ = false;
 480   return DID_HANDLE;
 481 }
 482
 483 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureFlingStart(
 484     const WebGestureEvent& gesture_event) {
 485   cc::InputHandler::ScrollStatus scroll_status;
 486
 487   if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
 488     scroll_status = input_handler_->ScrollBegin(
 489         gfx::Point(gesture_event.x, gesture_event.y),
 490         cc::InputHandler::NON_BUBBLING_GESTURE);
 491   } else {
 492     if (!gesture_scroll_on_impl_thread_)
 493       scroll_status = cc::InputHandler::SCROLL_ON_MAIN_THREAD;
 494     else
 495       scroll_status = input_handler_->FlingScrollBegin();
 496   }
 497
 498 #ifndef NDEBUG
 499   expect_scroll_update_end_ = false;
 500 #endif
 501
 502   switch (scroll_status) {
 503     case cc::InputHandler::SCROLL_STARTED: {
 504       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad)
 505         input_handler_->ScrollEnd();
 506
 507       const float vx = gesture_event.data.flingStart.velocityX;
 508       const float vy = gesture_event.data.flingStart.velocityY;
 509       current_fling_velocity_ = gfx::Vector2dF(vx, vy);
 510       DCHECK(!current_fling_velocity_.IsZero());
 511       fling_curve_.reset(client_->CreateFlingAnimationCurve(
 512           gesture_event.sourceDevice,
 513           WebFloatPoint(vx, vy),
 514           blink::WebSize()));
 515       disallow_horizontal_fling_scroll_ = !vx;
 516       disallow_vertical_fling_scroll_ = !vy;
 517       TRACE_EVENT_ASYNC_BEGIN2("input",
 518                                "InputHandlerProxy::HandleGestureFling::started",
 519                                this,
 520                                "vx",
 521                                vx,
 522                                "vy",
 523                                vy);
 524       // Note that the timestamp will only be used to kickstart the animation if
 525       // its sufficiently close to the timestamp of the first call |Animate()|.
 526       has_fling_animation_started_ = false;
 527       fling_parameters_.startTime = gesture_event.timeStampSeconds;
 528       fling_parameters_.delta = WebFloatPoint(vx, vy);
 529       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
 530       fling_parameters_.globalPoint =
 531           WebPoint(gesture_event.globalX, gesture_event.globalY);
 532       fling_parameters_.modifiers = gesture_event.modifiers;
 533       fling_parameters_.sourceDevice = gesture_event.sourceDevice;
 534       input_handler_->SetNeedsAnimate();
 535       return DID_HANDLE;
 536     }
 537     case cc::InputHandler::SCROLL_UNKNOWN:
 538     case cc::InputHandler::SCROLL_ON_MAIN_THREAD: {
 539       TRACE_EVENT_INSTANT0("input",
 540                            "InputHandlerProxy::HandleGestureFling::"
 541                            "scroll_on_main_thread",
 542                            TRACE_EVENT_SCOPE_THREAD);
 543       gesture_scroll_on_impl_thread_ = false;
 544       fling_may_be_active_on_main_thread_ = true;
 545       return DID_NOT_HANDLE;
 546     }
 547     case cc::InputHandler::SCROLL_IGNORED: {
 548       TRACE_EVENT_INSTANT0(
 549           "input",
 550           "InputHandlerProxy::HandleGestureFling::ignored",
 551           TRACE_EVENT_SCOPE_THREAD);
 552       gesture_scroll_on_impl_thread_ = false;
 553       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
 554         // We still pass the curve to the main thread if there's nothing
 555         // scrollable, in case something
 556         // registers a handler before the curve is over.
 557         return DID_NOT_HANDLE;
 558       }
 559       return DROP_EVENT;
 560     }
 561     case cc::InputHandler::ScrollStatusCount:
 562       NOTREACHED();
 563       break;
 564   }
 565   return DID_NOT_HANDLE;
 566 }
 567
 568 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchStart(
 569     const blink::WebTouchEvent& touch_event) {
 570   for (size_t i = 0; i < touch_event.touchesLength; ++i) {
 571     if (touch_event.touches[i].state != WebTouchPoint::StatePressed)
 572       continue;
 573     if (input_handler_->DoTouchEventsBlockScrollAt(
 574             gfx::Point(touch_event.touches[i].position.x,
 575                        touch_event.touches[i].position.y))) {
 576       // TODO(rbyers): We should consider still sending the touch events to
 577       // main asynchronously (crbug.com/455539).
 578       return DID_NOT_HANDLE;
 579     }
 580   }
 581   return DROP_EVENT;
 582 }
 583
 584 bool InputHandlerProxy::FilterInputEventForFlingBoosting(
 585     const WebInputEvent& event) {
 586   if (!WebInputEvent::isGestureEventType(event.type))
 587     return false;
 588
 589   if (!fling_curve_) {
 590     DCHECK(!deferred_fling_cancel_time_seconds_);
 591     return false;
 592   }
 593
 594   const WebGestureEvent& gesture_event =
 595       static_cast<const WebGestureEvent&>(event);
 596   if (gesture_event.type == WebInputEvent::GestureFlingCancel) {
 597     if (gesture_event.data.flingCancel.preventBoosting)
 598       return false;
 599
 600     if (current_fling_velocity_.LengthSquared() < kMinBoostFlingSpeedSquare)
 601       return false;
 602
 603     TRACE_EVENT_INSTANT0("input",
 604                          "InputHandlerProxy::FlingBoostStart",
 605                          TRACE_EVENT_SCOPE_THREAD);
 606     deferred_fling_cancel_time_seconds_ =
 607         event.timeStampSeconds + kFlingBoostTimeoutDelaySeconds;
 608     return true;
 609   }
 610
 611   // A fling is either inactive or is "free spinning", i.e., has yet to be
 612   // interrupted by a touch gesture, in which case there is nothing to filter.
 613   if (!deferred_fling_cancel_time_seconds_)
 614     return false;
 615
 616   // Gestures from a different source should immediately interrupt the fling.
 617   if (gesture_event.sourceDevice != fling_parameters_.sourceDevice) {
 618     CancelCurrentFling();
 619     return false;
 620   }
 621
 622   switch (gesture_event.type) {
 623     case WebInputEvent::GestureTapCancel:
 624     case WebInputEvent::GestureTapDown:
 625       return false;
 626
 627     case WebInputEvent::GestureScrollBegin:
 628       if (!input_handler_->IsCurrentlyScrollingLayerAt(
 629               gfx::Point(gesture_event.x, gesture_event.y),
 630               fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchpad
 631                   ? cc::InputHandler::NON_BUBBLING_GESTURE
 632                   : cc::InputHandler::GESTURE)) {
 633         CancelCurrentFling();
 634         return false;
 635       }
 636
 637       // TODO(jdduke): Use |gesture_event.data.scrollBegin.delta{X,Y}Hint| to
 638       // determine if the ScrollBegin should immediately cancel the fling.
 639       ExtendBoostedFlingTimeout(gesture_event);
 640       return true;
 641
 642     case WebInputEvent::GestureScrollUpdate: {
 643       const double time_since_last_boost_event =
 644           event.timeStampSeconds - last_fling_boost_event_.timeStampSeconds;
 645       if (ShouldSuppressScrollForFlingBoosting(current_fling_velocity_,
 646                                                gesture_event,
 647                                                time_since_last_boost_event)) {
 648         ExtendBoostedFlingTimeout(gesture_event);
 649         return true;
 650       }
 651
 652       CancelCurrentFling();
 653       return false;
 654     }
 655
 656     case WebInputEvent::GestureScrollEnd:
 657       // Clear the last fling boost event *prior* to fling cancellation,
 658       // preventing insertion of a synthetic GestureScrollBegin.
 659       last_fling_boost_event_ = WebGestureEvent();
 660       CancelCurrentFling();
 661       return true;
 662
 663     case WebInputEvent::GestureFlingStart: {
 664       DCHECK_EQ(fling_parameters_.sourceDevice, gesture_event.sourceDevice);
 665
 666       bool fling_boosted =
 667           fling_parameters_.modifiers == gesture_event.modifiers &&
 668           ShouldBoostFling(current_fling_velocity_, gesture_event);
 669
 670       gfx::Vector2dF new_fling_velocity(
 671           gesture_event.data.flingStart.velocityX,
 672           gesture_event.data.flingStart.velocityY);
 673       DCHECK(!new_fling_velocity.IsZero());
 674
 675       if (fling_boosted)
 676         current_fling_velocity_ += new_fling_velocity;
 677       else
 678         current_fling_velocity_ = new_fling_velocity;
 679
 680       WebFloatPoint velocity(current_fling_velocity_.x(),
 681                              current_fling_velocity_.y());
 682       deferred_fling_cancel_time_seconds_ = 0;
 683       disallow_horizontal_fling_scroll_ = !velocity.x;
 684       disallow_vertical_fling_scroll_ = !velocity.y;
 685       last_fling_boost_event_ = WebGestureEvent();
 686       fling_curve_.reset(client_->CreateFlingAnimationCurve(
 687           gesture_event.sourceDevice,
 688           velocity,
 689           blink::WebSize()));
 690       fling_parameters_.startTime = gesture_event.timeStampSeconds;
 691       fling_parameters_.delta = velocity;
 692       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
 693       fling_parameters_.globalPoint =
 694           WebPoint(gesture_event.globalX, gesture_event.globalY);
 695
 696       TRACE_EVENT_INSTANT2("input",
 697                            fling_boosted ? "InputHandlerProxy::FlingBoosted"
 698                                          : "InputHandlerProxy::FlingReplaced",
 699                            TRACE_EVENT_SCOPE_THREAD,
 700                            "vx",
 701                            current_fling_velocity_.x(),
 702                            "vy",
 703                            current_fling_velocity_.y());
 704
 705       // The client expects balanced calls between a consumed GestureFlingStart
 706       // and |DidStopFlinging()|. TODO(jdduke): Provide a count parameter to
 707       // |DidStopFlinging()| and only send after the accumulated fling ends.
 708       client_->DidStopFlinging();
 709       return true;
 710     }
 711
 712     default:
 713       // All other types of gestures (taps, presses, etc...) will complete the
 714       // deferred fling cancellation.
 715       CancelCurrentFling();
 716       return false;
 717   }
 718 }
 719
 720 void InputHandlerProxy::ExtendBoostedFlingTimeout(
 721     const blink::WebGestureEvent& event) {
 722   TRACE_EVENT_INSTANT0("input",
 723                        "InputHandlerProxy::ExtendBoostedFlingTimeout",
 724                        TRACE_EVENT_SCOPE_THREAD);
 725   deferred_fling_cancel_time_seconds_ =
 726       event.timeStampSeconds + kFlingBoostTimeoutDelaySeconds;
 727   last_fling_boost_event_ = event;
 728 }
 729
 730 void InputHandlerProxy::Animate(base::TimeTicks time) {
 731   if (scroll_elasticity_controller_)
 732     scroll_elasticity_controller_->Animate(time);
 733
 734   if (!fling_curve_)
 735     return;
 736
 737   double monotonic_time_sec = InSecondsF(time);
 738
 739   if (deferred_fling_cancel_time_seconds_ &&
 740       monotonic_time_sec > deferred_fling_cancel_time_seconds_) {
 741     CancelCurrentFling();
 742     return;
 743   }
 744
 745   client_->DidAnimateForInput();
 746
 747   if (!has_fling_animation_started_) {
 748     has_fling_animation_started_ = true;
 749     // Guard against invalid, future or sufficiently stale start times, as there
 750     // are no guarantees fling event and animation timestamps are compatible.
 751     if (!fling_parameters_.startTime ||
 752         monotonic_time_sec <= fling_parameters_.startTime ||
 753         monotonic_time_sec >= fling_parameters_.startTime +
 754                                   kMaxSecondsFromFlingTimestampToFirstAnimate) {
 755       fling_parameters_.startTime = monotonic_time_sec;
 756       input_handler_->SetNeedsAnimate();
 757       return;
 758     }
 759   }
 760
 761   bool fling_is_active =
 762       fling_curve_->apply(monotonic_time_sec - fling_parameters_.startTime,
 763                           this);
 764
 765   if (disallow_vertical_fling_scroll_ && disallow_horizontal_fling_scroll_)
 766     fling_is_active = false;
 767
 768   if (fling_is_active) {
 769     input_handler_->SetNeedsAnimate();
 770   } else {
 771     TRACE_EVENT_INSTANT0("input",
 772                          "InputHandlerProxy::animate::flingOver",
 773                          TRACE_EVENT_SCOPE_THREAD);
 774     CancelCurrentFling();
 775   }
 776 }
 777
 778 void InputHandlerProxy::MainThreadHasStoppedFlinging() {
 779   fling_may_be_active_on_main_thread_ = false;
 780   client_->DidStopFlinging();
 781 }
 782
 783 void InputHandlerProxy::ReconcileElasticOverscrollAndRootScroll() {
 784   if (scroll_elasticity_controller_)
 785     scroll_elasticity_controller_->ReconcileStretchAndScroll();
 786 }
 787
 788 void InputHandlerProxy::HandleOverscroll(
 789     const gfx::Point& causal_event_viewport_point,
 790     const cc::InputHandlerScrollResult& scroll_result) {
 791   DCHECK(client_);
 792   if (!scroll_result.did_overscroll_root)
 793     return;
 794
 795   TRACE_EVENT2("input",
 796                "InputHandlerProxy::DidOverscroll",
 797                "dx",
 798                scroll_result.unused_scroll_delta.x(),
 799                "dy",
 800                scroll_result.unused_scroll_delta.y());
 801
 802   DidOverscrollParams params;
 803   params.accumulated_overscroll = scroll_result.accumulated_root_overscroll;
 804   params.latest_overscroll_delta = scroll_result.unused_scroll_delta;
 805   params.current_fling_velocity =
 806       ToClientScrollIncrement(current_fling_velocity_);
 807   params.causal_event_viewport_point = causal_event_viewport_point;
 808
 809   if (fling_curve_) {
 810     static const int kFlingOverscrollThreshold = 1;
 811     disallow_horizontal_fling_scroll_ |=
 812         std::abs(params.accumulated_overscroll.x()) >=
 813         kFlingOverscrollThreshold;
 814     disallow_vertical_fling_scroll_ |=
 815         std::abs(params.accumulated_overscroll.y()) >=
 816         kFlingOverscrollThreshold;
 817   }
 818
 819   client_->DidOverscroll(params);
 820 }
 821
 822 bool InputHandlerProxy::CancelCurrentFling() {
 823   if (CancelCurrentFlingWithoutNotifyingClient()) {
 824     client_->DidStopFlinging();
 825     return true;
 826   }
 827   return false;
 828 }
 829
 830 bool InputHandlerProxy::CancelCurrentFlingWithoutNotifyingClient() {
 831   bool had_fling_animation = fling_curve_;
 832   if (had_fling_animation &&
 833       fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchscreen) {
 834     input_handler_->ScrollEnd();
 835     TRACE_EVENT_ASYNC_END0(
 836         "input",
 837         "InputHandlerProxy::HandleGestureFling::started",
 838         this);
 839   }
 840
 841   TRACE_EVENT_INSTANT1("input",
 842                        "InputHandlerProxy::CancelCurrentFling",
 843                        TRACE_EVENT_SCOPE_THREAD,
 844                        "had_fling_animation",
 845                        had_fling_animation);
 846   fling_curve_.reset();
 847   has_fling_animation_started_ = false;
 848   gesture_scroll_on_impl_thread_ = false;
 849   current_fling_velocity_ = gfx::Vector2dF();
 850   fling_parameters_ = blink::WebActiveWheelFlingParameters();
 851
 852   if (deferred_fling_cancel_time_seconds_) {
 853     deferred_fling_cancel_time_seconds_ = 0;
 854
 855     WebGestureEvent last_fling_boost_event = last_fling_boost_event_;
 856     last_fling_boost_event_ = WebGestureEvent();
 857     if (last_fling_boost_event.type == WebInputEvent::GestureScrollBegin ||
 858         last_fling_boost_event.type == WebInputEvent::GestureScrollUpdate) {
 859       // Synthesize a GestureScrollBegin, as the original was suppressed.
 860       HandleInputEvent(ObtainGestureScrollBegin(last_fling_boost_event));
 861     }
 862   }
 863
 864   return had_fling_animation;
 865 }
 866
 867 bool InputHandlerProxy::TouchpadFlingScroll(
 868     const WebFloatSize& increment) {
 869   WebMouseWheelEvent synthetic_wheel;
 870   synthetic_wheel.type = WebInputEvent::MouseWheel;
 871   synthetic_wheel.deltaX = increment.width;
 872   synthetic_wheel.deltaY = increment.height;
 873   synthetic_wheel.hasPreciseScrollingDeltas = true;
 874   synthetic_wheel.x = fling_parameters_.point.x;
 875   synthetic_wheel.y = fling_parameters_.point.y;
 876   synthetic_wheel.globalX = fling_parameters_.globalPoint.x;
 877   synthetic_wheel.globalY = fling_parameters_.globalPoint.y;
 878   synthetic_wheel.modifiers = fling_parameters_.modifiers;
 879
 880   InputHandlerProxy::EventDisposition disposition =
 881       HandleInputEvent(synthetic_wheel);
 882   switch (disposition) {
 883     case DID_HANDLE:
 884       return true;
 885     case DROP_EVENT:
 886       break;
 887     case DID_NOT_HANDLE:
 888       TRACE_EVENT_INSTANT0("input",
 889                            "InputHandlerProxy::scrollBy::AbortFling",
 890                            TRACE_EVENT_SCOPE_THREAD);
 891       // If we got a DID_NOT_HANDLE, that means we need to deliver wheels on the
 892       // main thread. In this case we need to schedule a commit and transfer the
 893       // fling curve over to the main thread and run the rest of the wheels from
 894       // there. This can happen when flinging a page that contains a scrollable
 895       // subarea that we can't scroll on the thread if the fling starts outside
 896       // the subarea but then is flung "under" the pointer.
 897       client_->TransferActiveWheelFlingAnimation(fling_parameters_);
 898       fling_may_be_active_on_main_thread_ = true;
 899       CancelCurrentFlingWithoutNotifyingClient();
 900       break;
 901   }
 902
 903   return false;
 904 }
 905
 906 bool InputHandlerProxy::scrollBy(const WebFloatSize& increment,
 907                                  const WebFloatSize& velocity) {
 908   WebFloatSize clipped_increment;
 909   WebFloatSize clipped_velocity;
 910   if (!disallow_horizontal_fling_scroll_) {
 911     clipped_increment.width = increment.width;
 912     clipped_velocity.width = velocity.width;
 913   }
 914   if (!disallow_vertical_fling_scroll_) {
 915     clipped_increment.height = increment.height;
 916     clipped_velocity.height = velocity.height;
 917   }
 918
 919   current_fling_velocity_ = clipped_velocity;
 920
 921   // Early out if the increment is zero, but avoid early terimination if the
 922   // velocity is still non-zero.
 923   if (clipped_increment == WebFloatSize())
 924     return clipped_velocity != WebFloatSize();
 925
 926   TRACE_EVENT2("input",
 927                "InputHandlerProxy::scrollBy",
 928                "x",
 929                clipped_increment.width,
 930                "y",
 931                clipped_increment.height);
 932
 933   bool did_scroll = false;
 934
 935   switch (fling_parameters_.sourceDevice) {
 936     case blink::WebGestureDeviceTouchpad:
 937       did_scroll = TouchpadFlingScroll(clipped_increment);
 938       break;
 939     case blink::WebGestureDeviceTouchscreen: {
 940       clipped_increment = ToClientScrollIncrement(clipped_increment);
 941       cc::InputHandlerScrollResult scroll_result = input_handler_->ScrollBy(
 942           fling_parameters_.point, clipped_increment);
 943       HandleOverscroll(fling_parameters_.point, scroll_result);
 944       did_scroll = scroll_result.did_scroll;
 945     } break;
 946   }
 947
 948   if (did_scroll) {
 949     fling_parameters_.cumulativeScroll.width += clipped_increment.width;
 950     fling_parameters_.cumulativeScroll.height += clipped_increment.height;
 951   }
 952
 953   // It's possible the provided |increment| is sufficiently small as to not
 954   // trigger a scroll, e.g., with a trivial time delta between fling updates.
 955   // Return true in this case to prevent early fling termination.
 956   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
 957       std::abs(clipped_increment.height) < kScrollEpsilon)
 958     return true;
 959
 960   return did_scroll;
 961 }
 962
 963 }  // namespace content