WinCairo build fails to link.
[WebKit-https.git] / Source / WebKit / chromium / src / WebCompositorInputHandlerImpl.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #include "WebCompositorInputHandlerImpl.h"
29
30 #include "TraceEvent.h"
31 #include "WebCompositorInputHandlerClient.h"
32 #include "WebInputEvent.h"
33 #include <public/Platform.h>
34 #include <public/WebInputHandlerClient.h>
35 #include <wtf/PassOwnPtr.h>
36 #include <wtf/ThreadingPrimitives.h>
37
38 using namespace WebCore;
39
40 namespace WebKit {
41
42 // These statics may only be accessed from the compositor thread.
43 int WebCompositorInputHandlerImpl::s_nextAvailableIdentifier = 1;
44 HashSet<WebCompositorInputHandlerImpl*>* WebCompositorInputHandlerImpl::s_compositors = 0;
45
46 WebCompositorInputHandler* WebCompositorInputHandler::fromIdentifier(int identifier)
47 {
48     return WebCompositorInputHandlerImpl::fromIdentifier(identifier);
49 }
50
51 WebCompositorInputHandler* WebCompositorInputHandlerImpl::fromIdentifier(int identifier)
52 {
53
54     if (!s_compositors)
55         return 0;
56
57     for (HashSet<WebCompositorInputHandlerImpl*>::iterator it = s_compositors->begin(); it != s_compositors->end(); ++it) {
58         if ((*it)->identifier() == identifier)
59             return *it;
60     }
61     return 0;
62 }
63
64 WebCompositorInputHandlerImpl::WebCompositorInputHandlerImpl()
65     : m_client(0)
66     , m_identifier(s_nextAvailableIdentifier++)
67     , m_inputHandlerClient(0)
68 #ifndef NDEBUG
69     , m_expectScrollUpdateEnd(false)
70     , m_expectPinchUpdateEnd(false)
71 #endif
72     , m_gestureScrollOnImplThread(false)
73     , m_gesturePinchOnImplThread(false)
74     , m_flingActiveOnMainThread(false)
75 {
76 }
77
78 WebCompositorInputHandlerImpl::~WebCompositorInputHandlerImpl()
79 {
80     if (m_client)
81         m_client->willShutdown();
82
83     ASSERT(s_compositors);
84     s_compositors->remove(this);
85     if (!s_compositors->size()) {
86         delete s_compositors;
87         s_compositors = 0;
88     }
89 }
90
91 void WebCompositorInputHandlerImpl::setClient(WebCompositorInputHandlerClient* client)
92 {
93     // It's valid to set a new client if we've never had one or to clear the client, but it's not valid to change from having one client to a different one.
94     ASSERT(!m_client || !client);
95     m_client = client;
96 }
97
98 void WebCompositorInputHandlerImpl::handleInputEvent(const WebInputEvent& event)
99 {
100     ASSERT(m_client);
101
102     WebCompositorInputHandlerImpl::EventDisposition disposition = handleInputEventInternal(event);
103     switch (disposition) {
104     case DidHandle:
105         m_client->didHandleInputEvent();
106         break;
107     case DidNotHandle:
108         m_client->didNotHandleInputEvent(true /* sendToWidget */);
109         break;
110     case DropEvent:
111         m_client->didNotHandleInputEvent(false /* sendToWidget */);
112         break;
113     }
114     if (event.modifiers & WebInputEvent::IsLastInputEventForCurrentVSync)
115         m_inputHandlerClient->didReceiveLastInputEventForVSync();
116 }
117
118 WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleInputEventInternal(const WebInputEvent& event)
119 {
120     if (event.type == WebInputEvent::MouseWheel) {
121         const WebMouseWheelEvent& wheelEvent = *static_cast<const WebMouseWheelEvent*>(&event);
122         WebInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(WebPoint(wheelEvent.x, wheelEvent.y), WebInputHandlerClient::ScrollInputTypeWheel);
123         switch (scrollStatus) {
124         case WebInputHandlerClient::ScrollStatusStarted: {
125             TRACE_EVENT_INSTANT2("webkit", "WebCompositorInputHandlerImpl::handleInput wheel scroll", "deltaX", -wheelEvent.deltaX, "deltaY", -wheelEvent.deltaY);
126             bool didScroll = false;
127             if (wheelEvent.scrollByPage) {
128                 ASSERT(!wheelEvent.deltaX);
129                 WebScrollbar::ScrollDirection direction = (wheelEvent.deltaY < 0) ? WebScrollbar::ScrollForward : WebScrollbar::ScrollBackward;
130                 didScroll = m_inputHandlerClient->scrollVerticallyByPageIfPossible(WebPoint(wheelEvent.x, wheelEvent.y), direction);
131             } else
132                 didScroll = m_inputHandlerClient->scrollByIfPossible(WebPoint(wheelEvent.x, wheelEvent.y), WebFloatSize(-wheelEvent.deltaX, -wheelEvent.deltaY));
133             m_inputHandlerClient->scrollEnd();
134             return didScroll ? DidHandle : DropEvent;
135         }
136         case WebInputHandlerClient::ScrollStatusIgnored:
137             // FIXME: This should be DropEvent, but in cases where we fail to properly sync scrollability it's safer to send the
138             // event to the main thread. Change back to DropEvent once we have synchronization bugs sorted out.
139             return DidNotHandle; 
140         case WebInputHandlerClient::ScrollStatusOnMainThread:
141             return DidNotHandle;
142         }
143     } else if (event.type == WebInputEvent::GestureScrollBegin) {
144         ASSERT(!m_gestureScrollOnImplThread);
145         ASSERT(!m_expectScrollUpdateEnd);
146 #ifndef NDEBUG
147         m_expectScrollUpdateEnd = true;
148 #endif
149         const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event);
150         WebInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(WebPoint(gestureEvent.x, gestureEvent.y), WebInputHandlerClient::ScrollInputTypeGesture);
151         switch (scrollStatus) {
152         case WebInputHandlerClient::ScrollStatusStarted:
153             m_gestureScrollOnImplThread = true;
154             return DidHandle;
155         case WebInputHandlerClient::ScrollStatusOnMainThread:
156             return DidNotHandle;
157         case WebInputHandlerClient::ScrollStatusIgnored:
158             return DropEvent;
159         }
160     } else if (event.type == WebInputEvent::GestureScrollUpdate) {
161         ASSERT(m_expectScrollUpdateEnd);
162
163         if (!m_gestureScrollOnImplThread && !m_gesturePinchOnImplThread)
164             return DidNotHandle;
165
166         const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event);
167         bool didScroll = m_inputHandlerClient->scrollByIfPossible(WebPoint(gestureEvent.x, gestureEvent.y),
168             WebFloatSize(-gestureEvent.data.scrollUpdate.deltaX, -gestureEvent.data.scrollUpdate.deltaY));
169         return didScroll ? DidHandle : DropEvent;
170     } else if (event.type == WebInputEvent::GestureScrollEnd) {
171         ASSERT(m_expectScrollUpdateEnd);
172 #ifndef NDEBUG
173         m_expectScrollUpdateEnd = false;
174 #endif
175         if (!m_gestureScrollOnImplThread)
176             return DidNotHandle;
177
178         m_inputHandlerClient->scrollEnd();
179         m_gestureScrollOnImplThread = false;
180         return DidHandle;
181     } else if (event.type == WebInputEvent::GesturePinchBegin) {
182         ASSERT(!m_expectPinchUpdateEnd);
183 #ifndef NDEBUG
184         m_expectPinchUpdateEnd = true;
185 #endif
186         m_inputHandlerClient->pinchGestureBegin();
187         m_gesturePinchOnImplThread = true;
188         return DidHandle;
189     } else if (event.type == WebInputEvent::GesturePinchEnd) {
190         ASSERT(m_expectPinchUpdateEnd);
191 #ifndef NDEBUG
192         m_expectPinchUpdateEnd = false;
193 #endif
194         m_gesturePinchOnImplThread = false;
195         m_inputHandlerClient->pinchGestureEnd();
196         return DidHandle;
197     } else if (event.type == WebInputEvent::GesturePinchUpdate) {
198         ASSERT(m_expectPinchUpdateEnd);
199         const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event);
200         m_inputHandlerClient->pinchGestureUpdate(gestureEvent.data.pinchUpdate.scale, WebPoint(gestureEvent.x, gestureEvent.y));
201         return DidHandle;
202     } else if (event.type == WebInputEvent::GestureFlingStart) {
203         const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event);
204         return handleGestureFling(gestureEvent);
205     } else if (event.type == WebInputEvent::GestureFlingCancel) {
206         if (cancelCurrentFling())
207             return DidHandle;
208         else if (!m_flingActiveOnMainThread)
209             return DropEvent;
210 #if ENABLE(TOUCH_EVENT_TRACKING)
211     } else if (event.type == WebInputEvent::TouchStart) {
212         const WebTouchEvent& touchEvent = *static_cast<const WebTouchEvent*>(&event);
213         if (!m_inputHandlerClient->haveTouchEventHandlersAt(touchEvent.touches[0].position))
214             return DropEvent;
215 #endif
216     } else if (WebInputEvent::isKeyboardEventType(event.type)) {
217          cancelCurrentFling();
218     }
219
220     return DidNotHandle;
221 }
222
223 WebCompositorInputHandlerImpl::EventDisposition WebCompositorInputHandlerImpl::handleGestureFling(const WebGestureEvent& gestureEvent)
224 {
225     WebInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(WebPoint(gestureEvent.x, gestureEvent.y), WebInputHandlerClient::ScrollInputTypeNonBubblingGesture);
226     switch (scrollStatus) {
227     case WebInputHandlerClient::ScrollStatusStarted: {
228         if (gestureEvent.sourceDevice == WebGestureEvent::Touchpad)
229             m_inputHandlerClient->scrollEnd();
230         m_flingCurve = adoptPtr(Platform::current()->createFlingAnimationCurve(gestureEvent.sourceDevice, WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY), WebSize()));
231         TRACE_EVENT_ASYNC_BEGIN0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::started", this);
232         m_flingParameters.delta = WebFloatPoint(gestureEvent.data.flingStart.velocityX, gestureEvent.data.flingStart.velocityY);
233         m_flingParameters.point = WebPoint(gestureEvent.x, gestureEvent.y);
234         m_flingParameters.globalPoint = WebPoint(gestureEvent.globalX, gestureEvent.globalY);
235         m_flingParameters.modifiers = gestureEvent.modifiers;
236         m_flingParameters.sourceDevice = gestureEvent.sourceDevice;
237         m_inputHandlerClient->scheduleAnimation();
238         return DidHandle;
239     }
240     case WebInputHandlerClient::ScrollStatusOnMainThread: {
241         TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::scrollOnMainThread");
242         m_flingActiveOnMainThread =  true;
243         return DidNotHandle;
244     }
245     case WebInputHandlerClient::ScrollStatusIgnored: {
246         TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::ignored");
247         if (gestureEvent.sourceDevice == WebGestureEvent::Touchpad) {
248             // We still pass the curve to the main thread if there's nothing scrollable, in case something
249             // registers a handler before the curve is over.
250             return DidNotHandle;
251         }
252         return DropEvent;
253     }
254     }
255     return DidNotHandle;
256 }
257
258 void WebCompositorInputHandlerImpl::bindToClient(WebInputHandlerClient* client)
259 {
260     ASSERT(!m_inputHandlerClient);
261
262     TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::bindToClient");
263     if (!s_compositors)
264         s_compositors = new HashSet<WebCompositorInputHandlerImpl*>;
265     s_compositors->add(this);
266
267     m_inputHandlerClient = client;
268 }
269
270 void WebCompositorInputHandlerImpl::animate(double monotonicTime)
271 {
272     if (!m_flingCurve)
273         return;
274
275     if (!m_flingParameters.startTime) {
276         m_flingParameters.startTime = monotonicTime;
277         m_inputHandlerClient->scheduleAnimation();
278         return;
279     }
280
281     if (m_flingCurve->apply(monotonicTime - m_flingParameters.startTime, this))
282         m_inputHandlerClient->scheduleAnimation();
283     else {
284         TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::animate::flingOver");
285         cancelCurrentFling();
286     }
287 }
288
289 bool WebCompositorInputHandlerImpl::cancelCurrentFling()
290 {
291     bool hadFlingAnimation = m_flingCurve;
292     if (hadFlingAnimation && m_flingParameters.sourceDevice == WebGestureEvent::Touchscreen) {
293         m_inputHandlerClient->scrollEnd();
294         TRACE_EVENT_ASYNC_END0("webkit", "WebCompositorInputHandlerImpl::handleGestureFling::started", this);
295     }
296
297     TRACE_EVENT_INSTANT1("webkit", "WebCompositorInputHandlerImpl::cancelCurrentFling", "hadFlingAnimation", hadFlingAnimation);
298     m_flingCurve.clear();
299     m_gestureScrollOnImplThread = false;
300     m_flingParameters = WebActiveWheelFlingParameters();
301     return hadFlingAnimation;
302 }
303
304 bool WebCompositorInputHandlerImpl::touchpadFlingScroll(const WebFloatSize& increment)
305 {
306     WebMouseWheelEvent syntheticWheel;
307     syntheticWheel.type = WebInputEvent::MouseWheel;
308     syntheticWheel.deltaX = increment.width;
309     syntheticWheel.deltaY = increment.height;
310     syntheticWheel.hasPreciseScrollingDeltas = true;
311     syntheticWheel.x = m_flingParameters.point.x;
312     syntheticWheel.y = m_flingParameters.point.y;
313     syntheticWheel.globalX = m_flingParameters.globalPoint.x;
314     syntheticWheel.globalY = m_flingParameters.globalPoint.y;
315     syntheticWheel.modifiers = m_flingParameters.modifiers;
316
317     WebCompositorInputHandlerImpl::EventDisposition disposition = handleInputEventInternal(syntheticWheel);
318     switch (disposition) {
319     case DidHandle:
320         return true;
321     case DropEvent:
322         break;
323     case DidNotHandle:
324         TRACE_EVENT_INSTANT0("webkit", "WebCompositorInputHandlerImpl::scrollBy::AbortFling");
325         // If we got a DidNotHandle, that means we need to deliver wheels on the main thread.
326         // In this case we need to schedule a commit and transfer the fling curve over to the main
327         // thread and run the rest of the wheels from there.
328         // This can happen when flinging a page that contains a scrollable subarea that we can't
329         // scroll on the thread if the fling starts outside the subarea but then is flung "under" the
330         // pointer.
331         m_client->transferActiveWheelFlingAnimation(m_flingParameters);
332         m_flingActiveOnMainThread = true;
333         cancelCurrentFling();
334         break;
335     }
336
337     return false;
338 }
339
340 void WebCompositorInputHandlerImpl::scrollBy(const WebFloatSize& increment)
341 {
342     if (increment == WebFloatSize())
343         return;
344
345     TRACE_EVENT2("webkit", "WebCompositorInputHandlerImpl::scrollBy", "x", increment.width, "y", increment.height);
346
347     bool didScroll = false;
348
349     switch (m_flingParameters.sourceDevice) {
350     case WebGestureEvent::Touchpad:
351         didScroll = touchpadFlingScroll(increment);
352         break;
353     case WebGestureEvent::Touchscreen:
354         didScroll = m_inputHandlerClient->scrollByIfPossible(m_flingParameters.point, WebFloatSize(-increment.width, -increment.height));
355         break;
356     }
357
358     if (didScroll) {
359         m_flingParameters.cumulativeScroll.width += increment.width;
360         m_flingParameters.cumulativeScroll.height += increment.height;
361     }
362 }
363
364 void WebCompositorInputHandlerImpl::mainThreadHasStoppedFlinging()
365 {
366     m_flingActiveOnMainThread =  false;
367 }
368
369 }