Articulate the cancel behavior in the WebTouchEvent.

third_party/WebKit/public/web/WebInputEvent.h

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 171 matching lines @@
         IsComposing      = 1 << 14,
 
         AltGrKey         = 1 << 15,
         OSKey            = 1 << 16,
         FnKey            = 1 << 17,
         SymbolKey        = 1 << 18,
 
         ScrollLockOn     = 1 << 19,
     };
 
+    enum DispatchType {
+        Blocking,
+        NonBlocking,

[tdresser, 2016/04/18 15:12:03]

The difference between NonBlocking and NonBlockingPassive isn't super clear
here.

NonBlocking indicates that we don't block due to a property of the event,
whereas NonBlockingPassive indicates that we don't block due to a property of
the event listener, correct?

Should we split this up into a HandlerBlockingType and uh... maybe
EventBlockingType?

I'm not super happy with that but it would clarify that we're talking about two
separate axis here, which isn't obvious with the current enum.

Alternatively, maybe renaming to something like:

enum DispatchType {
  Blocking,
  EventNonBlocking,
  ListenersNonBlockingPassive
  ListenersForcedNonBlockingPassive
}

I'm not big on DispatchType either, but I haven't come up with anything great.

Maybe just "BlockingType"? Or "BlockOnAckType"?

[Rick Byers, 2016/04/18 16:57:58]

IMHO the important thing is that it's clear that there are really only 2
behaviors as far as the application is concerned: cancelable and not cancelable.
 The rest of the division is just for our own internal bookkeeping /
measurements (or exposed diagnostics/tooling) around WHY something is not
cancelable.  With appropriate comments to that effect, the proposal here seems
fine to me.

I could also imagine an argument for making this super explicit by keeping
cancelable a bool and adding a NonBlockingReason which is defined explicitly to
not change semantics but just inform measurements / tooling (it's not like space
is at a premium here since there's never more than a few of these alive at once
- no reason to worry about packing tightly).

[dtapuska, 2016/04/18 19:19:33]

Acknowledged.

[dtapuska, 2016/04/18 19:19:33]

Done.

+        // All listeners are passive.
+        NonBlockingPassive,
+        // This value represents a state which would have normally blocking
+        // but was forced to be non-blocking.
+        NonBlockingForced,
+    };
+
     // The rail mode for a wheel event specifies the axis on which scrolling is
     // expected to stick. If this axis is set to Free, then scrolling is not
     // stuck to any axis.
     enum RailsMode {
         RailsModeFree       = 0,
         RailsModeHorizontal = 1,
         RailsModeVertical   = 2,
     };
 
     static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
@@ skipping 393 matching lines @@
 class WebTouchEvent : public WebInputEvent {
 public:
     // Maximum number of simultaneous touches supported on
     // Ash/Aura.
     enum { touchesLengthCap = 16 };
 
     unsigned touchesLength;
     // List of all touches, regardless of state.
     WebTouchPoint touches[touchesLengthCap];
 
-    // Whether the event can be canceled (with preventDefault). If true then the browser
-    // must wait for an ACK for this event. If false then no ACK IPC is expected.
-    bool cancelable;
+    // Whether the event is blocking or not.

[tdresser, 2016/04/18 15:12:03]

This comment is a bit terse. Maybe add a bit more detail?

[dtapuska, 2016/04/18 19:19:33]

Done.

+    DispatchType dispatchType;
 
     // For a single touch, this is true after the touch-point has moved beyond
     // the platform slop region. For a multitouch, this is true after any
     // touch-point has moved (by whatever amount).
     bool movedBeyondSlopRegion;
 
     // A unique identifier for the touch event.
     uint32_t uniqueTouchEventId;
 
     WebTouchEvent()
         : WebInputEvent(sizeof(WebTouchEvent))
         , touchesLength(0)
-        , cancelable(true)
+        , dispatchType(Blocking)
         , movedBeyondSlopRegion(false)
         , uniqueTouchEventId(0)
     {
     }
 };
 
 #pragma pack(pop)
 
 } // namespace blink
 
 #endif