Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/public/platform/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 209 matching lines @@
   enum RailsMode {
     RailsModeFree = 0,
     RailsModeHorizontal = 1,
     RailsModeVertical = 2,
   };
 
   static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
 
   static constexpr double TimeStampForTesting = 123.0;
 
-  double timeStampSeconds;  // Seconds since platform start with microsecond
-                            // resolution.
-  unsigned size;            // The size of this structure, for serialization.
-  Type type;
-  int modifiers;
-
   // Returns true if the WebInputEvent |type| is a mouse event.
   static bool isMouseEventType(int type) {
     return MouseTypeFirst <= type && type <= MouseTypeLast;
   }
 
   // Returns true if the WebInputEvent |type| is a keyboard event.
   static bool isKeyboardEventType(int type) {
     return KeyboardTypeFirst <= type && type <= KeyboardTypeLast;
   }
 
   // Returns true if the WebInputEvent |type| is a touch event.
   static bool isTouchEventType(int type) {
     return TouchTypeFirst <= type && type <= TouchTypeLast;
   }
 
   // Returns true if the WebInputEvent is a gesture event.
   static bool isGestureEventType(int type) {
     return GestureTypeFirst <= type && type <= GestureTypeLast;
   }
 
   bool isSameEventClass(const WebInputEvent& other) const {
-    if (isMouseEventType(type))
-      return isMouseEventType(other.type);
-    if (isGestureEventType(type))
-      return isGestureEventType(other.type);
-    if (isTouchEventType(type))
-      return isTouchEventType(other.type);
-    if (isKeyboardEventType(type))
-      return isKeyboardEventType(other.type);
-    return type == other.type;
+    if (isMouseEventType(m_type))
+      return isMouseEventType(other.m_type);
+    if (isGestureEventType(m_type))
+      return isGestureEventType(other.m_type);
+    if (isTouchEventType(m_type))
+      return isTouchEventType(other.m_type);
+    if (isKeyboardEventType(m_type))
+      return isKeyboardEventType(other.m_type);
+    return m_type == other.m_type;
   }
 
   BLINK_COMMON_EXPORT static const char* GetName(WebInputEvent::Type);
 
-  void setType(Type typeParam) { type = typeParam; }
+  Type type() const { return m_type; }
+  void setType(Type typeParam) { m_type = typeParam; }
 
-  void setModifiers(int modifiersParam) { modifiers = modifiersParam; }
+  int modifiers() const { return m_modifiers; }
+  void setModifiers(int modifiersParam) { m_modifiers = modifiersParam; }
 
-  void setTimeStampSeconds(double seconds) { timeStampSeconds = seconds; }
+  double timeStampSeconds() const { return m_timeStampSeconds; }
+  void setTimeStampSeconds(double seconds) { m_timeStampSeconds = seconds; }
+
+  unsigned size() const { return m_size; }
 
  protected:
   WebInputEvent(unsigned sizeParam,
                 Type typeParam,
                 int modifiersParam,
                 double timeStampSecondsParam) {
     memset(this, 0, sizeParam);

[esprehn, 2016/12/14 19:03:05]

It's very weird to memset yourself once you're a real class with members, can we
add actual init for the members instead?

[dtapuska, 2017/01/12 16:45:13]

I've added a TODO. I think the memset is necessary because this object is sent
across the IPC boundary. Once we have fully moved to mojo we remove it to ensure
we don't leak process memory from the browser process.

-    timeStampSeconds = timeStampSecondsParam;
-    size = sizeParam;
-    type = typeParam;
-    modifiers = modifiersParam;
+    m_timeStampSeconds = timeStampSecondsParam;
+    m_size = sizeParam;
+    m_type = typeParam;
+    m_modifiers = modifiersParam;
   }
 
   explicit WebInputEvent(unsigned sizeParam) {
     memset(this, 0, sizeParam);
-    timeStampSeconds = 0.0;
-    size = sizeParam;
-    type = Undefined;
+    m_timeStampSeconds = 0.0;

[esprehn, 2016/12/14 19:03:05]

this is a duplicate of the memset?

[dtapuska, 2017/01/12 16:45:13]

The code was that way before and I presume someone didn't want to assume the
float representation of 0.0 was all zeros in memory. But I can remove it if you
have a big concern.

+    m_size = sizeParam;
+    m_type = Undefined;
   }
+
+  double m_timeStampSeconds;  // Seconds since platform start with microsecond
+                              // resolution.
+  unsigned m_size;            // The size of this structure, for serialization.
+  Type m_type;
+  int m_modifiers;
 };
 
 // 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 215 matching lines @@
   WebTouchEvent(Type type, int modifiers, double timeStampSeconds)
       : WebInputEvent(sizeof(WebTouchEvent), type, modifiers, timeStampSeconds),
         dispatchType(Blocking) {}
 };
 
 #pragma pack(pop)
 
 }  // namespace blink
 
 #endif