| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "ui/events/ipc/event_param_traits.h" |
| 6 |
| 7 #include <string.h> |
| 8 |
| 9 #include "ipc/ipc_message_utils.h" |
| 10 #include "ipc/ipc_param_traits.h" |
| 11 #include "ui/events/event.h" |
| 12 #include "ui/gfx/ipc/gfx_param_traits.h" |
| 13 |
| 14 // Generate param traits size methods. |
| 15 #include "ipc/param_traits_size_macros.h" |
| 16 namespace IPC { |
| 17 #include "ui/events/ipc/event_param_traits_macros.h" |
| 18 } // namespace IPC |
| 19 |
| 20 // Generate param traits write methods. |
| 21 #include "ipc/param_traits_write_macros.h" |
| 22 namespace IPC { |
| 23 #include "ui/events/ipc/event_param_traits_macros.h" |
| 24 } // namespace IPC |
| 25 |
| 26 // Generate param traits read methods. |
| 27 #include "ipc/param_traits_read_macros.h" |
| 28 namespace IPC { |
| 29 #include "ui/events/ipc/event_param_traits_macros.h" |
| 30 } // namespace IPC |
| 31 |
| 32 // Generate param traits log methods. |
| 33 #include "ipc/param_traits_log_macros.h" |
| 34 namespace IPC { |
| 35 #include "ui/events/ipc/event_param_traits_macros.h" |
| 36 } // namespace IPC |
| 37 |
| 38 namespace IPC { |
| 39 |
| 40 // Implements (Write|Read|Log)Event for event type-qualified functions. Every |
| 41 // such function invokes an implementation according to the event type and |
| 42 // flags, or else invokes a default implementation. Event constructors require |
| 43 // |type|, |time_stamp|, and |flags| (hence the common arguments passed to each |
| 44 // implementation). |
| 45 #define EVENT_IMPL(ReturnType, methodName, implName, defaultCase, ...) \ |
| 46 ReturnType ParamTraits<ui::ScopedEvent>::methodName( \ |
| 47 ui::EventType type, base::TimeDelta time_stamp, int flags, \ |
| 48 ##__VA_ARGS__) { \ |
| 49 switch (type) { \ |
| 50 case ui::EventType::ET_MOUSE_PRESSED: \ |
| 51 case ui::EventType::ET_MOUSE_DRAGGED: \ |
| 52 case ui::EventType::ET_MOUSE_RELEASED: \ |
| 53 case ui::EventType::ET_MOUSE_MOVED: \ |
| 54 case ui::EventType::ET_MOUSE_ENTERED: \ |
| 55 case ui::EventType::ET_MOUSE_EXITED: \ |
| 56 case ui::EventType::ET_MOUSE_CAPTURE_CHANGED: \ |
| 57 implName(ui::MouseEvent) \ |
| 58 case ui::EventType::ET_KEY_PRESSED: \ |
| 59 case ui::EventType::ET_KEY_RELEASED: \ |
| 60 implName(ui::KeyEvent) \ |
| 61 case ui::EventType::ET_MOUSEWHEEL: \ |
| 62 implName(ui::MouseWheelEvent) \ |
| 63 case ui::EventType::ET_TOUCH_RELEASED: \ |
| 64 case ui::EventType::ET_TOUCH_PRESSED: \ |
| 65 case ui::EventType::ET_TOUCH_MOVED: \ |
| 66 case ui::EventType::ET_TOUCH_CANCELLED: \ |
| 67 case ui::EventType::ET_DROP_TARGET_EVENT: \ |
| 68 implName(ui::TouchEvent) \ |
| 69 case ui::EventType::ET_GESTURE_SCROLL_BEGIN: \ |
| 70 case ui::EventType::ET_GESTURE_SCROLL_END: \ |
| 71 case ui::EventType::ET_GESTURE_SCROLL_UPDATE: \ |
| 72 case ui::EventType::ET_GESTURE_SHOW_PRESS: \ |
| 73 case ui::EventType::ET_GESTURE_WIN8_EDGE_SWIPE: \ |
| 74 case ui::EventType::ET_GESTURE_TAP: \ |
| 75 case ui::EventType::ET_GESTURE_TAP_DOWN: \ |
| 76 case ui::EventType::ET_GESTURE_TAP_CANCEL: \ |
| 77 case ui::EventType::ET_GESTURE_BEGIN: \ |
| 78 case ui::EventType::ET_GESTURE_END: \ |
| 79 case ui::EventType::ET_GESTURE_TWO_FINGER_TAP: \ |
| 80 case ui::EventType::ET_GESTURE_PINCH_BEGIN: \ |
| 81 case ui::EventType::ET_GESTURE_PINCH_END: \ |
| 82 case ui::EventType::ET_GESTURE_PINCH_UPDATE: \ |
| 83 case ui::EventType::ET_GESTURE_LONG_PRESS: \ |
| 84 case ui::EventType::ET_GESTURE_LONG_TAP: \ |
| 85 case ui::EventType::ET_GESTURE_SWIPE: \ |
| 86 case ui::EventType::ET_GESTURE_TAP_UNCONFIRMED: \ |
| 87 case ui::EventType::ET_GESTURE_DOUBLE_TAP: \ |
| 88 implName(ui::GestureEvent) \ |
| 89 case ui::EventType::ET_SCROLL: \ |
| 90 implName(ui::ScrollEvent) \ |
| 91 case ui::EventType::ET_SCROLL_FLING_START: \ |
| 92 case ui::EventType::ET_SCROLL_FLING_CANCEL: \ |
| 93 if (flags & ui::MouseEventFlags::EF_FROM_TOUCH) { \ |
| 94 implName(ui::GestureEvent) \ |
| 95 } else { \ |
| 96 implName(ui::MouseEvent) \ |
| 97 } \ |
| 98 case ui::EventType::ET_CANCEL_MODE: \ |
| 99 implName(ui::CancelModeEvent) \ |
| 100 default: \ |
| 101 defaultCase; \ |
| 102 } \ |
| 103 } |
| 104 |
| 105 // Concrete event type (T) implementation procedures: size, write, read, log. |
| 106 #define CAST_EVENT(T) (*static_cast<T*>(p.get())) |
| 107 #define SIZE_EVENT(T) ParamTraits<T>::GetSize(s, CAST_EVENT(T)); |
| 108 #define WRITE_EVENT(T) \ |
| 109 ParamTraits<T>::Write(m, CAST_EVENT(T)); \ |
| 110 break; |
| 111 #define READ_EVENT(T) \ |
| 112 { \ |
| 113 scoped_ptr<T> event(new T(type, time_stamp, flags)); \ |
| 114 if (!ParamTraits<T>::Read(m, iter, event.get())) { \ |
| 115 p->reset(); \ |
| 116 return false; \ |
| 117 } else { \ |
| 118 *p = std::move(event); \ |
| 119 return true; \ |
| 120 } \ |
| 121 } |
| 122 #define LOG_EVENT(T) return ParamTraits<T>::Log(CAST_EVENT(T), l); |
| 123 |
| 124 // void SizeEvent(ui::EventType type, int flags, base::PickleSizer* s, |
| 125 // const ui::ScopedEvent& p) { ... } |
| 126 EVENT_IMPL(void, |
| 127 SizeEvent, |
| 128 SIZE_EVENT, |
| 129 /* default switch/case: no-op */, |
| 130 base::PickleSizer* s, |
| 131 const ui::ScopedEvent& p) |
| 132 |
| 133 // void WriteEvent(ui::EventType type, int flags, base::Pickle* m, |
| 134 // const ui::ScopedEvent& p) { ... } |
| 135 EVENT_IMPL(void, |
| 136 WriteEvent, |
| 137 WRITE_EVENT, |
| 138 /* default switch/case: no-op */, |
| 139 base::Pickle* m, |
| 140 const ui::ScopedEvent& p) |
| 141 |
| 142 // bool ReadEvent(ui::EventType type, int flags, base::Pickle* m, |
| 143 // base::PickleIterator* iter, ui::ScopedEvent* p) { ... } |
| 144 EVENT_IMPL(bool, |
| 145 ReadEvent, |
| 146 READ_EVENT, |
| 147 return false;, |
| 148 const base::Pickle* m, |
| 149 base::PickleIterator* iter, |
| 150 ui::ScopedEvent* p) |
| 151 |
| 152 // void LogEvent(ui::EventType type, int flags, const ui::ScopedEvent& p, |
| 153 // std::string* l) { ... } |
| 154 EVENT_IMPL(void, |
| 155 LogEvent, |
| 156 LOG_EVENT, |
| 157 /* default switch/case: no-op */, |
| 158 const ui::ScopedEvent& p, |
| 159 std::string* l) |
| 160 |
| 161 #undef CAST_EVENT |
| 162 #undef SIZE_EVENT |
| 163 #undef WRITE_EVENT |
| 164 #undef READ_EVENT |
| 165 #undef LOG_EVENT |
| 166 #undef EVENT_IMPL |
| 167 |
| 168 void ParamTraits<ui::ScopedEvent>::GetSize(base::PickleSizer* s, |
| 169 const param_type& p) { |
| 170 DCHECK(p); |
| 171 GetParamSize(s, p->type_); |
| 172 GetParamSize(s, p->name_); |
| 173 GetParamSize(s, p->time_stamp_); |
| 174 GetParamSize(s, p->flags_); |
| 175 GetParamSize(s, p->phase_); |
| 176 GetParamSize(s, p->result_); |
| 177 GetParamSize(s, p->cancelable_); |
| 178 SizeEvent(p->type_, p->time_stamp_, p->flags_, s, p); |
| 179 } |
| 180 |
| 181 void ParamTraits<ui::ScopedEvent>::Write(base::Pickle* m, const param_type& p) { |
| 182 DCHECK(p); |
| 183 WriteParam(m, p->type_); |
| 184 WriteParam(m, p->name_); |
| 185 WriteParam(m, p->time_stamp_); |
| 186 WriteParam(m, p->flags_); |
| 187 WriteParam(m, p->phase_); |
| 188 WriteParam(m, p->result_); |
| 189 WriteParam(m, p->cancelable_); |
| 190 WriteEvent(p->type_, p->time_stamp_, p->flags_, m, p); |
| 191 } |
| 192 |
| 193 bool ParamTraits<ui::ScopedEvent>::Read(const base::Pickle* m, |
| 194 base::PickleIterator* iter, |
| 195 param_type* p) { |
| 196 // Expect: valid ui::ScopedEvent that does not (yet) point to anything. |
| 197 DCHECK(p && !*p); |
| 198 |
| 199 ui::EventType type; |
| 200 std::string name; |
| 201 base::TimeDelta time_stamp; |
| 202 int flags; |
| 203 ui::EventPhase phase; |
| 204 ui::EventResult result; |
| 205 int cancelable; |
| 206 |
| 207 // Read initial params, then invoke ReadEvent which will reset() |p| to an |
| 208 // instance of the correct concrete event type. |
| 209 if (!ReadParam(m, iter, &type) || !ReadParam(m, iter, &name) || |
| 210 !ReadParam(m, iter, &time_stamp) || !ReadParam(m, iter, &flags) || |
| 211 !ReadParam(m, iter, &phase) || !ReadParam(m, iter, &result) || |
| 212 !ReadParam(m, iter, &cancelable) || |
| 213 !ReadEvent(type, time_stamp, flags, m, iter, p)) |
| 214 return false; |
| 215 |
| 216 // Fill in abstract event information. |
| 217 (*p)->type_ = type; |
| 218 (*p)->name_ = name; |
| 219 (*p)->time_stamp_ = time_stamp; |
| 220 (*p)->flags_ = flags; |
| 221 (*p)->phase_ = phase; |
| 222 (*p)->result_ = result; |
| 223 (*p)->cancelable_ = cancelable; |
| 224 |
| 225 return true; |
| 226 } |
| 227 |
| 228 void ParamTraits<ui::ScopedEvent>::Log(const param_type& p, std::string* l) { |
| 229 l->append("<UI Event: "); |
| 230 LogEvent(p->type_, p->time_stamp_, p->flags_, p, l); |
| 231 l->append(">"); |
| 232 } |
| 233 |
| 234 void ParamTraits<ui::CancelModeEvent>::GetSize(base::PickleSizer* s, |
| 235 const param_type& p) {} |
| 236 |
| 237 void ParamTraits<ui::CancelModeEvent>::Write(base::Pickle* m, |
| 238 const param_type& p) {} |
| 239 |
| 240 bool ParamTraits<ui::CancelModeEvent>::Read(const base::Pickle* m, |
| 241 base::PickleIterator* iter, |
| 242 param_type* p) { |
| 243 return true; |
| 244 } |
| 245 |
| 246 void ParamTraits<ui::CancelModeEvent>::Log(const param_type& p, |
| 247 std::string* l) { |
| 248 l->append("<ui::CancelModeEvent>"); |
| 249 } |
| 250 |
| 251 void ParamTraits<ui::GestureEventDetails::Details>::GetSize( |
| 252 base::PickleSizer* s, |
| 253 const param_type& p) { |
| 254 s->AddBytes(sizeof(param_type)); |
| 255 } |
| 256 |
| 257 void ParamTraits<ui::GestureEventDetails::Details>::Write(base::Pickle* m, |
| 258 const param_type& p) { |
| 259 m->WriteBytes(&p, sizeof(param_type)); |
| 260 } |
| 261 |
| 262 bool ParamTraits<ui::GestureEventDetails::Details>::Read( |
| 263 const base::Pickle* m, |
| 264 base::PickleIterator* iter, |
| 265 param_type* p) { |
| 266 const char* data; |
| 267 if (!iter->ReadBytes(&data, sizeof(param_type))) |
| 268 return false; |
| 269 |
| 270 memcpy(p, data, sizeof(param_type)); |
| 271 return true; |
| 272 } |
| 273 |
| 274 void ParamTraits<ui::GestureEventDetails::Details>::Log(const param_type& p, |
| 275 std::string* l) { |
| 276 l->append("<ui::GestureEventDetails::Details>"); |
| 277 } |
| 278 |
| 279 } // namespace IPC |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1695783002:
IPC::ParamTraits for ui::Event (towards ui::Events over mojo IPC) (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master