Prevent implicit WebInputEvent construction from WebInputEvent::Type

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 40 matching lines @@
 // properly and don't have paddings/gaps, otherwise memory check tools
 // like Valgrind will complain about uninitialized memory usage when
 // transferring these classes over the wire.
 
 #pragma pack(push, 4)
 
 // WebInputEvent --------------------------------------------------------------
 
 class WebInputEvent {
 public:
-    WebInputEvent(unsigned sizeParam = sizeof(WebInputEvent))
-    {
-        memset(this, 0, sizeParam);
-        timeStampSeconds = 0.0;
-        size = sizeParam;
-        type = Undefined;
-        modifiers = 0;
-    }
-
     // When we use an input method (or an input method editor), we receive
     // two events for a keypress. The former event is a keydown, which
     // provides a keycode, and the latter is a textinput, which provides
     // a character processed by an input method. (The mapping from a
     // keycode to a character code is not trivial for non-English
     // keyboards.)
     // To support input methods, Safari sends keydown events to WebKit for
     // filtering. WebKit sends filtered keydown events back to Safari,
     // which sends them to input methods.
     // Unfortunately, it is hard to apply this design to Chrome because of
@@ skipping 137 matching lines @@
             || type == MouseUp
             || type == TouchStart
             || type == TouchEnd;
     }
 
     // Returns true if the WebInputEvent is a gesture event.
     static bool isGestureEventType(int type)
     {
         return GestureTypeFirst <= type && type <= GestureTypeLast;
     }
+
+protected:
+    explicit WebInputEvent(unsigned sizeParam)
+    {
+        memset(this, 0, sizeParam);
+        timeStampSeconds = 0.0;
+        size = sizeParam;
+        type = Undefined;
+        modifiers = 0;
+    }
 };
 
 // WebKeyboardEvent -----------------------------------------------------------
 
 class WebKeyboardEvent : public WebInputEvent {
 public:
     // Caps on string lengths so we can make them static arrays and keep
     // them PODs.
     static const size_t textLengthCap = 4;
 
@@ skipping 30 matching lines @@
     // shift).  This is useful for working out shortcut keys.  Linux and
     // Windows guarantee one character per event.  The Mac does not, but in
     // reality that's all it ever gives.  We're generous, and cap it a bit
     // longer.
     WebUChar text[textLengthCap];
     WebUChar unmodifiedText[textLengthCap];
 
     // This is a string identifying the key pressed.
     char keyIdentifier[keyIdentifierLengthCap];
 
-    WebKeyboardEvent(unsigned sizeParam = sizeof(WebKeyboardEvent))
-        : WebInputEvent(sizeParam)
+    WebKeyboardEvent()
+        : WebInputEvent(sizeof(WebKeyboardEvent))
         , windowsKeyCode(0)
         , nativeKeyCode(0)
         , isSystemKey(false)
     {
         memset(&text, 0, sizeof(text));
         memset(&unmodifiedText, 0, sizeof(unmodifiedText));
         memset(&keyIdentifier, 0, sizeof(keyIdentifier));
     }
 
     // Sets keyIdentifier based on the value of windowsKeyCode.  This is
@@ skipping 19 matching lines @@
     int x;
     int y;
     int windowX;
     int windowY;
     int globalX;
     int globalY;
     int movementX;
     int movementY;
     int clickCount;
 
-    WebMouseEvent(unsigned sizeParam = sizeof(WebMouseEvent))
+    WebMouseEvent()
+        : WebInputEvent(sizeof(WebMouseEvent))
+        , button(ButtonNone)
+        , x(0)
+        , y(0)
+        , windowX(0)
+        , windowY(0)
+        , globalX(0)
+        , globalY(0)
+        , movementX(0)
+        , movementY(0)
+        , clickCount(0)
+    {
+    }
+
+protected:
+    explicit WebMouseEvent(unsigned sizeParam)
         : WebInputEvent(sizeParam)
         , button(ButtonNone)
         , x(0)
         , y(0)
         , windowX(0)
         , windowY(0)
         , globalX(0)
         , globalY(0)
         , movementX(0)
         , movementY(0)
@@ skipping 43 matching lines @@
     // an alternate effect. The common case is that a scroll in the left or
     // right directions causes a back or forwards navigation, respectively.
     //
     // These flags prevent rubber banding from starting in a given direction,
     // but have no effect on an ongoing rubber banding. A rubber banding that
     // started in the vertical direction is allowed to continue in the right
     // direction, even if canRubberbandRight is 0.
     int canRubberbandLeft;
     int canRubberbandRight;
 
-    WebMouseWheelEvent(unsigned sizeParam = sizeof(WebMouseWheelEvent))
-        : WebMouseEvent(sizeParam)
+    WebMouseWheelEvent()
+        : WebMouseEvent(sizeof(WebMouseWheelEvent))
         , deltaX(0.0f)
         , deltaY(0.0f)
         , wheelTicksX(0.0f)
         , wheelTicksY(0.0f)
         , accelerationRatioX(1.0f)
         , accelerationRatioY(1.0f)
         , scrollByPage(false)
         , hasPreciseScrollingDeltas(false)
         , phase(PhaseNone)
         , momentumPhase(PhaseNone)
@@ skipping 64 matching lines @@
         struct {
             float velocityX;
             float velocityY;
         } flingStart;
 
         struct {
             float scale;
         } pinchUpdate;
     } data;
 
-    WebGestureEvent(unsigned sizeParam = sizeof(WebGestureEvent))
-        : WebInputEvent(sizeParam)
+    WebGestureEvent()
+        : WebInputEvent(sizeof(WebGestureEvent))
         , x(0)
         , y(0)
         , globalX(0)
         , globalY(0)
     {
         memset(&data, 0, sizeof(data));
     }
 };
 
 // WebTouchEvent --------------------------------------------------------------
 
 class WebTouchEvent : public WebInputEvent {
 public:
     // Maximum number of simultaneous touches supported on
     // Ash/Aura.
     enum { touchesLengthCap = 12 };
 
     unsigned touchesLength;
     // List of all touches which are currently down.
     WebTouchPoint touches[touchesLengthCap];
 
     unsigned changedTouchesLength;
     // List of all touches whose state has changed since the last WebTouchEvent
     WebTouchPoint changedTouches[touchesLengthCap];
 
     unsigned targetTouchesLength;
     // List of all touches which are currently down and are targeting the event recipient.
     WebTouchPoint targetTouches[touchesLengthCap];
 
-    WebTouchEvent(unsigned sizeParam = sizeof(WebTouchEvent))
-        : WebInputEvent(sizeParam)
+    WebTouchEvent()
+        : WebInputEvent(sizeof(WebTouchEvent))
         , touchesLength(0)
         , changedTouchesLength(0)
         , targetTouchesLength(0)
     {
     }
 };
 
 #pragma pack(pop)
 
 } // namespace blink
 
 #endif