Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(78)

Side by Side Diff: webkit/child/touch_fling_gesture_curve.cc

Issue 52663003: Remove all fling related stuff from the renderer assuming that browser side Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2012 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 "webkit/child/touch_fling_gesture_curve.h"
6
7 #include <cmath>
8
9 #include "base/debug/trace_event.h"
10 #include "base/logging.h"
11 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
12 #include "third_party/WebKit/public/platform/WebFloatSize.h"
13 #include "third_party/WebKit/public/platform/WebGestureCurve.h"
14 #include "third_party/WebKit/public/platform/WebGestureCurveTarget.h"
15 #include "third_party/WebKit/public/platform/WebSize.h"
16
17 using WebKit::WebFloatPoint;
18 using WebKit::WebFloatSize;
19 using WebKit::WebGestureCurve;
20 using WebKit::WebGestureCurveTarget;
21 using WebKit::WebSize;
22
23 namespace {
24
25 const char* kCurveName = "TouchFlingGestureCurve";
26
27 inline double position(double t, float* p) {
28 return p[0] * exp(-p[2] * t) - p[1] * t - p[0];
29 }
30
31 inline double velocity(double t, float* p) {
32 return -p[0] * p[2] * exp(-p[2] * t) - p[1];
33 }
34
35 inline double timeAtVelocity(double v, float* p) {
36 DCHECK(p[0]);
37 DCHECK(p[2]);
38 return -log((v + p[1]) / (-p[0] * p[2])) / p[2];
39 }
40
41 } // namespace
42
43
44 namespace webkit_glue {
45
46 // This curve implementation is based on the notion of a single, absolute
47 // curve, which starts at a large velocity and smoothly decreases to
48 // zero. For a given input velocity, we find where on the curve this
49 // velocity occurs, and start the animation at this point---denoted by
50 // (time_offset_, position_offset_).
51 //
52 // This has the effect of automatically determining an animation duration
53 // that scales with input velocity, as faster initial velocities start
54 // earlier on the curve and thus take longer to reach the end. No
55 // complicated time scaling is required.
56 //
57 // Since the starting velocity is implicitly determined by our starting
58 // point, we only store the relative magnitude and direction of both
59 // initial x- and y-velocities, and use this to scale the computed
60 // displacement at any point in time. This guarantees that fling
61 // trajectories are straight lines when viewed in x-y space. Initial
62 // velocities that lie outside the max velocity are constrained to start
63 // at zero (and thus are implicitly scaled).
64 //
65 // The curve is modelled as a 4th order polynomial, starting at t = 0,
66 // and ending at t = curve_duration_. Attempts to generate
67 // position/velocity estimates outside this range are undefined.
68
69 WebGestureCurve* TouchFlingGestureCurve::Create(
70 const WebFloatPoint& initial_velocity,
71 float p0,
72 float p1,
73 float p2,
74 const WebSize& cumulative_scroll) {
75 return new TouchFlingGestureCurve(initial_velocity, p0, p1, p2,
76 cumulative_scroll);
77 }
78
79 TouchFlingGestureCurve::TouchFlingGestureCurve(
80 const WebFloatPoint& initial_velocity,
81 float alpha,
82 float beta,
83 float gamma,
84 const WebSize& cumulative_scroll)
85 : cumulative_scroll_(WebFloatSize(cumulative_scroll.width,
86 cumulative_scroll.height)) {
87 DCHECK(initial_velocity != WebFloatPoint());
88
89 coefficients_[0] = alpha;
90 coefficients_[1] = beta;
91 coefficients_[2] = gamma;
92
93 // Curve ends when velocity reaches zero.
94 curve_duration_ = timeAtVelocity(0, coefficients_);
95 DCHECK(curve_duration_ > 0);
96
97 float max_start_velocity = std::max(fabs(initial_velocity.x),
98 fabs(initial_velocity.y));
99
100 // Force max_start_velocity to lie in the range v(0) to v(curve_duration),
101 // and assume that the curve parameters define a monotonically decreasing
102 // velocity, or else bisection search may fail.
103 if (max_start_velocity > velocity(0, coefficients_))
104 max_start_velocity = velocity(0, coefficients_);
105
106 if (max_start_velocity < 0)
107 max_start_velocity = 0;
108
109 // We keep track of relative magnitudes and directions of the
110 // velocity/displacement components here.
111 displacement_ratio_ = WebFloatPoint(initial_velocity.x / max_start_velocity,
112 initial_velocity.y / max_start_velocity);
113
114 // Compute time-offset for start velocity.
115 time_offset_ = timeAtVelocity(max_start_velocity, coefficients_);
116
117 // Compute curve position at offset time
118 position_offset_ = position(time_offset_, coefficients_);
119 TRACE_EVENT_ASYNC_BEGIN1("input", "GestureAnimation", this, "curve",
120 kCurveName);
121 }
122
123 TouchFlingGestureCurve::~TouchFlingGestureCurve() {
124 TRACE_EVENT_ASYNC_END0("input", "GestureAnimation", this);
125 }
126
127 bool TouchFlingGestureCurve::apply(double time, WebGestureCurveTarget* target) {
128 float displacement;
129 float speed;
130 if (time < 0) {
131 displacement = 0.f;
132 speed = 0.f;
133 } else if (time + time_offset_ < curve_duration_) {
134 displacement =
135 position(time + time_offset_, coefficients_) - position_offset_;
136 speed = velocity(time + time_offset_, coefficients_);
137 } else {
138 displacement = position(curve_duration_, coefficients_) - position_offset_;
139 speed = 0.f;
140 }
141
142 // Keep track of integer portion of scroll thus far, and prepare increment.
143 WebFloatSize scroll(displacement * displacement_ratio_.x,
144 displacement * displacement_ratio_.y);
145 WebFloatSize scroll_increment(scroll.width - cumulative_scroll_.width,
146 scroll.height - cumulative_scroll_.height);
147 WebFloatSize scroll_velocity(speed * displacement_ratio_.x,
148 speed * displacement_ratio_.y);
149 cumulative_scroll_ = scroll;
150
151 if (time + time_offset_ < curve_duration_ ||
152 scroll_increment != WebFloatSize()) {
153 target->notifyCurrentFlingVelocity(scroll_velocity);
154 // scrollBy() could delete this curve if the animation is over, so don't
155 // touch any member variables after making that call.
156 target->scrollBy(scroll_increment);
157 return true;
158 }
159
160 return false;
161 }
162
163 } // namespace webkit_glue
OLDNEW
« no previous file with comments | « webkit/child/touch_fling_gesture_curve.h ('k') | webkit/child/webkitplatformsupport_child_impl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698