IPC::ParamTraits for ui::Event (towards ui::Events over mojo IPC)

ui/events/ipc/event_param_traits.cc

+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/events/ipc/event_param_traits.h"
+
+#include <string.h>
+
+#include "ipc/ipc_message_utils.h"
+#include "ipc/ipc_param_traits.h"
+#include "ui/events/event.h"
+#include "ui/gfx/ipc/gfx_param_traits.h"
+
+// Generate param traits size methods.
+#include "ipc/param_traits_size_macros.h"
+namespace IPC {
+#include "ui/events/ipc/event_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits write methods.
+#include "ipc/param_traits_write_macros.h"
+namespace IPC {
+#include "ui/events/ipc/event_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits read methods.
+#include "ipc/param_traits_read_macros.h"
+namespace IPC {
+#include "ui/events/ipc/event_param_traits_macros.h"
+}  // namespace IPC
+
+// Generate param traits log methods.
+#include "ipc/param_traits_log_macros.h"
+namespace IPC {
+#include "ui/events/ipc/event_param_traits_macros.h"
+}  // namespace IPC
+
+namespace IPC {
+
+// Implements (Write|Read|Log)Event for event type-qualified functions. Every
+// such function invokes an implementation according to the event type and
+// flags, or else invokes a default implementation. Event constructors require
+// |type|, |time_stamp|, and |flags| (hence the common arguments passed to each
+// implementation).
+#define EVENT_IMPL(ReturnType, methodName, implName, defaultCase, ...)  \
+  ReturnType ParamTraits<ui::ScopedEvent>::methodName(                  \
+      ui::EventType type, base::TimeDelta time_stamp, int flags,        \
+      ##__VA_ARGS__) {                                                  \
+    switch (type) {                                                     \
+      case ui::EventType::ET_MOUSE_PRESSED:                             \
+      case ui::EventType::ET_MOUSE_DRAGGED:                             \
+      case ui::EventType::ET_MOUSE_RELEASED:                            \
+      case ui::EventType::ET_MOUSE_MOVED:                               \
+      case ui::EventType::ET_MOUSE_ENTERED:                             \
+      case ui::EventType::ET_MOUSE_EXITED:                              \
+      case ui::EventType::ET_MOUSE_CAPTURE_CHANGED:                     \
+        implName(ui::MouseEvent)                                        \
+      case ui::EventType::ET_KEY_PRESSED:                               \
+      case ui::EventType::ET_KEY_RELEASED:                              \
+        implName(ui::KeyEvent)                                          \
+      case ui::EventType::ET_MOUSEWHEEL:                                \
+        implName(ui::MouseWheelEvent)                                   \
+      case ui::EventType::ET_TOUCH_RELEASED:                            \
+      case ui::EventType::ET_TOUCH_PRESSED:                             \
+      case ui::EventType::ET_TOUCH_MOVED:                               \
+      case ui::EventType::ET_TOUCH_CANCELLED:                           \
+      case ui::EventType::ET_DROP_TARGET_EVENT:                         \
+        implName(ui::TouchEvent)                                        \
+      case ui::EventType::ET_GESTURE_SCROLL_BEGIN:                      \
+      case ui::EventType::ET_GESTURE_SCROLL_END:                        \
+      case ui::EventType::ET_GESTURE_SCROLL_UPDATE:                     \
+      case ui::EventType::ET_GESTURE_SHOW_PRESS:                        \
+      case ui::EventType::ET_GESTURE_WIN8_EDGE_SWIPE:                   \
+      case ui::EventType::ET_GESTURE_TAP:                               \
+      case ui::EventType::ET_GESTURE_TAP_DOWN:                          \
+      case ui::EventType::ET_GESTURE_TAP_CANCEL:                        \
+      case ui::EventType::ET_GESTURE_BEGIN:                             \
+      case ui::EventType::ET_GESTURE_END:                               \
+      case ui::EventType::ET_GESTURE_TWO_FINGER_TAP:                    \
+      case ui::EventType::ET_GESTURE_PINCH_BEGIN:                       \
+      case ui::EventType::ET_GESTURE_PINCH_END:                         \
+      case ui::EventType::ET_GESTURE_PINCH_UPDATE:                      \
+      case ui::EventType::ET_GESTURE_LONG_PRESS:                        \
+      case ui::EventType::ET_GESTURE_LONG_TAP:                          \
+      case ui::EventType::ET_GESTURE_SWIPE:                             \
+      case ui::EventType::ET_GESTURE_TAP_UNCONFIRMED:                   \
+      case ui::EventType::ET_GESTURE_DOUBLE_TAP:                        \
+        implName(ui::GestureEvent)                                      \
+      case ui::EventType::ET_SCROLL:                                    \
+        implName(ui::ScrollEvent)                                       \
+      case ui::EventType::ET_SCROLL_FLING_START:                        \
+      case ui::EventType::ET_SCROLL_FLING_CANCEL:                       \
+        if (flags & ui::MouseEventFlags::EF_FROM_TOUCH) {               \
+          implName(ui::GestureEvent)                                    \
+        } else {                                                        \
+          implName(ui::MouseEvent)                                      \
+        }                                                               \
+      case ui::EventType::ET_CANCEL_MODE:                               \
+        implName(ui::CancelModeEvent)                                   \
+      default:                                                          \
+        defaultCase;                                                    \
+    }                                                                   \
+  }
+
+// Concrete event type (T) implementation procedures: size, write, read, log.
+#define CAST_EVENT(T) (*static_cast<T*>(p.get()))

[Tom Sepez, 2016/02/18 18:46:10]

nit: I'd suggest removing CAST_EVENT and SIZE_EVENT at the cost of source size
to increase transparency.

[Mark Dittmer, 2016/02/18 19:12:56]

Can we meet in the middle and just eliminate CAST_EVENT? SIZE_EVENT is used as
an implName for EVENT_IMPL.

+#define SIZE_EVENT(T) ParamTraits<T>::GetSize(s, CAST_EVENT(T));
+#define WRITE_EVENT(T)                     \
+  ParamTraits<T>::Write(m, CAST_EVENT(T)); \
+  break;
+#define READ_EVENT(T)                                    \
+  {                                                      \
+    scoped_ptr<T> event(new T(type, time_stamp, flags)); \
+    if (!ParamTraits<T>::Read(m, iter, event.get())) {   \
+      p->reset();                                        \
+      return false;                                      \
+    } else {                                             \
+      *p = std::move(event);                             \
+      return true;                                       \
+    }                                                    \
+  }
+#define LOG_EVENT(T) return ParamTraits<T>::Log(CAST_EVENT(T), l);
+
+// void SizeEvent(ui::EventType type, int flags, base::PickleSizer* s,
+//                const ui::ScopedEvent& p) { ... }
+EVENT_IMPL(void,
+           SizeEvent,
+           SIZE_EVENT,
+           /* default switch/case: no-op */,
+           base::PickleSizer* s,
+           const ui::ScopedEvent& p)
+
+// void WriteEvent(ui::EventType type, int flags, base::Pickle* m,
+//                 const ui::ScopedEvent& p) { ... }
+EVENT_IMPL(void,
+           WriteEvent,
+           WRITE_EVENT,
+           /* default switch/case: no-op */,
+           base::Pickle* m,
+           const ui::ScopedEvent& p)
+
+// bool ReadEvent(ui::EventType type, int flags, base::Pickle* m,
+//                base::PickleIterator* iter, ui::ScopedEvent* p) { ... }
+EVENT_IMPL(bool,
+           ReadEvent,
+           READ_EVENT,
+           return false;,
+           const base::Pickle* m,
+           base::PickleIterator* iter,
+           ui::ScopedEvent* p)
+
+// void LogEvent(ui::EventType type, int flags, const ui::ScopedEvent& p,
+//               std::string* l) { ... }
+EVENT_IMPL(void,
+           LogEvent,
+           LOG_EVENT,
+           /* default switch/case: no-op */,
+           const ui::ScopedEvent& p,
+           std::string* l)
+
+#undef CAST_EVENT
+#undef SIZE_EVENT
+#undef WRITE_EVENT
+#undef READ_EVENT
+#undef LOG_EVENT
+#undef EVENT_IMPL
+
+void ParamTraits<ui::ScopedEvent>::GetSize(base::PickleSizer* s,
+                                           const param_type& p) {
+  DCHECK(p);
+  GetParamSize(s, p->type_);
+  GetParamSize(s, p->name_);
+  GetParamSize(s, p->time_stamp_);
+  GetParamSize(s, p->flags_);
+  GetParamSize(s, p->phase_);
+  GetParamSize(s, p->result_);
+  GetParamSize(s, p->cancelable_);
+  SizeEvent(p->type_, p->time_stamp_, p->flags_, s, p);
+}
+
+void ParamTraits<ui::ScopedEvent>::Write(base::Pickle* m, const param_type& p) {
+  DCHECK(p);
+  WriteParam(m, p->type_);
+  WriteParam(m, p->name_);
+  WriteParam(m, p->time_stamp_);
+  WriteParam(m, p->flags_);
+  WriteParam(m, p->phase_);
+  WriteParam(m, p->result_);
+  WriteParam(m, p->cancelable_);
+  WriteEvent(p->type_, p->time_stamp_, p->flags_, m, p);
+}
+
+bool ParamTraits<ui::ScopedEvent>::Read(const base::Pickle* m,
+                                        base::PickleIterator* iter,
+                                        param_type* p) {
+  // Expect: valid ui::ScopedEvent that does not (yet) point to anything.
+  DCHECK(p && !*p);
+
+  ui::EventType type;
+  std::string name;
+  base::TimeDelta time_stamp;
+  int flags;
+  ui::EventPhase phase;
+  ui::EventResult result;
+  int cancelable;
+
+  // Read initial params, then invoke ReadEvent which will reset() |p| to an
+  // instance of the correct concrete event type.
+  if (!ReadParam(m, iter, &type) || !ReadParam(m, iter, &name) ||
+      !ReadParam(m, iter, &time_stamp) || !ReadParam(m, iter, &flags) ||
+      !ReadParam(m, iter, &phase) || !ReadParam(m, iter, &result) ||
+      !ReadParam(m, iter, &cancelable) ||
+      !ReadEvent(type, time_stamp, flags, m, iter, p))
+    return false;
+
+  // Fill in abstract event information.
+  (*p)->type_ = type;
+  (*p)->name_ = name;
+  (*p)->time_stamp_ = time_stamp;
+  (*p)->flags_ = flags;
+  (*p)->phase_ = phase;
+  (*p)->result_ = result;
+  (*p)->cancelable_ = cancelable;
+
+  return true;
+}
+
+void ParamTraits<ui::ScopedEvent>::Log(const param_type& p, std::string* l) {
+  l->append("<UI Event: ");
+  LogEvent(p->type_, p->time_stamp_, p->flags_, p, l);
+  l->append(">");
+}
+
+void ParamTraits<ui::CancelModeEvent>::GetSize(base::PickleSizer* s,
+                                               const param_type& p) {}
+
+void ParamTraits<ui::CancelModeEvent>::Write(base::Pickle* m,
+                                             const param_type& p) {}
+
+bool ParamTraits<ui::CancelModeEvent>::Read(const base::Pickle* m,
+                                            base::PickleIterator* iter,
+                                            param_type* p) {
+  return true;
+}
+
+void ParamTraits<ui::CancelModeEvent>::Log(const param_type& p,
+                                           std::string* l) {
+  l->append("<ui::CancelModeEvent>");
+}
+
+void ParamTraits<ui::GestureEventDetails::Details>::GetSize(
+    base::PickleSizer* s,
+    const param_type& p) {
+  s->AddBytes(sizeof(param_type));
+}
+
+void ParamTraits<ui::GestureEventDetails::Details>::Write(base::Pickle* m,
+                                                          const param_type& p) {
+  m->WriteBytes(&p, sizeof(param_type));
+}
+
+bool ParamTraits<ui::GestureEventDetails::Details>::Read(
+    const base::Pickle* m,
+    base::PickleIterator* iter,
+    param_type* p) {
+  const char* data;
+  if (!iter->ReadBytes(&data, sizeof(param_type)))
+    return false;
+
+  memcpy(p, data, sizeof(param_type));
+  return true;
+}
+
+void ParamTraits<ui::GestureEventDetails::Details>::Log(const param_type& p,
+                                                        std::string* l) {
+  l->append("<ui::GestureEventDetails::Details>");
+}
+
+}  // namespace IPC