[chromium] Notify compositor of wheel event registration via ScrollingCoordinator
[WebKit-https.git] / Source / WebKit / chromium / tests / WebCompositorInputHandlerImplTest.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 "WebCompositor.h"
31 #include "WebCompositorInputHandlerClient.h"
32 #include "WebInputEvent.h"
33 #include "cc/CCInputHandler.h"
34 #include "cc/CCSingleThreadProxy.h"
35
36 #include <gtest/gtest.h>
37 #include <wtf/OwnPtr.h>
38
39 using WebKit::WebCompositorInputHandler;
40 using WebKit::WebCompositorInputHandlerImpl;
41
42 namespace {
43
44 class MockInputHandlerClient : public WebCore::CCInputHandlerClient {
45     WTF_MAKE_NONCOPYABLE(MockInputHandlerClient);
46 public:
47     MockInputHandlerClient()
48         : m_scrollStatus(ScrollStarted)
49         , m_pinchStarted(false)
50         , m_pinchEnded(false)
51         , m_pinchMagnification(0)
52     {
53     }
54     virtual ~MockInputHandlerClient() { }
55
56     void setScrollStatus(ScrollStatus status) { m_scrollStatus = status; }
57
58     bool pinchStarted() const { return m_pinchStarted; }
59     bool pinchEnded() const { return m_pinchEnded; }
60     float pinchMaginifcation() const { return m_pinchMagnification; }
61
62     void resetPinch()
63     {
64         m_pinchStarted = m_pinchEnded = false;
65         m_pinchMagnification = 0;
66     }
67
68 private:
69     virtual void setNeedsRedraw() OVERRIDE { }
70     virtual ScrollStatus scrollBegin(const WebCore::IntPoint&, WebCore::CCInputHandlerClient::ScrollInputType) OVERRIDE
71     {
72         return m_scrollStatus;
73     }
74     virtual void scrollBy(const WebCore::IntSize&) OVERRIDE { }
75     virtual void scrollEnd() OVERRIDE { }
76
77     virtual void pinchGestureBegin() OVERRIDE
78     {
79         m_pinchStarted = true;
80     }
81     virtual void pinchGestureUpdate(float magnifyDelta, const WebCore::IntPoint& anchor) OVERRIDE
82     {
83         m_pinchMagnification = magnifyDelta;
84     }
85     virtual void pinchGestureEnd() OVERRIDE
86     {
87         m_pinchEnded = true;
88     }
89     virtual void startPageScaleAnimation(const WebCore::IntSize& targetPosition,
90                                          bool anchorPoint,
91                                          float pageScale,
92                                          double startTimeMs,
93                                          double durationMs) OVERRIDE { }
94
95     ScrollStatus m_scrollStatus;
96     bool m_pinchStarted;
97     bool m_pinchEnded;
98     float m_pinchMagnification;
99 };
100
101 class MockWebCompositorInputHandlerClient : public WebKit::WebCompositorInputHandlerClient {
102     WTF_MAKE_NONCOPYABLE(MockWebCompositorInputHandlerClient);
103 public:
104     MockWebCompositorInputHandlerClient()
105         : m_handled(false)
106         , m_sendToWidget(false)
107     {
108     }
109     virtual ~MockWebCompositorInputHandlerClient() { }
110
111     void reset()
112     {
113         m_handled = false;
114         m_sendToWidget = false;
115     }
116
117     bool handled() const { return m_handled; }
118     bool sendToWidget() const { return m_sendToWidget; }
119
120 private:
121     virtual void willShutdown() OVERRIDE { }
122     virtual void didHandleInputEvent() OVERRIDE
123     {
124         m_handled = true;
125     }
126     virtual void didNotHandleInputEvent(bool sendToWidget) OVERRIDE
127     {
128         m_sendToWidget = sendToWidget;
129     }
130
131     bool m_handled;
132     bool m_sendToWidget;
133 };
134
135 TEST(WebCompositorInputHandlerImpl, fromIdentifier)
136 {
137     WebKit::WebCompositor::initialize(0);
138 #ifndef NDEBUG
139     // WebCompositorInputHandler APIs can only be called from the compositor thread.
140     WebCore::DebugScopedSetImplThread alwaysImplThread;
141 #endif
142
143     // Before creating any WebCompositorInputHandlers, lookups for any value should fail and not crash.
144     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(2));
145     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(0));
146     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(-1));
147
148     int compositorIdentifier = -1;
149     {
150         OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputHandlerImpl::create(0);
151         compositorIdentifier = inputHandler->identifier();
152         // The compositor we just created should be locatable.
153         EXPECT_EQ(inputHandler.get(), WebCompositorInputHandler::fromIdentifier(compositorIdentifier));
154
155         // But nothing else.
156         EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(inputHandler->identifier() + 10));
157     }
158
159     // After the compositor is destroyed, its entry should be removed from the map.
160     EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(compositorIdentifier));
161
162     WebKit::WebCompositor::shutdown();
163 }
164
165 TEST(WebCompositorInputHandlerImpl, gestureScroll)
166 {
167     WebKit::WebCompositor::initialize(0);
168 #ifndef NDEBUG
169     // WebCompositorInputHandler APIs can only be called from the compositor thread.
170     WebCore::DebugScopedSetImplThread alwaysImplThread;
171 #endif
172
173     MockInputHandlerClient mockInputHandler;
174     OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputHandlerImpl::create(&mockInputHandler);
175     MockWebCompositorInputHandlerClient mockClient;
176     inputHandler->setClient(&mockClient);
177
178     WebKit::WebGestureEvent gesture;
179
180     gesture.type = WebKit::WebInputEvent::GestureScrollBegin;
181     inputHandler->handleInputEvent(gesture);
182     EXPECT_TRUE(mockClient.handled());
183     EXPECT_FALSE(mockClient.sendToWidget());
184     mockClient.reset();
185
186     gesture.type = WebKit::WebInputEvent::GestureScrollUpdate;
187     gesture.deltaY = 40;
188     inputHandler->handleInputEvent(gesture);
189     EXPECT_TRUE(mockClient.handled());
190     EXPECT_FALSE(mockClient.sendToWidget());
191     mockClient.reset();
192
193     gesture.type = WebKit::WebInputEvent::GestureScrollEnd;
194     gesture.deltaY = 0;
195     inputHandler->handleInputEvent(gesture);
196     EXPECT_TRUE(mockClient.handled());
197     EXPECT_FALSE(mockClient.sendToWidget());
198     mockClient.reset();
199
200     mockInputHandler.setScrollStatus(WebCore::CCInputHandlerClient::ScrollFailed);
201
202     gesture.type = WebKit::WebInputEvent::GestureScrollBegin;
203     inputHandler->handleInputEvent(gesture);
204     EXPECT_FALSE(mockClient.handled());
205     EXPECT_TRUE(mockClient.sendToWidget());
206     mockClient.reset();
207
208     gesture.type = WebKit::WebInputEvent::GestureScrollUpdate;
209     gesture.deltaY = 40;
210     inputHandler->handleInputEvent(gesture);
211     EXPECT_FALSE(mockClient.handled());
212     EXPECT_TRUE(mockClient.sendToWidget());
213     mockClient.reset();
214
215     gesture.type = WebKit::WebInputEvent::GestureScrollEnd;
216     gesture.deltaY = 0;
217     inputHandler->handleInputEvent(gesture);
218     EXPECT_FALSE(mockClient.handled());
219     EXPECT_TRUE(mockClient.sendToWidget());
220     mockClient.reset();
221
222     inputHandler->setClient(0);
223
224     WebKit::WebCompositor::shutdown();
225 }
226
227 TEST(WebCompositorInputHandlerImpl, gesturePinch)
228 {
229     WebKit::WebCompositor::initialize(0);
230 #ifndef NDEBUG
231     // WebCompositorInputHandler APIs can only be called from the compositor thread.
232     WebCore::DebugScopedSetImplThread alwaysImplThread;
233 #endif
234
235     MockInputHandlerClient mockInputHandler;
236     OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputHandlerImpl::create(&mockInputHandler);
237     MockWebCompositorInputHandlerClient mockClient;
238     inputHandler->setClient(&mockClient);
239
240     WebKit::WebGestureEvent gesture;
241
242     gesture.type = WebKit::WebInputEvent::GesturePinchBegin;
243     inputHandler->handleInputEvent(gesture);
244     EXPECT_TRUE(mockClient.handled());
245     EXPECT_FALSE(mockClient.sendToWidget());
246     EXPECT_TRUE(mockInputHandler.pinchStarted());
247     mockClient.reset();
248     mockInputHandler.resetPinch();
249
250     gesture.type = WebKit::WebInputEvent::GesturePinchUpdate;
251     gesture.deltaX = 1.5;
252     inputHandler->handleInputEvent(gesture);
253     EXPECT_TRUE(mockClient.handled());
254     EXPECT_FALSE(mockClient.sendToWidget());
255     EXPECT_FALSE(mockInputHandler.pinchEnded());
256     EXPECT_EQ(1.5, mockInputHandler.pinchMaginifcation());
257     mockClient.reset();
258     mockInputHandler.resetPinch();
259
260     gesture.type = WebKit::WebInputEvent::GesturePinchUpdate;
261     gesture.deltaX = 0.5;
262     inputHandler->handleInputEvent(gesture);
263     EXPECT_TRUE(mockClient.handled());
264     EXPECT_FALSE(mockClient.sendToWidget());
265     EXPECT_FALSE(mockInputHandler.pinchEnded());
266     EXPECT_EQ(0.5, mockInputHandler.pinchMaginifcation());
267     mockClient.reset();
268     mockInputHandler.resetPinch();
269
270     gesture.type = WebKit::WebInputEvent::GesturePinchEnd;
271     inputHandler->handleInputEvent(gesture);
272     EXPECT_TRUE(mockClient.handled());
273     EXPECT_FALSE(mockClient.sendToWidget());
274     EXPECT_TRUE(mockInputHandler.pinchEnded());
275     mockClient.reset();
276     mockInputHandler.resetPinch();
277
278     inputHandler->setClient(0);
279
280     WebKit::WebCompositor::shutdown();
281 }
282
283 }