| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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_scroll_elasticity_controller.h" | |
| 6 | |
| 7 #include <math.h> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "cc/input/input_handler.h" | |
| 11 #include "ui/gfx/geometry/vector2d_conversions.h" | |
| 12 | |
| 13 // InputScrollElasticityController is based on | |
| 14 // WebKit/Source/platform/mac/InputScrollElasticityController.mm | |
| 15 /* | |
| 16 * Copyright (C) 2011 Apple Inc. All rights reserved. | |
| 17 * | |
| 18 * Redistribution and use in source and binary forms, with or without | |
| 19 * modification, are permitted provided that the following conditions | |
| 20 * are met: | |
| 21 * 1. Redistributions of source code must retain the above copyright | |
| 22 * notice, this list of conditions and the following disclaimer. | |
| 23 * 2. Redistributions in binary form must reproduce the above copyright | |
| 24 * notice, this list of conditions and the following disclaimer in the | |
| 25 * documentation and/or other materials provided with the distribution. | |
| 26 * | |
| 27 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' | |
| 28 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, | |
| 29 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS | |
| 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
| 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
| 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
| 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
| 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | |
| 37 * THE POSSIBILITY OF SUCH DAMAGE. | |
| 38 */ | |
| 39 | |
| 40 namespace content { | |
| 41 | |
| 42 namespace { | |
| 43 | |
| 44 const float kScrollVelocityZeroingTimeout = 0.10f; | |
| 45 const float kRubberbandMinimumRequiredDeltaBeforeStretch = 10; | |
| 46 | |
| 47 const float kRubberbandStiffness = 20; | |
| 48 const float kRubberbandAmplitude = 0.31f; | |
| 49 const float kRubberbandPeriod = 1.6f; | |
| 50 | |
| 51 // For these functions which compute the stretch amount, always return a | |
| 52 // rounded value, instead of a floating-point value. The reason for this is | |
| 53 // that Blink's scrolling can become erratic with fractional scroll amounts (in | |
| 54 // particular, if you have a scroll offset of 0.5, Blink will never actually | |
| 55 // bring that value back to 0, which breaks the logic used to determine if a | |
| 56 // layer is pinned in a direction). | |
| 57 | |
| 58 gfx::Vector2d StretchAmountForTimeDelta(const gfx::Vector2dF& initial_position, | |
| 59 const gfx::Vector2dF& initial_velocity, | |
| 60 float elapsed_time) { | |
| 61 // Compute the stretch amount at a given time after some initial conditions. | |
| 62 // Do this by first computing an intermediary position given the initial | |
| 63 // position, initial velocity, time elapsed, and no external forces. Then | |
| 64 // take the intermediary position and damp it towards zero by multiplying | |
| 65 // against a negative exponential. | |
| 66 float amplitude = kRubberbandAmplitude; | |
| 67 float period = kRubberbandPeriod; | |
| 68 float critical_dampening_factor = | |
| 69 expf((-elapsed_time * kRubberbandStiffness) / period); | |
| 70 | |
| 71 return gfx::ToRoundedVector2d(gfx::ScaleVector2d( | |
| 72 initial_position + | |
| 73 gfx::ScaleVector2d(initial_velocity, elapsed_time * amplitude), | |
| 74 critical_dampening_factor)); | |
| 75 } | |
| 76 | |
| 77 gfx::Vector2d StretchAmountForReboundDelta(const gfx::Vector2dF& delta) { | |
| 78 float stiffness = std::max(kRubberbandStiffness, 1.0f); | |
| 79 return gfx::ToRoundedVector2d(gfx::ScaleVector2d(delta, 1.0f / stiffness)); | |
| 80 } | |
| 81 | |
| 82 gfx::Vector2d StretchScrollForceForStretchAmount(const gfx::Vector2dF& delta) { | |
| 83 return gfx::ToRoundedVector2d( | |
| 84 gfx::ScaleVector2d(delta, kRubberbandStiffness)); | |
| 85 } | |
| 86 | |
| 87 } // namespace | |
| 88 | |
| 89 InputScrollElasticityController::InputScrollElasticityController( | |
| 90 cc::ScrollElasticityHelper* helper) | |
| 91 : helper_(helper), | |
| 92 state_(kStateInactive), | |
| 93 momentum_animation_reset_at_next_frame_(false), | |
| 94 weak_factory_(this) { | |
| 95 } | |
| 96 | |
| 97 InputScrollElasticityController::~InputScrollElasticityController() { | |
| 98 } | |
| 99 | |
| 100 base::WeakPtr<InputScrollElasticityController> | |
| 101 InputScrollElasticityController::GetWeakPtr() { | |
| 102 if (helper_) | |
| 103 return weak_factory_.GetWeakPtr(); | |
| 104 return base::WeakPtr<InputScrollElasticityController>(); | |
| 105 } | |
| 106 | |
| 107 void InputScrollElasticityController::ObserveWheelEventAndResult( | |
| 108 const blink::WebMouseWheelEvent& wheel_event, | |
| 109 const cc::InputHandlerScrollResult& scroll_result) { | |
| 110 // We should only get PhaseMayBegin or PhaseBegan events while in the | |
| 111 // Inactive or MomentumAnimated states, but in case we get bad input (e.g, | |
| 112 // abbreviated by tab-switch), always re-set the state to ActiveScrolling | |
| 113 // when those events are received. | |
| 114 if (wheel_event.phase == blink::WebMouseWheelEvent::PhaseMayBegin || | |
| 115 wheel_event.phase == blink::WebMouseWheelEvent::PhaseBegan) { | |
| 116 scroll_velocity = gfx::Vector2dF(); | |
| 117 last_scroll_event_timestamp_ = base::TimeTicks(); | |
| 118 state_ = kStateActiveScroll; | |
| 119 pending_overscroll_delta_ = gfx::Vector2dF(); | |
| 120 return; | |
| 121 } | |
| 122 | |
| 123 gfx::Vector2dF event_delta(-wheel_event.deltaX, -wheel_event.deltaY); | |
| 124 base::TimeTicks event_timestamp = | |
| 125 base::TimeTicks() + | |
| 126 base::TimeDelta::FromSecondsD(wheel_event.timeStampSeconds); | |
| 127 switch (state_) { | |
| 128 case kStateInactive: { | |
| 129 // The PhaseMayBegin and PhaseBegan cases are handled at the top of the | |
| 130 // function. | |
| 131 if (wheel_event.momentumPhase == blink::WebMouseWheelEvent::PhaseBegan) | |
| 132 state_ = kStateMomentumScroll; | |
| 133 break; | |
| 134 } | |
| 135 case kStateActiveScroll: | |
| 136 if (wheel_event.phase == blink::WebMouseWheelEvent::PhaseChanged) { | |
| 137 UpdateVelocity(event_delta, event_timestamp); | |
| 138 Overscroll(event_delta, scroll_result.unused_scroll_delta); | |
| 139 } else if (wheel_event.phase == blink::WebMouseWheelEvent::PhaseEnded || | |
| 140 wheel_event.phase == | |
| 141 blink::WebMouseWheelEvent::PhaseCancelled) { | |
| 142 if (helper_->StretchAmount().IsZero()) { | |
| 143 EnterStateInactive(); | |
| 144 } else { | |
| 145 EnterStateMomentumAnimated(event_timestamp); | |
| 146 } | |
| 147 } | |
| 148 break; | |
| 149 case kStateMomentumScroll: | |
| 150 if (wheel_event.momentumPhase == | |
| 151 blink::WebMouseWheelEvent::PhaseChanged) { | |
| 152 UpdateVelocity(event_delta, event_timestamp); | |
| 153 Overscroll(event_delta, scroll_result.unused_scroll_delta); | |
| 154 if (!helper_->StretchAmount().IsZero()) { | |
| 155 EnterStateMomentumAnimated(event_timestamp); | |
| 156 } | |
| 157 } else if (wheel_event.momentumPhase == | |
| 158 blink::WebMouseWheelEvent::PhaseEnded) { | |
| 159 EnterStateInactive(); | |
| 160 } | |
| 161 case kStateMomentumAnimated: | |
| 162 // The PhaseMayBegin and PhaseBegan cases are handled at the top of the | |
| 163 // function. | |
| 164 break; | |
| 165 } | |
| 166 } | |
| 167 | |
| 168 void InputScrollElasticityController::UpdateVelocity( | |
| 169 const gfx::Vector2dF& event_delta, | |
| 170 const base::TimeTicks& event_timestamp) { | |
| 171 float time_delta = | |
| 172 (event_timestamp - last_scroll_event_timestamp_).InSecondsF(); | |
| 173 if (time_delta < kScrollVelocityZeroingTimeout && time_delta > 0) { | |
| 174 scroll_velocity = gfx::Vector2dF(event_delta.x() / time_delta, | |
| 175 event_delta.y() / time_delta); | |
| 176 } else { | |
| 177 scroll_velocity = gfx::Vector2dF(); | |
| 178 } | |
| 179 last_scroll_event_timestamp_ = event_timestamp; | |
| 180 } | |
| 181 | |
| 182 void InputScrollElasticityController::Overscroll( | |
| 183 const gfx::Vector2dF& input_delta, | |
| 184 const gfx::Vector2dF& overscroll_delta) { | |
| 185 // The effect can be dynamically disabled by setting disallowing user | |
| 186 // scrolling. When disabled, disallow active or momentum overscrolling, but | |
| 187 // allow any current overscroll to animate back. | |
| 188 if (!helper_->IsUserScrollable()) | |
| 189 return; | |
| 190 | |
| 191 gfx::Vector2dF adjusted_overscroll_delta = | |
| 192 pending_overscroll_delta_ + overscroll_delta; | |
| 193 pending_overscroll_delta_ = gfx::Vector2dF(); | |
| 194 | |
| 195 // Only allow one direction to overscroll at a time, and slightly prefer | |
| 196 // scrolling vertically by applying the equal case to delta_y. | |
| 197 if (fabsf(input_delta.y()) >= fabsf(input_delta.x())) | |
| 198 adjusted_overscroll_delta.set_x(0); | |
| 199 else | |
| 200 adjusted_overscroll_delta.set_y(0); | |
| 201 | |
| 202 // Don't allow overscrolling in a direction where scrolling is possible. | |
| 203 if (!PinnedHorizontally(adjusted_overscroll_delta.x())) | |
| 204 adjusted_overscroll_delta.set_x(0); | |
| 205 if (!PinnedVertically(adjusted_overscroll_delta.y())) { | |
| 206 adjusted_overscroll_delta.set_y(0); | |
| 207 } | |
| 208 | |
| 209 // Require a minimum of 10 units of overscroll before starting the rubber-band | |
| 210 // stretch effect, so that small stray motions don't trigger it. If that | |
| 211 // minimum isn't met, save what remains in |pending_overscroll_delta_| for | |
| 212 // the next event. | |
| 213 gfx::Vector2dF old_stretch_amount = helper_->StretchAmount(); | |
| 214 gfx::Vector2dF stretch_scroll_force_delta; | |
| 215 if (old_stretch_amount.x() != 0 || | |
| 216 fabsf(adjusted_overscroll_delta.x()) >= | |
| 217 kRubberbandMinimumRequiredDeltaBeforeStretch) { | |
| 218 stretch_scroll_force_delta.set_x(adjusted_overscroll_delta.x()); | |
| 219 } else { | |
| 220 pending_overscroll_delta_.set_x(adjusted_overscroll_delta.x()); | |
| 221 } | |
| 222 if (old_stretch_amount.y() != 0 || | |
| 223 fabsf(adjusted_overscroll_delta.y()) >= | |
| 224 kRubberbandMinimumRequiredDeltaBeforeStretch) { | |
| 225 stretch_scroll_force_delta.set_y(adjusted_overscroll_delta.y()); | |
| 226 } else { | |
| 227 pending_overscroll_delta_.set_y(adjusted_overscroll_delta.y()); | |
| 228 } | |
| 229 | |
| 230 // Update the stretch amount according to the spring equations. | |
| 231 if (stretch_scroll_force_delta.IsZero()) | |
| 232 return; | |
| 233 stretch_scroll_force_ += stretch_scroll_force_delta; | |
| 234 gfx::Vector2dF new_stretch_amount = | |
| 235 StretchAmountForReboundDelta(stretch_scroll_force_); | |
| 236 helper_->SetStretchAmount(new_stretch_amount); | |
| 237 } | |
| 238 | |
| 239 void InputScrollElasticityController::EnterStateInactive() { | |
| 240 DCHECK_NE(kStateInactive, state_); | |
| 241 DCHECK(helper_->StretchAmount().IsZero()); | |
| 242 state_ = kStateInactive; | |
| 243 stretch_scroll_force_ = gfx::Vector2dF(); | |
| 244 } | |
| 245 | |
| 246 void InputScrollElasticityController::EnterStateMomentumAnimated( | |
| 247 const base::TimeTicks& triggering_event_timestamp) { | |
| 248 DCHECK_NE(kStateMomentumAnimated, state_); | |
| 249 state_ = kStateMomentumAnimated; | |
| 250 | |
| 251 momentum_animation_start_time_ = triggering_event_timestamp; | |
| 252 momentum_animation_initial_stretch_ = helper_->StretchAmount(); | |
| 253 momentum_animation_initial_velocity_ = scroll_velocity; | |
| 254 momentum_animation_reset_at_next_frame_ = false; | |
| 255 | |
| 256 // Similarly to the logic in Overscroll, prefer vertical scrolling to | |
| 257 // horizontal scrolling. | |
| 258 if (fabsf(momentum_animation_initial_velocity_.y()) >= | |
| 259 fabsf(momentum_animation_initial_velocity_.x())) | |
| 260 momentum_animation_initial_velocity_.set_x(0); | |
| 261 | |
| 262 if (!CanScrollHorizontally()) | |
| 263 momentum_animation_initial_velocity_.set_x(0); | |
| 264 | |
| 265 if (!CanScrollVertically()) | |
| 266 momentum_animation_initial_velocity_.set_y(0); | |
| 267 | |
| 268 helper_->RequestAnimate(); | |
| 269 } | |
| 270 | |
| 271 void InputScrollElasticityController::Animate(base::TimeTicks time) { | |
| 272 if (state_ != kStateMomentumAnimated) | |
| 273 return; | |
| 274 | |
| 275 if (momentum_animation_reset_at_next_frame_) { | |
| 276 momentum_animation_start_time_ = time; | |
| 277 momentum_animation_initial_stretch_ = helper_->StretchAmount(); | |
| 278 momentum_animation_initial_velocity_ = gfx::Vector2dF(); | |
| 279 momentum_animation_reset_at_next_frame_ = false; | |
| 280 } | |
| 281 | |
| 282 float time_delta = | |
| 283 std::max((time - momentum_animation_start_time_).InSecondsF(), 0.0); | |
| 284 | |
| 285 gfx::Vector2dF old_stretch_amount = helper_->StretchAmount(); | |
| 286 gfx::Vector2dF new_stretch_amount = StretchAmountForTimeDelta( | |
| 287 momentum_animation_initial_stretch_, momentum_animation_initial_velocity_, | |
| 288 time_delta); | |
| 289 gfx::Vector2dF stretch_delta = new_stretch_amount - old_stretch_amount; | |
| 290 | |
| 291 // If the new stretch amount is near zero, set it directly to zero and enter | |
| 292 // the inactive state. | |
| 293 if (fabs(new_stretch_amount.x()) < 1 && fabs(new_stretch_amount.y()) < 1) { | |
| 294 helper_->SetStretchAmount(gfx::Vector2dF()); | |
| 295 EnterStateInactive(); | |
| 296 return; | |
| 297 } | |
| 298 | |
| 299 // If we are not pinned in the direction of the delta, then the delta is only | |
| 300 // allowed to decrease the existing stretch -- it cannot increase a stretch | |
| 301 // until it is pinned. | |
| 302 if (!PinnedHorizontally(stretch_delta.x())) { | |
| 303 if (stretch_delta.x() > 0 && old_stretch_amount.x() < 0) | |
| 304 stretch_delta.set_x(std::min(stretch_delta.x(), -old_stretch_amount.x())); | |
| 305 else if (stretch_delta.x() < 0 && old_stretch_amount.x() > 0) | |
| 306 stretch_delta.set_x(std::max(stretch_delta.x(), -old_stretch_amount.x())); | |
| 307 else | |
| 308 stretch_delta.set_x(0); | |
| 309 } | |
| 310 if (!PinnedVertically(stretch_delta.y())) { | |
| 311 if (stretch_delta.y() > 0 && old_stretch_amount.y() < 0) | |
| 312 stretch_delta.set_y(std::min(stretch_delta.y(), -old_stretch_amount.y())); | |
| 313 else if (stretch_delta.y() < 0 && old_stretch_amount.y() > 0) | |
| 314 stretch_delta.set_y(std::max(stretch_delta.y(), -old_stretch_amount.y())); | |
| 315 else | |
| 316 stretch_delta.set_y(0); | |
| 317 } | |
| 318 new_stretch_amount = old_stretch_amount + stretch_delta; | |
| 319 | |
| 320 stretch_scroll_force_ = | |
| 321 StretchScrollForceForStretchAmount(new_stretch_amount); | |
| 322 helper_->SetStretchAmount(new_stretch_amount); | |
| 323 helper_->RequestAnimate(); | |
| 324 } | |
| 325 | |
| 326 bool InputScrollElasticityController::PinnedHorizontally( | |
| 327 float direction) const { | |
| 328 gfx::ScrollOffset scroll_offset = helper_->ScrollOffset(); | |
| 329 gfx::ScrollOffset max_scroll_offset = helper_->MaxScrollOffset(); | |
| 330 if (direction < 0) | |
| 331 return scroll_offset.x() <= 0; | |
| 332 if (direction > 0) | |
| 333 return scroll_offset.x() >= max_scroll_offset.x(); | |
| 334 return false; | |
| 335 } | |
| 336 | |
| 337 bool InputScrollElasticityController::PinnedVertically(float direction) const { | |
| 338 gfx::ScrollOffset scroll_offset = helper_->ScrollOffset(); | |
| 339 gfx::ScrollOffset max_scroll_offset = helper_->MaxScrollOffset(); | |
| 340 if (direction < 0) | |
| 341 return scroll_offset.y() <= 0; | |
| 342 if (direction > 0) | |
| 343 return scroll_offset.y() >= max_scroll_offset.y(); | |
| 344 return false; | |
| 345 } | |
| 346 | |
| 347 bool InputScrollElasticityController::CanScrollHorizontally() const { | |
| 348 return helper_->MaxScrollOffset().x() > 0; | |
| 349 } | |
| 350 | |
| 351 bool InputScrollElasticityController::CanScrollVertically() const { | |
| 352 return helper_->MaxScrollOffset().y() > 0; | |
| 353 } | |
| 354 | |
| 355 void InputScrollElasticityController::ReconcileStretchAndScroll() { | |
| 356 gfx::Vector2dF stretch = helper_->StretchAmount(); | |
| 357 if (stretch.IsZero()) | |
| 358 return; | |
| 359 | |
| 360 gfx::ScrollOffset scroll_offset = helper_->ScrollOffset(); | |
| 361 gfx::ScrollOffset max_scroll_offset = helper_->MaxScrollOffset(); | |
| 362 | |
| 363 // Compute stretch_adjustment which will be added to |stretch| and subtracted | |
| 364 // from the |scroll_offset|. | |
| 365 gfx::Vector2dF stretch_adjustment; | |
| 366 if (stretch.x() < 0 && scroll_offset.x() > 0) { | |
| 367 stretch_adjustment.set_x( | |
| 368 std::min(-stretch.x(), static_cast<float>(scroll_offset.x()))); | |
| 369 } | |
| 370 if (stretch.x() > 0 && scroll_offset.x() < max_scroll_offset.x()) { | |
| 371 stretch_adjustment.set_x(std::max( | |
| 372 -stretch.x(), | |
| 373 static_cast<float>(scroll_offset.x() - max_scroll_offset.x()))); | |
| 374 } | |
| 375 if (stretch.y() < 0 && scroll_offset.y() > 0) { | |
| 376 stretch_adjustment.set_y( | |
| 377 std::min(-stretch.y(), static_cast<float>(scroll_offset.y()))); | |
| 378 } | |
| 379 if (stretch.y() > 0 && scroll_offset.y() < max_scroll_offset.y()) { | |
| 380 stretch_adjustment.set_y(std::max( | |
| 381 -stretch.y(), | |
| 382 static_cast<float>(scroll_offset.y() - max_scroll_offset.y()))); | |
| 383 } | |
| 384 | |
| 385 if (stretch_adjustment.IsZero()) | |
| 386 return; | |
| 387 | |
| 388 gfx::Vector2dF new_stretch_amount = stretch + stretch_adjustment; | |
| 389 helper_->ScrollBy(-stretch_adjustment); | |
| 390 helper_->SetStretchAmount(new_stretch_amount); | |
| 391 | |
| 392 // Update the internal state for the active scroll or animation to avoid | |
| 393 // discontinuities. | |
| 394 switch (state_) { | |
| 395 case kStateActiveScroll: | |
| 396 stretch_scroll_force_ = | |
| 397 StretchScrollForceForStretchAmount(new_stretch_amount); | |
| 398 break; | |
| 399 case kStateMomentumAnimated: | |
| 400 momentum_animation_reset_at_next_frame_ = true; | |
| 401 break; | |
| 402 default: | |
| 403 // These cases should not be hit because the stretch must be zero in the | |
| 404 // Inactive and MomentumScroll states. | |
| 405 NOTREACHED(); | |
| 406 break; | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1415953004:
Move content/renderer input handling for web input events to ui (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master