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

Side by Side Diff: third_party/WebKit/public/web/WebInputEvent.h

Issue 2173073003: Move WebInputEvent into public/platform from public/web (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix gn build failure with android Created 4 years, 4 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
OLDNEW
1 /* 1 /*
2 * Copyright (C) 2009 Google Inc. All rights reserved. 2 * Copyright (C) 2009 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 are 5 * modification, are permitted provided that the following conditions are
6 * met: 6 * met:
7 * 7 *
8 * * Redistributions of source code must retain the above copyright 8 * * 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 * * Redistributions in binary form must reproduce the above 10 * * Redistributions in binary form must reproduce the above
(...skipping 10 matching lines...) Expand all
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */ 29 */
30 30
31 #ifndef WebInputEvent_h 31 // TODO(dtapuska): This is a temporarily placeholder file
32 #define WebInputEvent_h 32 // while crbug.com/625684 is fixed.
33 33 #include "../platform/WebInputEvent.h"
34 #include "../platform/WebCommon.h"
35 #include "../platform/WebGestureDevice.h"
36 #include "../platform/WebPointerProperties.h"
37 #include "../platform/WebRect.h"
38 #include "WebTouchPoint.h"
39
40 #include <string.h>
41
42 namespace blink {
43
44 // The classes defined in this file are intended to be used with
45 // WebWidget's handleInputEvent method. These event types are cross-
46 // platform and correspond closely to WebCore's Platform*Event classes.
47 //
48 // WARNING! These classes must remain PODs (plain old data). They are
49 // intended to be "serializable" by copying their raw bytes, so they must
50 // not contain any non-bit-copyable member variables!
51 //
52 // Furthermore, the class members need to be packed so they are aligned
53 // properly and don't have paddings/gaps, otherwise memory check tools
54 // like Valgrind will complain about uninitialized memory usage when
55 // transferring these classes over the wire.
56
57 #pragma pack(push, 4)
58
59 // WebInputEvent --------------------------------------------------------------
60
61 class WebInputEvent {
62 public:
63 // When we use an input method (or an input method editor), we receive
64 // two events for a keypress. The former event is a keydown, which
65 // provides a keycode, and the latter is a textinput, which provides
66 // a character processed by an input method. (The mapping from a
67 // keycode to a character code is not trivial for non-English
68 // keyboards.)
69 // To support input methods, Safari sends keydown events to WebKit for
70 // filtering. WebKit sends filtered keydown events back to Safari,
71 // which sends them to input methods.
72 // Unfortunately, it is hard to apply this design to Chrome because of
73 // our multiprocess architecture. An input method is running in a
74 // browser process. On the other hand, WebKit is running in a renderer
75 // process. So, this design results in increasing IPC messages.
76 // To support input methods without increasing IPC messages, Chrome
77 // handles keyboard events in a browser process and send asynchronous
78 // input events (to be translated to DOM events) to a renderer
79 // process.
80 // This design is mostly the same as the one of Windows and Mac Carbon.
81 // So, for what it's worth, our Linux and Mac front-ends emulate our
82 // Windows front-end. To emulate our Windows front-end, we can share
83 // our back-end code among Windows, Linux, and Mac.
84 // TODO(hbono): Issue 18064: remove the KeyDown type since it isn't
85 // used in Chrome any longer.
86
87 // A Java counterpart will be generated for this enum.
88 // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.blink_public.web
89 // GENERATED_JAVA_CLASS_NAME_OVERRIDE: WebInputEventType
90 enum Type {
91 Undefined = -1,
92 TypeFirst = Undefined,
93
94 // WebMouseEvent
95 MouseDown,
96 MouseTypeFirst = MouseDown,
97 MouseUp,
98 MouseMove,
99 MouseEnter,
100 MouseLeave,
101 ContextMenu,
102 MouseTypeLast = ContextMenu,
103
104 // WebMouseWheelEvent
105 MouseWheel,
106
107 // WebKeyboardEvent
108 RawKeyDown,
109 KeyboardTypeFirst = RawKeyDown,
110 KeyDown,
111 KeyUp,
112 Char,
113 KeyboardTypeLast = Char,
114
115 // WebGestureEvent
116 GestureScrollBegin,
117 GestureTypeFirst = GestureScrollBegin,
118 GestureScrollEnd,
119 GestureScrollUpdate,
120 GestureFlingStart,
121 GestureFlingCancel,
122 GestureShowPress,
123 GestureTap,
124 GestureTapUnconfirmed,
125 GestureTapDown,
126 GestureTapCancel,
127 GestureDoubleTap,
128 GestureTwoFingerTap,
129 GestureLongPress,
130 GestureLongTap,
131 GesturePinchBegin,
132 GesturePinchEnd,
133 GesturePinchUpdate,
134 GestureTypeLast = GesturePinchUpdate,
135
136 // WebTouchEvent
137 TouchStart,
138 TouchTypeFirst = TouchStart,
139 TouchMove,
140 TouchEnd,
141 TouchCancel,
142 TouchScrollStarted,
143 TouchTypeLast = TouchScrollStarted,
144
145 TypeLast = TouchTypeLast
146 };
147
148 // The modifier constants cannot change their values since pepper
149 // does a 1-1 mapping of its values; see
150 // content/renderer/pepper/event_conversion.cc
151 //
152 // A Java counterpart will be generated for this enum.
153 // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.blink_public.web
154 // GENERATED_JAVA_CLASS_NAME_OVERRIDE: WebInputEventModifier
155 enum Modifiers {
156 // modifiers for all events:
157 ShiftKey = 1 << 0,
158 ControlKey = 1 << 1,
159 AltKey = 1 << 2,
160 MetaKey = 1 << 3,
161
162 // modifiers for keyboard events:
163 IsKeyPad = 1 << 4,
164 IsAutoRepeat = 1 << 5,
165
166 // modifiers for mouse events:
167 LeftButtonDown = 1 << 6,
168 MiddleButtonDown = 1 << 7,
169 RightButtonDown = 1 << 8,
170
171 // Toggle modifers for all events.
172 CapsLockOn = 1 << 9,
173 NumLockOn = 1 << 10,
174
175 IsLeft = 1 << 11,
176 IsRight = 1 << 12,
177
178 // Indicates that an event was generated on the touch screen while
179 // touch accessibility is enabled, so the event should be handled
180 // by accessibility code first before normal input event processing.
181 IsTouchAccessibility = 1 << 13,
182
183 IsComposing = 1 << 14,
184
185 AltGrKey = 1 << 15,
186 FnKey = 1 << 16,
187 SymbolKey = 1 << 17,
188
189 ScrollLockOn = 1 << 18,
190 };
191
192 // Indicates whether the browser needs to block on the ACK result for
193 // this event, and if not why note (for metrics/diagnostics purposes).
194 // These values are direct mappings of the values in PlatformEvent
195 // so the values can be cast between the enumerations. static_asserts
196 // checking this are in web/WebInputEventConversion.cpp.
197 enum DispatchType {
198 // Event can be canceled.
199 Blocking,
200 // Event can not be canceled.
201 EventNonBlocking,
202 // All listeners are passive; not cancelable.
203 ListenersNonBlockingPassive,
204 // This value represents a state which would have normally blocking
205 // but was forced to be non-blocking; not cancelable.
206 ListenersForcedNonBlockingPassive,
207 };
208
209 // The rail mode for a wheel event specifies the axis on which scrolling is
210 // expected to stick. If this axis is set to Free, then scrolling is not
211 // stuck to any axis.
212 enum RailsMode {
213 RailsModeFree = 0,
214 RailsModeHorizontal = 1,
215 RailsModeVertical = 2,
216 };
217
218 static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
219
220 double timeStampSeconds; // Seconds since platform start with microsecond re solution.
221 unsigned size; // The size of this structure, for serialization.
222 Type type;
223 int modifiers;
224
225 // Returns true if the WebInputEvent |type| is a mouse event.
226 static bool isMouseEventType(int type)
227 {
228 return MouseTypeFirst <= type && type <= MouseTypeLast;
229 }
230
231 // Returns true if the WebInputEvent |type| is a keyboard event.
232 static bool isKeyboardEventType(int type)
233 {
234 return KeyboardTypeFirst <= type && type <= KeyboardTypeLast;
235 }
236
237 // Returns true if the WebInputEvent |type| is a touch event.
238 static bool isTouchEventType(int type)
239 {
240 return TouchTypeFirst <= type && type <= TouchTypeLast;
241 }
242
243 // Returns true if the WebInputEvent is a gesture event.
244 static bool isGestureEventType(int type)
245 {
246 return GestureTypeFirst <= type && type <= GestureTypeLast;
247 }
248
249 protected:
250 explicit WebInputEvent(unsigned sizeParam)
251 {
252 memset(this, 0, sizeParam);
253 timeStampSeconds = 0.0;
254 size = sizeParam;
255 type = Undefined;
256 modifiers = 0;
257 }
258 };
259
260 // WebKeyboardEvent -----------------------------------------------------------
261
262 class WebKeyboardEvent : public WebInputEvent {
263 public:
264 // Caps on string lengths so we can make them static arrays and keep
265 // them PODs.
266 static const size_t textLengthCap = 4;
267
268 // |windowsKeyCode| is the Windows key code associated with this key
269 // event. Sometimes it's direct from the event (i.e. on Windows),
270 // sometimes it's via a mapping function. If you want a list, see
271 // WebCore/platform/chromium/KeyboardCodes* . Note that this should
272 // ALWAYS store the non-locational version of a keycode as this is
273 // what is returned by the Windows API. For example, it should
274 // store VK_SHIFT instead of VK_RSHIFT. The location information
275 // should be stored in |modifiers|.
276 int windowsKeyCode;
277
278 // The actual key code genenerated by the platform. The DOM spec runs
279 // on Windows-equivalent codes (thus |windowsKeyCode| above) but it
280 // doesn't hurt to have this one around.
281 int nativeKeyCode;
282
283 // The DOM code enum of the key pressed as passed by the embedder. DOM
284 // code enum are defined in ui/events/keycodes/dom4/keycode_converter_data.h .
285 int domCode;
286
287 // The DOM key enum of the key pressed as passed by the embedder. DOM
288 // key enum are defined in ui/events/keycodes/dom3/dom_key_data.h
289 int domKey;
290
291 // This identifies whether this event was tagged by the system as being
292 // a "system key" event (see
293 // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for
294 // details). Other platforms don't have this concept, but it's just
295 // easier to leave it always false than ifdef.
296 bool isSystemKey;
297
298 // Whether the event forms part of a browser-handled keyboard shortcut.
299 // This can be used to conditionally suppress Char events after a
300 // shortcut-triggering RawKeyDown goes unhandled.
301 bool isBrowserShortcut;
302
303 // |text| is the text generated by this keystroke. |unmodifiedText| is
304 // |text|, but unmodified by an concurrently-held modifiers (except
305 // shift). This is useful for working out shortcut keys. Linux and
306 // Windows guarantee one character per event. The Mac does not, but in
307 // reality that's all it ever gives. We're generous, and cap it a bit
308 // longer.
309 WebUChar text[textLengthCap];
310 WebUChar unmodifiedText[textLengthCap];
311
312 WebKeyboardEvent()
313 : WebInputEvent(sizeof(WebKeyboardEvent))
314 , windowsKeyCode(0)
315 , nativeKeyCode(0)
316 , isSystemKey(false)
317 , isBrowserShortcut(false)
318 {
319 memset(&text, 0, sizeof(text));
320 memset(&unmodifiedText, 0, sizeof(unmodifiedText));
321 }
322 };
323
324 // WebMouseEvent --------------------------------------------------------------
325
326 class WebMouseEvent : public WebInputEvent, public WebPointerProperties {
327 public:
328 // Renderer coordinates. Similar to viewport coordinates but without
329 // DevTools emulation transform or overscroll applied. i.e. the coordinates
330 // in Chromium's RenderView bounds.
331 int x;
332 int y;
333
334 // DEPRECATED (crbug.com/507787)
335 int windowX;
336 int windowY;
337
338 // Screen coordinate
339 int globalX;
340 int globalY;
341
342 int movementX;
343 int movementY;
344 int clickCount;
345
346 WebMouseEvent()
347 : WebInputEvent(sizeof(WebMouseEvent))
348 , WebPointerProperties()
349 , x(0)
350 , y(0)
351 , windowX(0)
352 , windowY(0)
353 , globalX(0)
354 , globalY(0)
355 , movementX(0)
356 , movementY(0)
357 , clickCount(0)
358 {
359 }
360
361 protected:
362 explicit WebMouseEvent(unsigned sizeParam)
363 : WebInputEvent(sizeParam)
364 , WebPointerProperties()
365 , x(0)
366 , y(0)
367 , windowX(0)
368 , windowY(0)
369 , globalX(0)
370 , globalY(0)
371 , movementX(0)
372 , movementY(0)
373 , clickCount(0)
374 {
375 }
376 };
377
378 // WebMouseWheelEvent ---------------------------------------------------------
379
380 class WebMouseWheelEvent : public WebMouseEvent {
381 public:
382 enum Phase {
383 PhaseNone = 0,
384 PhaseBegan = 1 << 0,
385 PhaseStationary = 1 << 1,
386 PhaseChanged = 1 << 2,
387 PhaseEnded = 1 << 3,
388 PhaseCancelled = 1 << 4,
389 PhaseMayBegin = 1 << 5,
390 };
391
392 float deltaX;
393 float deltaY;
394 float wheelTicksX;
395 float wheelTicksY;
396
397 float accelerationRatioX;
398 float accelerationRatioY;
399
400 // This field exists to allow BrowserPlugin to mark MouseWheel events as
401 // 'resent' to handle the case where an event is not consumed when first
402 // encountered; it should be handled differently by the plugin when it is
403 // sent for thesecond time. No code within Blink touches this, other than to
404 // plumb it through event conversions.
405 int resendingPluginId;
406
407 Phase phase;
408 Phase momentumPhase;
409
410 // Rubberbanding is an OSX visual effect. When a user scrolls the content
411 // area with a track pad, and the content area is already at its limit in
412 // the direction being scrolled, the entire content area is allowed to
413 // scroll slightly off screen, revealing a grey background. When the user
414 // lets go, the content area snaps back into place. Blink is responsible
415 // for this rubberbanding effect, but the embedder may wish to disable
416 // rubber banding in the left or right direction, if the scroll should have
417 // an alternate effect. The common case is that a scroll in the left or
418 // right directions causes a back or forwards navigation, respectively.
419 //
420 // These flags prevent rubber banding from starting in a given direction,
421 // but have no effect on an ongoing rubber banding. A rubber banding that
422 // started in the vertical direction is allowed to continue in the right
423 // direction, even if canRubberbandRight is 0.
424 bool canRubberbandLeft;
425 bool canRubberbandRight;
426
427 bool scrollByPage;
428 bool hasPreciseScrollingDeltas;
429
430 RailsMode railsMode;
431
432 // Whether the event is blocking, non-blocking, all event
433 // listeners were passive or was forced to be non-blocking.
434 DispatchType dispatchType;
435
436 WebMouseWheelEvent()
437 : WebMouseEvent(sizeof(WebMouseWheelEvent))
438 , deltaX(0.0f)
439 , deltaY(0.0f)
440 , wheelTicksX(0.0f)
441 , wheelTicksY(0.0f)
442 , accelerationRatioX(1.0f)
443 , accelerationRatioY(1.0f)
444 , resendingPluginId(-1)
445 , phase(PhaseNone)
446 , momentumPhase(PhaseNone)
447 , canRubberbandLeft(true)
448 , canRubberbandRight(true)
449 , scrollByPage(false)
450 , hasPreciseScrollingDeltas(false)
451 , railsMode(RailsModeFree)
452 , dispatchType(Blocking)
453 {
454 }
455 };
456
457 // WebGestureEvent ------------------------------------------------------------- -
458
459 class WebGestureEvent : public WebInputEvent {
460 public:
461 enum ScrollUnits {
462 PrecisePixels = 0, // generated by high precision devices.
463 Pixels, // large pixel jump duration; should animate to delta.
464 Page // page (visible viewport) based scrolling.
465 };
466
467 enum InertialPhaseState {
468 UnknownMomentumPhase = 0, // No phase information.
469 NonMomentumPhase, // Regular scrolling phase.
470 MomentumPhase, // Momentum phase.
471 };
472
473 int x;
474 int y;
475 int globalX;
476 int globalY;
477 WebGestureDevice sourceDevice;
478
479 // If the WebGestureEvent has sourceDevice=WebGestureDeviceTouchscreen, this
480 // field contains the unique identifier for the touch event that released
481 // this event at TouchDispositionGestureFilter. If the WebGestureEvents was
482 // not released through a touch event (e.g. timer-released gesture events or
483 // gesture events with sourceDevice!=WebGestureDeviceTouchscreen), the field
484 // contains 0. See crbug.com/618738.
485 uint32_t uniqueTouchEventId;
486
487 // This field exists to allow BrowserPlugin to mark GestureScroll events as
488 // 'resent' to handle the case where an event is not consumed when first
489 // encountered; it should be handled differently by the plugin when it is
490 // sent for thesecond time. No code within Blink touches this, other than to
491 // plumb it through event conversions.
492 int resendingPluginId;
493
494 union {
495 // Tap information must be set for GestureTap, GestureTapUnconfirmed,
496 // and GestureDoubleTap events.
497 struct {
498 int tapCount;
499 float width;
500 float height;
501 } tap;
502
503 struct {
504 float width;
505 float height;
506 } tapDown;
507
508 struct {
509 float width;
510 float height;
511 } showPress;
512
513 struct {
514 float width;
515 float height;
516 } longPress;
517
518 struct {
519 float firstFingerWidth;
520 float firstFingerHeight;
521 } twoFingerTap;
522
523 struct {
524 // Initial motion that triggered the scroll.
525 // May be redundant with deltaX/deltaY in the first scrollUpdate.
526 float deltaXHint;
527 float deltaYHint;
528 // Default initialized to ScrollUnits::PrecisePixels.
529 ScrollUnits deltaHintUnits;
530 // If true, this event will skip hit testing to find a scroll
531 // target and instead just scroll the viewport.
532 bool targetViewport;
533 // The state of inertial phase scrolling. OSX has unique phases for normal and
534 // momentum scroll events. Should always be UnknownMomentumPhase for touch based
535 // input as it generates GestureFlingStart instead.
536 InertialPhaseState inertialPhase;
537 // True if this event was synthesized in order to force a hit test; avoiding scroll
538 // latching behavior until crbug.com/526463 is fully implemented.
539 bool synthetic;
540 } scrollBegin;
541
542 struct {
543 float deltaX;
544 float deltaY;
545 float velocityX;
546 float velocityY;
547 // Whether any previous GestureScrollUpdate in the current scroll
548 // sequence was suppressed (e.g., the causal touchmove was
549 // preventDefault'ed). This bit is particularly useful for
550 // determining whether the observed scroll update sequence captures
551 // the entirety of the generative motion.
552 bool previousUpdateInSequencePrevented;
553 bool preventPropagation;
554 InertialPhaseState inertialPhase;
555 // Default initialized to ScrollUnits::PrecisePixels.
556 ScrollUnits deltaUnits;
557 } scrollUpdate;
558
559 struct {
560 // The original delta units the scrollBegin and scrollUpdates
561 // were sent as.
562 ScrollUnits deltaUnits;
563 // The state of inertial phase scrolling. OSX has unique phases for normal and
564 // momentum scroll events. Should always be UnknownMomentumPhase for touch based
565 // input as it generates GestureFlingStart instead.
566 InertialPhaseState inertialPhase;
567 // True if this event was synthesized in order to generate the prope r
568 // GSB/GSU/GSE matching sequences. This is a temporary so that a fut ure
569 // GSB will generate a hit test so latching behavior is avoided
570 // until crbug.com/526463 is fully implemented.
571 bool synthetic;
572 } scrollEnd;
573
574 struct {
575 float velocityX;
576 float velocityY;
577 // If true, this event will skip hit testing to find a scroll
578 // target and instead just scroll the viewport.
579 bool targetViewport;
580 } flingStart;
581
582 struct {
583 // If set to true, don't treat flingCancel
584 // as a part of fling boost events sequence.
585 bool preventBoosting;
586 } flingCancel;
587
588 struct {
589 bool zoomDisabled;
590 float scale;
591 } pinchUpdate;
592 } data;
593
594 WebGestureEvent()
595 : WebInputEvent(sizeof(WebGestureEvent))
596 , x(0)
597 , y(0)
598 , globalX(0)
599 , globalY(0)
600 , sourceDevice(WebGestureDeviceUninitialized)
601 , resendingPluginId(-1)
602 {
603 memset(&data, 0, sizeof(data));
604 }
605 };
606
607 // WebTouchEvent --------------------------------------------------------------
608
609 // TODO(e_hakkinen): Replace with WebPointerEvent. crbug.com/508283
610 class WebTouchEvent : public WebInputEvent {
611 public:
612 // Maximum number of simultaneous touches supported on
613 // Ash/Aura.
614 enum { touchesLengthCap = 16 };
615
616 unsigned touchesLength;
617 // List of all touches, regardless of state.
618 WebTouchPoint touches[touchesLengthCap];
619
620 // Whether the event is blocking, non-blocking, all event
621 // listeners were passive or was forced to be non-blocking.
622 DispatchType dispatchType;
623
624 // For a single touch, this is true after the touch-point has moved beyond
625 // the platform slop region. For a multitouch, this is true after any
626 // touch-point has moved (by whatever amount).
627 bool movedBeyondSlopRegion;
628
629 // Whether there was an active fling animation when the event was
630 // dispatched.
631 bool dispatchedDuringFling;
632
633 // A unique identifier for the touch event. Valid ids start at one and
634 // increase monotonically. Zero means an unknown id.
635 uint32_t uniqueTouchEventId;
636
637 WebTouchEvent()
638 : WebInputEvent(sizeof(WebTouchEvent))
639 , touchesLength(0)
640 , dispatchType(Blocking)
641 , movedBeyondSlopRegion(false)
642 , dispatchedDuringFling(false)
643 , uniqueTouchEventId(0)
644 {
645 }
646 };
647
648 #pragma pack(pop)
649
650 } // namespace blink
651
652 #endif
OLDNEW
« no previous file with comments | « third_party/WebKit/public/platform/WebTouchPoint.h ('k') | third_party/WebKit/public/web/WebTouchPoint.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698