Hook ScrollElasticityController to InputHandlerProxy

content/renderer/input/input_scroll_elasticity_controller.cc

 // Copyright 2014 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_scroll_elasticity_controller.h"
 
 #include <math.h>
 
-// ScrollElasticityController and ScrollElasticityControllerClient are based on
-// WebKit/Source/platform/mac/ScrollElasticityController.mm
+// InputScrollElasticityController is based on
+// WebKit/Source/platform/mac/InputScrollElasticityController.mm
 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 60 matching lines @@
     // multiplier = [[NSUserDefaults standardUserDefaults]
     //     floatForKey:@"NSScrollWheelMultiplier"];
     if (multiplier <= 0)
       multiplier = 1;
   }
   return multiplier;
 }
 
 }  // namespace
 
-ScrollElasticityController::ScrollElasticityController(
-    ScrollElasticityControllerClient* client)
+InputScrollElasticityController::InputScrollElasticityController(
+    cc::ScrollElasticityControllerClient* client)
     : client_(client),
       in_scroll_gesture_(false),
       has_scrolled_(false),
       momentum_scroll_in_progress_(false),
       ignore_momentum_scrolls_(false),
       last_momentum_scroll_timestamp_(0),
-      snap_rubberband_timer_is_active_(false) {
+      snap_rubberband_timer_is_active_(false),
+      weak_factory_(this) {
 }
 
-bool ScrollElasticityController::HandleWheelEvent(
+InputScrollElasticityController::~InputScrollElasticityController() {
+  DCHECK(!client_);
+}
+
+base::WeakPtr<InputScrollElasticityController>
+InputScrollElasticityController::GetWeakPtr() {
+  if (client_)
+    return weak_factory_.GetWeakPtr();
+  return base::WeakPtr<InputScrollElasticityController>();
+}
+
+void InputScrollElasticityController::WillShutdown() {
+  weak_factory_.InvalidateWeakPtrs();
+  client_ = NULL;
+}
+
+void InputScrollElasticityController::Animate(base::TimeTicks time) {
+  if (!snap_rubberband_timer_is_active_)
+    return;
+
+  // TODO(ccameron): This should send the time parameter to the snap function,
+  // so that animation can be based on frame time, not arbitrarily-sampled
+  // clock time.
+  SnapRubberbandTimerFired();
+}
+
+void InputScrollElasticityController::ObserveWheelEventAndResult(
+    const blink::WebMouseWheelEvent& wheel_event,
+    const cc::InputHandlerScrollResult& scroll_result) {
+  // TODO(ccameron): Pull non-over-scrolling scroll logic out of
+  // HandleWheelEvent, and read the scroll result instead.
+  HandleWheelEvent(wheel_event);
+}
+
+bool InputScrollElasticityController::HandleWheelEvent(
     const blink::WebMouseWheelEvent& wheel_event) {
   if (wheel_event.phase == blink::WebMouseWheelEvent::PhaseMayBegin)
     return false;
 
   if (wheel_event.phase == blink::WebMouseWheelEvent::PhaseBegan) {
     in_scroll_gesture_ = true;
     has_scrolled_ = false;
     momentum_scroll_in_progress_ = false;
     ignore_momentum_scrolls_ = false;
     last_momentum_scroll_timestamp_ = 0;
@@ skipping 215 matching lines @@
 float RoundToDevicePixelTowardZero(float num) {
   float rounded_num = roundf(num);
   if (fabs(num - rounded_num) < 0.125)
     num = rounded_num;
 
   return RoundTowardZero(num);
 }
 
 }  // namespace
 
-void ScrollElasticityController::SnapRubberbandTimerFired() {
+void InputScrollElasticityController::SnapRubberbandTimerFired() {
   if (!momentum_scroll_in_progress_ || ignore_momentum_scrolls_) {
     float time_delta = (base::Time::Now() - start_time_).InSecondsF();
 
     if (start_stretch_ == gfx::Vector2dF()) {
       start_stretch_ = client_->StretchAmount();
       if (start_stretch_ == gfx::Vector2dF()) {
         StopSnapRubberbandTimer();
 
         stretch_scroll_force_ = gfx::Vector2dF();
         start_time_ = base::Time();
@@ skipping 43 matching lines @@
       start_stretch_ = gfx::Vector2dF();
       orig_origin_ = gfx::Vector2dF();
       orig_velocity_ = gfx::Vector2dF();
     }
   } else {
     start_time_ = base::Time::Now();
     start_stretch_ = gfx::Vector2dF();
   }
 }
 
-bool ScrollElasticityController::IsRubberbandInProgress() const {
+bool InputScrollElasticityController::IsRubberbandInProgress() const {
   if (!in_scroll_gesture_ && !momentum_scroll_in_progress_ &&
       !snap_rubberband_timer_is_active_)
     return false;
 
   return !client_->StretchAmount().IsZero();
 }
 
-void ScrollElasticityController::StopSnapRubberbandTimer() {
+void InputScrollElasticityController::StopSnapRubberbandTimer() {
   client_->StopSnapRubberbandTimer();
   snap_rubberband_timer_is_active_ = false;
 }
 
-void ScrollElasticityController::SnapRubberband() {
+void InputScrollElasticityController::SnapRubberband() {
   double time_delta = SystemUptime() - last_momentum_scroll_timestamp_;
   if (last_momentum_scroll_timestamp_ &&
       time_delta >= kScrollVelocityZeroingTimeout)
     momentum_velocity_ = gfx::Vector2dF();
 
   in_scroll_gesture_ = false;
 
   if (snap_rubberband_timer_is_active_)
     return;
 
   start_stretch_ = gfx::Vector2dF();
   orig_origin_ = gfx::Vector2dF();
   orig_velocity_ = gfx::Vector2dF();
 
   // If there's no momentum scroll or stretch amount, no need to start the
   // timer.
   if (!momentum_scroll_in_progress_ &&
       client_->StretchAmount() == gfx::Vector2dF()) {
     start_time_ = base::Time();
     stretch_scroll_force_ = gfx::Vector2dF();
     return;
   }
 
   start_time_ = base::Time::Now();
   client_->StartSnapRubberbandTimer();
   snap_rubberband_timer_is_active_ = true;
 }
 
-bool ScrollElasticityController::ShouldHandleEvent(
+bool InputScrollElasticityController::ShouldHandleEvent(
     const blink::WebMouseWheelEvent& wheel_event) {
   // Once any scrolling has happened, all future events should be handled.
   if (has_scrolled_)
     return true;
 
   // The event can't cause scrolling to start if its delta is 0.
   if (wheel_event.deltaX == 0 && wheel_event.deltaY == 0)
     return false;
 
   // If the client isn't pinned, then the event is guaranteed to cause
   // scrolling.
   if (!client_->PinnedInDirection(gfx::Vector2dF(-wheel_event.deltaX, 0)))
     return true;
 
   // If the event is pinned, then the client can't scroll, but it might rubber
   // band.
   // Check if the event allows rubber banding.
   if (wheel_event.deltaY == 0) {
     if (wheel_event.deltaX > 0 && !wheel_event.canRubberbandLeft)
       return false;
     if (wheel_event.deltaX < 0 && !wheel_event.canRubberbandRight)
       return false;
   }
 
   // The event is going to either cause scrolling or rubber banding.
   return true;
 }
 
 }  // namespace content