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

Side by Side Diff: Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp

Issue 9931004: Merge 112364 - [chromium] Transfer wheel fling via WebCompositorInputHandlerClient (Closed) Base URL: http://svn.webkit.org/repository/webkit/branches/chromium/1084/
Patch Set: Created 8 years, 8 months 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
« no previous file with comments | « Source/WebKit/chromium/src/WebViewImpl.cpp ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright (C) 2011 Google Inc. All rights reserved. 2 * Copyright (C) 2011 Google Inc. All rights reserved.
3 * 3 *
4 * Redistribution and use in source and binary forms, with or without 4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions 5 * modification, are permitted provided that the following conditions
6 * are met: 6 * are met:
7 * 7 *
8 * 1. Redistributions of source code must retain the above copyright 8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer. 9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright 10 * 2. Redistributions in binary form must reproduce the above copyright
(...skipping 15 matching lines...) Expand all
26 #include "config.h" 26 #include "config.h"
27 27
28 #include "WebCompositorInputHandlerImpl.h" 28 #include "WebCompositorInputHandlerImpl.h"
29 29
30 #include "WebCompositor.h" 30 #include "WebCompositor.h"
31 #include "WebCompositorInputHandlerClient.h" 31 #include "WebCompositorInputHandlerClient.h"
32 #include "WebInputEvent.h" 32 #include "WebInputEvent.h"
33 #include "cc/CCActiveGestureAnimation.h" 33 #include "cc/CCActiveGestureAnimation.h"
34 #include "cc/CCInputHandler.h" 34 #include "cc/CCInputHandler.h"
35 #include "cc/CCSingleThreadProxy.h" 35 #include "cc/CCSingleThreadProxy.h"
36 #include "platform/WebFloatPoint.h"
37 #include "platform/WebPoint.h"
36 38
37 #include <gmock/gmock.h> 39 #include <gmock/gmock.h>
38 #include <gtest/gtest.h> 40 #include <gtest/gtest.h>
39 #include <wtf/OwnPtr.h> 41 #include <wtf/OwnPtr.h>
40 42
41 using WebKit::WebCompositorInputHandler; 43 using namespace WebKit;
42 using WebKit::WebCompositorInputHandlerImpl;
43 44
44 namespace { 45 namespace {
45 46
46 class MockCCInputHandlerClient : public WebCore::CCInputHandlerClient { 47 class MockCCInputHandlerClient : public WebCore::CCInputHandlerClient {
47 WTF_MAKE_NONCOPYABLE(MockCCInputHandlerClient); 48 WTF_MAKE_NONCOPYABLE(MockCCInputHandlerClient);
48 public: 49 public:
49 MockCCInputHandlerClient() 50 MockCCInputHandlerClient()
50 { 51 {
51 } 52 }
52 virtual ~MockCCInputHandlerClient() { } 53 virtual ~MockCCInputHandlerClient() { }
(...skipping 13 matching lines...) Expand all
66 virtual void startPageScaleAnimation(const WebCore::IntSize& targetPosition, 67 virtual void startPageScaleAnimation(const WebCore::IntSize& targetPosition,
67 bool anchorPoint, 68 bool anchorPoint,
68 float pageScale, 69 float pageScale,
69 double startTimeMs, 70 double startTimeMs,
70 double durationMs) OVERRIDE { } 71 double durationMs) OVERRIDE { }
71 72
72 virtual WebCore::CCActiveGestureAnimation* activeGestureAnimation() OVERRIDE { return 0; } 73 virtual WebCore::CCActiveGestureAnimation* activeGestureAnimation() OVERRIDE { return 0; }
73 virtual void setActiveGestureAnimation(PassOwnPtr<WebCore::CCActiveGestureAn imation>) OVERRIDE { } 74 virtual void setActiveGestureAnimation(PassOwnPtr<WebCore::CCActiveGestureAn imation>) OVERRIDE { }
74 }; 75 };
75 76
76 class MockWebCompositorInputHandlerClient : public WebKit::WebCompositorInputHan dlerClient { 77 class MockWebCompositorInputHandlerClient : public WebCompositorInputHandlerClie nt {
77 WTF_MAKE_NONCOPYABLE(MockWebCompositorInputHandlerClient); 78 WTF_MAKE_NONCOPYABLE(MockWebCompositorInputHandlerClient);
78 public: 79 public:
79 MockWebCompositorInputHandlerClient() 80 MockWebCompositorInputHandlerClient()
80 : WebKit::WebCompositorInputHandlerClient() 81 : WebCompositorInputHandlerClient()
81 { 82 {
82 } 83 }
83 virtual ~MockWebCompositorInputHandlerClient() { } 84 virtual ~MockWebCompositorInputHandlerClient() { }
84 85
85 MOCK_METHOD0(willShutdown, void()); 86 MOCK_METHOD0(willShutdown, void());
86 MOCK_METHOD0(didHandleInputEvent, void()); 87 MOCK_METHOD0(didHandleInputEvent, void());
87 MOCK_METHOD1(didNotHandleInputEvent, void(bool sendToWidget)); 88 MOCK_METHOD1(didNotHandleInputEvent, void(bool sendToWidget));
89
90 MOCK_METHOD1(transferActiveWheelFlingAnimation, void(const WebActiveWheelFli ngParameters&));
91
88 }; 92 };
89 93
90 TEST(WebCompositorInputHandlerImpl, fromIdentifier) 94 TEST(WebCompositorInputHandlerImpl, fromIdentifier)
91 { 95 {
92 WebKit::WebCompositor::initialize(0); 96 WebCompositor::initialize(0);
93 WebCore::DebugScopedSetImplThread alwaysImplThread; 97 WebCore::DebugScopedSetImplThread alwaysImplThread;
94 98
95 // Before creating any WebCompositorInputHandlers, lookups for any value sho uld fail and not crash. 99 // Before creating any WebCompositorInputHandlers, lookups for any value sho uld fail and not crash.
96 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(2)); 100 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(2));
97 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(0)); 101 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(0));
98 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(-1)); 102 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(-1));
99 103
100 int compositorIdentifier = -1; 104 int compositorIdentifier = -1;
101 { 105 {
102 OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputH andlerImpl::create(0); 106 OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputH andlerImpl::create(0);
103 compositorIdentifier = inputHandler->identifier(); 107 compositorIdentifier = inputHandler->identifier();
104 // The compositor we just created should be locatable. 108 // The compositor we just created should be locatable.
105 EXPECT_EQ(inputHandler.get(), WebCompositorInputHandler::fromIdentifier( compositorIdentifier)); 109 EXPECT_EQ(inputHandler.get(), WebCompositorInputHandler::fromIdentifier( compositorIdentifier));
106 110
107 // But nothing else. 111 // But nothing else.
108 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(inputHandler->ide ntifier() + 10)); 112 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(inputHandler->ide ntifier() + 10));
109 } 113 }
110 114
111 // After the compositor is destroyed, its entry should be removed from the m ap. 115 // After the compositor is destroyed, its entry should be removed from the m ap.
112 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(compositorIdentifier) ); 116 EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(compositorIdentifier) );
113 WebKit::WebCompositor::shutdown(); 117 WebCompositor::shutdown();
114 } 118 }
115 119
116 class WebCompositorInputHandlerImplTest : public testing::Test { 120 class WebCompositorInputHandlerImplTest : public testing::Test {
117 public: 121 public:
118 WebCompositorInputHandlerImplTest() 122 WebCompositorInputHandlerImplTest()
119 : m_expectedDisposition(DidHandle) 123 : m_expectedDisposition(DidHandle)
120 { 124 {
121 WebKit::WebCompositor::initialize(0); 125 WebCompositor::initialize(0);
122 m_inputHandler = WebCompositorInputHandlerImpl::create(&m_mockCCInputHan dlerClient); 126 m_inputHandler = WebCompositorInputHandlerImpl::create(&m_mockCCInputHan dlerClient);
123 m_inputHandler->setClient(&m_mockClient); 127 m_inputHandler->setClient(&m_mockClient);
124 } 128 }
125 129
126 ~WebCompositorInputHandlerImplTest() 130 ~WebCompositorInputHandlerImplTest()
127 { 131 {
128 m_inputHandler->setClient(0); 132 m_inputHandler->setClient(0);
129 m_inputHandler.clear(); 133 m_inputHandler.clear();
130 WebKit::WebCompositor::shutdown(); 134 WebCompositor::shutdown();
131 } 135 }
132 136
133 void verifyAndResetMocks() 137 // This is defined as a macro because when an expectation is not satisfied t he only output you get
134 { 138 // out of gmock is the line number that set the expectation.
135 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient); 139 #define VERIFY_AND_RESET_MOCKS() do \
136 testing::Mock::VerifyAndClearExpectations(&m_mockClient); 140 { \
137 switch (m_expectedDisposition) { 141 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient); \
138 case DidHandle: 142 testing::Mock::VerifyAndClearExpectations(&m_mockClient); \
139 // If we expect to handle events, we shouldn't get any didNotHandleI nputEvent() calls with any parameter. 143 switch (m_expectedDisposition) { \
140 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(::testing::_)).Time s(0); 144 case DidHandle: \
141 EXPECT_CALL(m_mockClient, didHandleInputEvent()); 145 /* If we expect to handle events, we shouldn't get any didNotHandleI nputEvent() calls with any parameter. */ \
142 break; 146 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(::testing::_)).Time s(0); \
143 case DidNotHandle: 147 EXPECT_CALL(m_mockClient, didHandleInputEvent()); \
144 // If we aren't expecting to handle events, we shouldn't call didHan dleInputEvent(). 148 break; \
145 EXPECT_CALL(m_mockClient, didHandleInputEvent()).Times(0); 149 case DidNotHandle: \
146 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(false)).Times(0); 150 /* If we aren't expecting to handle events, we shouldn't call didHan dleInputEvent(). */ \
147 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(true)); 151 EXPECT_CALL(m_mockClient, didHandleInputEvent()).Times(0); \
148 break; 152 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(false)).Times(0); \
149 case DropEvent: 153 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(true)); \
150 // If we're expecting to drop, we shouldn't get any didHandle..() or didNotHandleInputEvent(true /* sendToWidget */) calls. 154 break; \
151 EXPECT_CALL(m_mockClient, didHandleInputEvent()).Times(0); 155 case DropEvent: \
152 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(true)).Times(0); 156 /* If we're expecting to drop, we shouldn't get any didHandle..() or didNotHandleInputEvent(true) calls. */ \
153 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(false)); 157 EXPECT_CALL(m_mockClient, didHandleInputEvent()).Times(0); \
154 break; 158 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(true)).Times(0); \
155 } 159 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(false)); \
156 } 160 break; \
161 } \
162 } while (0)
157 163
158 protected: 164 protected:
159 MockCCInputHandlerClient m_mockCCInputHandlerClient; 165 MockCCInputHandlerClient m_mockCCInputHandlerClient;
160 OwnPtr<WebCompositorInputHandlerImpl> m_inputHandler; 166 OwnPtr<WebCompositorInputHandlerImpl> m_inputHandler;
161 MockWebCompositorInputHandlerClient m_mockClient; 167 MockWebCompositorInputHandlerClient m_mockClient;
162 WebKit::WebGestureEvent gesture; 168 WebGestureEvent gesture;
163 169
164 enum ExpectedDisposition { DidHandle, DidNotHandle, DropEvent }; 170 enum ExpectedDisposition { DidHandle, DidNotHandle, DropEvent };
165 ExpectedDisposition m_expectedDisposition; 171 ExpectedDisposition m_expectedDisposition;
166 172
167 private: 173 private:
168 WebCore::DebugScopedSetImplThread m_alwaysImplThread; 174 WebCore::DebugScopedSetImplThread m_alwaysImplThread;
169 }; 175 };
170 176
171 177
172 TEST_F(WebCompositorInputHandlerImplTest, gestureScrollStarted) 178 TEST_F(WebCompositorInputHandlerImplTest, gestureScrollStarted)
173 { 179 {
174 // We shouldn't send any events to the widget for this gesture. 180 // We shouldn't send any events to the widget for this gesture.
175 m_expectedDisposition = DidHandle; 181 m_expectedDisposition = DidHandle;
176 verifyAndResetMocks(); 182 VERIFY_AND_RESET_MOCKS();
177 183
178 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 184 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
179 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ; 185 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
180 186
181 gesture.type = WebKit::WebInputEvent::GestureScrollBegin; 187 gesture.type = WebInputEvent::GestureScrollBegin;
182 m_inputHandler->handleInputEvent(gesture); 188 m_inputHandler->handleInputEvent(gesture);
183 189
184 verifyAndResetMocks(); 190 VERIFY_AND_RESET_MOCKS();
185 191
186 gesture.type = WebKit::WebInputEvent::GestureScrollUpdate; 192 gesture.type = WebInputEvent::GestureScrollUpdate;
187 gesture.deltaY = -40; // -Y means scroll down - i.e. in the +Y direction. 193 gesture.deltaY = -40; // -Y means scroll down - i.e. in the +Y direction.
188 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::Property(&WebCore: :IntSize::height, testing::Gt(0)))); 194 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::Property(&WebCore: :IntSize::height, testing::Gt(0))));
189 m_inputHandler->handleInputEvent(gesture); 195 m_inputHandler->handleInputEvent(gesture);
190 196
191 verifyAndResetMocks(); 197 VERIFY_AND_RESET_MOCKS();
192 198
193 gesture.type = WebKit::WebInputEvent::GestureScrollEnd; 199 gesture.type = WebInputEvent::GestureScrollEnd;
194 gesture.deltaY = 0; 200 gesture.deltaY = 0;
195 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd()); 201 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd());
196 m_inputHandler->handleInputEvent(gesture); 202 m_inputHandler->handleInputEvent(gesture);
197 } 203 }
198 204
199 TEST_F(WebCompositorInputHandlerImplTest, gestureScrollFailed) 205 TEST_F(WebCompositorInputHandlerImplTest, gestureScrollFailed)
200 { 206 {
201 // We should send all events to the widget for this gesture. 207 // We should send all events to the widget for this gesture.
202 m_expectedDisposition = DidNotHandle; 208 m_expectedDisposition = DidNotHandle;
203 verifyAndResetMocks(); 209 VERIFY_AND_RESET_MOCKS();
204 210
205 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(::testing::_, ::testing: :_)) 211 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(::testing::_, ::testing: :_))
206 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed)); 212 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed));
207 213
208 gesture.type = WebKit::WebInputEvent::GestureScrollBegin; 214 gesture.type = WebInputEvent::GestureScrollBegin;
209 m_inputHandler->handleInputEvent(gesture); 215 m_inputHandler->handleInputEvent(gesture);
210 216
211 verifyAndResetMocks(); 217 VERIFY_AND_RESET_MOCKS();
212 218
213 gesture.type = WebKit::WebInputEvent::GestureScrollUpdate; 219 gesture.type = WebInputEvent::GestureScrollUpdate;
214 gesture.deltaY = 40; 220 gesture.deltaY = 40;
215 m_inputHandler->handleInputEvent(gesture); 221 m_inputHandler->handleInputEvent(gesture);
216 222
217 verifyAndResetMocks(); 223 VERIFY_AND_RESET_MOCKS();
218 224
219 gesture.type = WebKit::WebInputEvent::GestureScrollEnd; 225 gesture.type = WebInputEvent::GestureScrollEnd;
220 gesture.deltaY = 0; 226 gesture.deltaY = 0;
221 m_inputHandler->handleInputEvent(gesture); 227 m_inputHandler->handleInputEvent(gesture);
222 } 228 }
223 229
224 TEST_F(WebCompositorInputHandlerImplTest, gestureScrollIgnored) 230 TEST_F(WebCompositorInputHandlerImplTest, gestureScrollIgnored)
225 { 231 {
226 // We shouldn't handle the GestureScrollBegin. 232 // We shouldn't handle the GestureScrollBegin.
227 // Instead, we should get one didNotHandleInputEvent(false) call per handleI nputEvent(), 233 // Instead, we should get one didNotHandleInputEvent(false) call per handleI nputEvent(),
228 // indicating that we could determine that there's nothing that could scroll or otherwise 234 // indicating that we could determine that there's nothing that could scroll or otherwise
229 // react to this gesture sequence and thus we should drop the whole gesture sequence on the floor. 235 // react to this gesture sequence and thus we should drop the whole gesture sequence on the floor.
230 m_expectedDisposition = DropEvent; 236 m_expectedDisposition = DropEvent;
231 verifyAndResetMocks(); 237 VERIFY_AND_RESET_MOCKS();
232 238
233 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 239 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
234 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollIgnored)) ; 240 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollIgnored)) ;
235 241
236 gesture.type = WebKit::WebInputEvent::GestureScrollBegin; 242 gesture.type = WebInputEvent::GestureScrollBegin;
237 m_inputHandler->handleInputEvent(gesture); 243 m_inputHandler->handleInputEvent(gesture);
238 } 244 }
239 245
240 TEST_F(WebCompositorInputHandlerImplTest, gesturePinch) 246 TEST_F(WebCompositorInputHandlerImplTest, gesturePinch)
241 { 247 {
242 // We shouldn't send any events to the widget for this gesture. 248 // We shouldn't send any events to the widget for this gesture.
243 m_expectedDisposition = DidHandle; 249 m_expectedDisposition = DidHandle;
244 verifyAndResetMocks(); 250 VERIFY_AND_RESET_MOCKS();
245 251
246 gesture.type = WebKit::WebInputEvent::GesturePinchBegin; 252 gesture.type = WebInputEvent::GesturePinchBegin;
247 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureBegin()); 253 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureBegin());
248 m_inputHandler->handleInputEvent(gesture); 254 m_inputHandler->handleInputEvent(gesture);
249 255
250 verifyAndResetMocks(); 256 VERIFY_AND_RESET_MOCKS();
251 257
252 gesture.type = WebKit::WebInputEvent::GesturePinchUpdate; 258 gesture.type = WebInputEvent::GesturePinchUpdate;
253 gesture.deltaX = 1.5; 259 gesture.deltaX = 1.5;
254 gesture.x = 7; 260 gesture.x = 7;
255 gesture.y = 13; 261 gesture.y = 13;
256 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureUpdate(1.5, WebCore::Int Point(7, 13))); 262 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureUpdate(1.5, WebCore::Int Point(7, 13)));
257 m_inputHandler->handleInputEvent(gesture); 263 m_inputHandler->handleInputEvent(gesture);
258 264
259 verifyAndResetMocks(); 265 VERIFY_AND_RESET_MOCKS();
260 266
261 gesture.type = WebKit::WebInputEvent::GesturePinchUpdate; 267 gesture.type = WebInputEvent::GesturePinchUpdate;
262 gesture.deltaX = 0.5; 268 gesture.deltaX = 0.5;
263 gesture.x = 9; 269 gesture.x = 9;
264 gesture.y = 6; 270 gesture.y = 6;
265 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureUpdate(.5, WebCore::IntP oint(9, 6))); 271 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureUpdate(.5, WebCore::IntP oint(9, 6)));
266 m_inputHandler->handleInputEvent(gesture); 272 m_inputHandler->handleInputEvent(gesture);
267 273
268 verifyAndResetMocks(); 274 VERIFY_AND_RESET_MOCKS();
269 275
270 gesture.type = WebKit::WebInputEvent::GesturePinchEnd; 276 gesture.type = WebInputEvent::GesturePinchEnd;
271 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureEnd()); 277 EXPECT_CALL(m_mockCCInputHandlerClient, pinchGestureEnd());
272 m_inputHandler->handleInputEvent(gesture); 278 m_inputHandler->handleInputEvent(gesture);
273 } 279 }
274 280
275 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingStarted) 281 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingStarted)
276 { 282 {
277 // We shouldn't send any events to the widget for this gesture. 283 // We shouldn't send any events to the widget for this gesture.
278 m_expectedDisposition = DidHandle; 284 m_expectedDisposition = DidHandle;
279 verifyAndResetMocks(); 285 VERIFY_AND_RESET_MOCKS();
280 286
281 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 287 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
282 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ; 288 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
283 289
284 gesture.type = WebKit::WebInputEvent::GestureFlingStart; 290 gesture.type = WebInputEvent::GestureFlingStart;
285 gesture.deltaX = 10; 291 gesture.deltaX = 10;
286 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()); 292 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
287 m_inputHandler->handleInputEvent(gesture); 293 m_inputHandler->handleInputEvent(gesture);
288 294
289 verifyAndResetMocks(); 295 VERIFY_AND_RESET_MOCKS();
290 296
291 // Verify that a GestureFlingCancel during an animation cancels it. 297 // Verify that a GestureFlingCancel during an animation cancels it.
292 gesture.type = WebKit::WebInputEvent::GestureFlingCancel; 298 gesture.type = WebInputEvent::GestureFlingCancel;
293 m_inputHandler->handleInputEvent(gesture); 299 m_inputHandler->handleInputEvent(gesture);
294 } 300 }
295 301
296 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingFailed) 302 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingFailed)
297 { 303 {
298 // We should send all events to the widget for this gesture. 304 // We should send all events to the widget for this gesture.
299 m_expectedDisposition = DidNotHandle; 305 m_expectedDisposition = DidNotHandle;
300 verifyAndResetMocks(); 306 VERIFY_AND_RESET_MOCKS();
301 307
302 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 308 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
303 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed)); 309 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed));
304 310
305 gesture.type = WebKit::WebInputEvent::GestureFlingStart; 311 gesture.type = WebInputEvent::GestureFlingStart;
306 m_inputHandler->handleInputEvent(gesture); 312 m_inputHandler->handleInputEvent(gesture);
307 313
308 verifyAndResetMocks(); 314 VERIFY_AND_RESET_MOCKS();
309 315
310 // Even if we didn't start a fling ourselves, we still need to send the canc el event to the widget. 316 // Even if we didn't start a fling ourselves, we still need to send the canc el event to the widget.
311 gesture.type = WebKit::WebInputEvent::GestureFlingCancel; 317 gesture.type = WebInputEvent::GestureFlingCancel;
312 m_inputHandler->handleInputEvent(gesture); 318 m_inputHandler->handleInputEvent(gesture);
313 } 319 }
314 320
315 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingIgnored) 321 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingIgnored)
316 { 322 {
317 m_expectedDisposition = DidNotHandle; 323 m_expectedDisposition = DidNotHandle;
318 verifyAndResetMocks(); 324 VERIFY_AND_RESET_MOCKS();
319 325
320 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 326 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
321 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollIgnored)) ; 327 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollIgnored)) ;
322 328
323 gesture.type = WebKit::WebInputEvent::GestureFlingStart; 329 gesture.type = WebInputEvent::GestureFlingStart;
324 m_inputHandler->handleInputEvent(gesture); 330 m_inputHandler->handleInputEvent(gesture);
325 331
326 verifyAndResetMocks(); 332 VERIFY_AND_RESET_MOCKS();
327 333
328 // Even if we didn't start a fling ourselves, we still need to send the canc el event to the widget. 334 // Even if we didn't start a fling ourselves, we still need to send the canc el event to the widget.
329 gesture.type = WebKit::WebInputEvent::GestureFlingCancel; 335 gesture.type = WebInputEvent::GestureFlingCancel;
330 m_inputHandler->handleInputEvent(gesture); 336 m_inputHandler->handleInputEvent(gesture);
331 } 337 }
332 338
333 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingAnimates) 339 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingAnimates)
334 { 340 {
335 // We shouldn't send any events to the widget for this gesture. 341 // We shouldn't send any events to the widget for this gesture.
336 m_expectedDisposition = DidHandle; 342 m_expectedDisposition = DidHandle;
337 verifyAndResetMocks(); 343 VERIFY_AND_RESET_MOCKS();
338 344
339 // On the fling start, we should schedule an animation but not actually star t 345 // On the fling start, we should schedule an animation but not actually star t
340 // scrolling. 346 // scrolling.
341 gesture.type = WebKit::WebInputEvent::GestureFlingStart; 347 gesture.type = WebInputEvent::GestureFlingStart;
342 gesture.deltaX = -1000; 348 WebFloatPoint flingDelta = WebFloatPoint(1000, 0);
349 WebPoint flingPoint = WebPoint(7, 13);
350 WebPoint flingGlobalPoint = WebPoint(17, 23);
351 int modifiers = 7;
352 gesture.deltaX = flingDelta.x;
353 gesture.deltaY = flingDelta.y;
354 gesture.x = flingPoint.x;
355 gesture.y = flingPoint.y;
356 gesture.globalX = flingGlobalPoint.x;
357 gesture.globalY = flingGlobalPoint.y;
358 gesture.modifiers = modifiers;
343 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()); 359 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
344 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 360 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
345 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ; 361 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
346 m_inputHandler->handleInputEvent(gesture); 362 m_inputHandler->handleInputEvent(gesture);
347 363
348 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient); 364 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
349 // The first animate call should let us pick up an animation start time, but we 365 // The first animate call should let us pick up an animation start time, but we
350 // shouldn't actually move anywhere just yet. The first frame after the flin g start 366 // shouldn't actually move anywhere just yet. The first frame after the flin g start
351 // will typically include the last scroll from the gesture that lead to the scroll 367 // will typically include the last scroll from the gesture that lead to the scroll
352 // (either wheel or gesture scroll), so there should be no visible hitch. 368 // (either wheel or gesture scroll), so there should be no visible hitch.
353 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()); 369 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
354 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0); 370 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0);
355 m_inputHandler->animate(10); 371 m_inputHandler->animate(10);
356 372
357 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient); 373 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
358 374
359 // The second call should start scrolling in the +X direction. 375 // The second call should start scrolling in the -X direction.
360 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()); 376 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
361 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 377 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
362 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ; 378 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
363 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::Property(&WebCore: :IntSize::width, testing::Gt(0)))); 379 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::Property(&WebCore: :IntSize::width, testing::Lt(0))));
364 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd()); 380 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd());
365 m_inputHandler->animate(10.1); 381 m_inputHandler->animate(10.1);
366 382
367 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient); 383 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
368 384
369 // Let's say on the third call we hit a non-scrollable region. We should abo rt the fling and not scroll. 385 // Let's say on the third call we hit a non-scrollable region. We should abo rt the fling and not scroll.
370 // FIXME: We also need to do some work to transfer the rest of this fling to the main thread. 386 // We also should pass the current fling parameters out to the client so the rest of the fling can be
371 // Add tests for this once it's implemented. 387 // transferred to the main thread.
372 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()); 388 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
373 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) 389 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
374 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed)); 390 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed));
375 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::_)).Times(0); 391 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::_)).Times(0);
376 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd()).Times(0); 392 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd()).Times(0);
393
394 // Expected wheel fling animation parameters:
395 // *) flingDelta and flingPoint should match the original GestureFlingStart event
396 // *) startTime should be 10 to match the time parameter of the first animat e() call after the GestureFlingStart
397 // *) cumulativeScroll depends on the curve, but since we've animated in the -X direction the X value should be < 0
398 EXPECT_CALL(m_mockClient, transferActiveWheelFlingAnimation(testing::AllOf(
399 testing::Field(&WebActiveWheelFlingParameters::delta, testing::Eq(flingD elta)),
400 testing::Field(&WebActiveWheelFlingParameters::point, testing::Eq(flingP oint)),
401 testing::Field(&WebActiveWheelFlingParameters::globalPoint, testing::Eq( flingGlobalPoint)),
402 testing::Field(&WebActiveWheelFlingParameters::modifiers, testing::Eq(mo difiers)),
403 testing::Field(&WebActiveWheelFlingParameters::startTime, testing::Eq(10 )),
404 testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll,
405 testing::Field(&WebSize::width, testing::Gt(0))))));
377 m_inputHandler->animate(10.2); 406 m_inputHandler->animate(10.2);
378 407
379 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient); 408 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
409 testing::Mock::VerifyAndClearExpectations(&m_mockClient);
380 410
381 // Since we've aborted the fling, the next animation should be a no-op and s hould not result in another 411 // Since we've aborted the fling, the next animation should be a no-op and s hould not result in another
382 // frame being requested. 412 // frame being requested.
383 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()).Times(0); 413 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()).Times(0);
384 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0); 414 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0);
385 m_inputHandler->animate(10.3); 415 m_inputHandler->animate(10.3);
416
417 // Since we've transferred the fling to the main thread, we need to pass the next GestureFlingCancel to the main
418 // thread as well.
419 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(true));
420 gesture.type = WebInputEvent::GestureFlingCancel;
421 m_inputHandler->handleInputEvent(gesture);
422 }
423
424 TEST_F(WebCompositorInputHandlerImplTest, gestureFlingTransferResets)
425 {
426 // We shouldn't send any events to the widget for this gesture.
427 m_expectedDisposition = DidHandle;
428 VERIFY_AND_RESET_MOCKS();
429
430 // Start a gesture fling in the -X direction with zero Y movement.
431 gesture.type = WebInputEvent::GestureFlingStart;
432 WebFloatPoint flingDelta = WebFloatPoint(1000, 0);
433 WebPoint flingPoint = WebPoint(7, 13);
434 WebPoint flingGlobalPoint = WebPoint(17, 23);
435 int modifiers = 1;
436 gesture.deltaX = flingDelta.x;
437 gesture.deltaY = flingDelta.y;
438 gesture.x = flingPoint.x;
439 gesture.y = flingPoint.y;
440 gesture.globalX = flingGlobalPoint.x;
441 gesture.globalY = flingGlobalPoint.y;
442 gesture.modifiers = modifiers;
443 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
444 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
445 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
446 m_inputHandler->handleInputEvent(gesture);
447
448 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
449
450 // Start the fling animation at time 10. This shouldn't actually scroll, jus t establish a start time.
451 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
452 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0);
453 m_inputHandler->animate(10);
454
455 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
456
457 // The second call should start scrolling in the -X direction.
458 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
459 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
460 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
461 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::Property(&WebCore: :IntSize::width, testing::Lt(0))));
462 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd());
463 m_inputHandler->animate(10.1);
464
465 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
466
467 // Let's say on the third call we hit a non-scrollable region. We should abo rt the fling and not scroll.
468 // We also should pass the current fling parameters out to the client so the rest of the fling can be
469 // transferred to the main thread.
470 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
471 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
472 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed));
473 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::_)).Times(0);
474 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd()).Times(0);
475
476 // Expected wheel fling animation parameters:
477 // *) flingDelta and flingPoint should match the original GestureFlingStart event
478 // *) startTime should be 10 to match the time parameter of the first animat e() call after the GestureFlingStart
479 // *) cumulativeScroll depends on the curve, but since we've animated in the -X direction the X value should be < 0
480 EXPECT_CALL(m_mockClient, transferActiveWheelFlingAnimation(testing::AllOf(
481 testing::Field(&WebActiveWheelFlingParameters::delta, testing::Eq(flingD elta)),
482 testing::Field(&WebActiveWheelFlingParameters::point, testing::Eq(flingP oint)),
483 testing::Field(&WebActiveWheelFlingParameters::globalPoint, testing::Eq( flingGlobalPoint)),
484 testing::Field(&WebActiveWheelFlingParameters::modifiers, testing::Eq(mo difiers)),
485 testing::Field(&WebActiveWheelFlingParameters::startTime, testing::Eq(10 )),
486 testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll,
487 testing::Field(&WebSize::width, testing::Gt(0))))));
488 m_inputHandler->animate(10.2);
489
490 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
491 testing::Mock::VerifyAndClearExpectations(&m_mockClient);
492
493 // Since we've aborted the fling, the next animation should be a no-op and s hould not result in another
494 // frame being requested.
495 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation()).Times(0);
496 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0);
497 m_inputHandler->animate(10.3);
498
499 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
500
501 // Since we've transferred the fling to the main thread, we need to pass the next GestureFlingCancel to the main
502 // thread as well.
503 EXPECT_CALL(m_mockClient, didNotHandleInputEvent(true));
504 gesture.type = WebInputEvent::GestureFlingCancel;
505 m_inputHandler->handleInputEvent(gesture);
506
507 VERIFY_AND_RESET_MOCKS();
508
509 // Start a second gesture fling, this time in the +Y direction with no X.
510 gesture.type = WebInputEvent::GestureFlingStart;
511 flingDelta = WebFloatPoint(0, -1000);
512 flingPoint = WebPoint(95, 87);
513 flingGlobalPoint = WebPoint(32, 71);
514 modifiers = 2;
515 gesture.deltaX = flingDelta.x;
516 gesture.deltaY = flingDelta.y;
517 gesture.x = flingPoint.x;
518 gesture.y = flingPoint.y;
519 gesture.globalX = flingGlobalPoint.x;
520 gesture.globalY = flingGlobalPoint.y;
521 gesture.modifiers = modifiers;
522 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
523 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
524 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
525 m_inputHandler->handleInputEvent(gesture);
526
527 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
528
529 // Start the second fling animation at time 30.
530 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
531 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_)) .Times(0);
532 m_inputHandler->animate(30);
533
534 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
535
536 // Tick the second fling once normally.
537 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
538 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
539 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollStarted)) ;
540 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::Property(&WebCore: :IntSize::height, testing::Gt(0))));
541 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd());
542 m_inputHandler->animate(30.1);
543
544 testing::Mock::VerifyAndClearExpectations(&m_mockCCInputHandlerClient);
545
546 // Then abort the second fling.
547 EXPECT_CALL(m_mockCCInputHandlerClient, scheduleAnimation());
548 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBegin(testing::_, testing::_))
549 .WillOnce(testing::Return(WebCore::CCInputHandlerClient::ScrollFailed));
550 EXPECT_CALL(m_mockCCInputHandlerClient, scrollBy(testing::_)).Times(0);
551 EXPECT_CALL(m_mockCCInputHandlerClient, scrollEnd()).Times(0);
552
553 // We should get parameters from the second fling, nothing from the first fl ing should "leak".
554 EXPECT_CALL(m_mockClient, transferActiveWheelFlingAnimation(testing::AllOf(
555 testing::Field(&WebActiveWheelFlingParameters::delta, testing::Eq(flingD elta)),
556 testing::Field(&WebActiveWheelFlingParameters::point, testing::Eq(flingP oint)),
557 testing::Field(&WebActiveWheelFlingParameters::globalPoint, testing::Eq( flingGlobalPoint)),
558 testing::Field(&WebActiveWheelFlingParameters::modifiers, testing::Eq(mo difiers)),
559 testing::Field(&WebActiveWheelFlingParameters::startTime, testing::Eq(30 )),
560 testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll,
561 testing::Field(&WebSize::height, testing::Lt(0))))));
562 m_inputHandler->animate(30.2);
386 } 563 }
387 564
388 } 565 }
OLDNEW
« no previous file with comments | « Source/WebKit/chromium/src/WebViewImpl.cpp ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698