| 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 "components/mus/common/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 "components/mus/common/event_param_traits_macros.h" |
| 18 } |
| 19 |
| 20 // Generate param traits write methods. |
| 21 #include "ipc/param_traits_write_macros.h" |
| 22 namespace IPC { |
| 23 #include "components/mus/common/event_param_traits_macros.h" |
| 24 } |
| 25 |
| 26 // Generate param traits read methods. |
| 27 #include "ipc/param_traits_read_macros.h" |
| 28 namespace IPC { |
| 29 #include "components/mus/common/event_param_traits_macros.h" |
| 30 } |
| 31 |
| 32 // Generate param traits log methods. |
| 33 #include "ipc/param_traits_log_macros.h" |
| 34 namespace IPC { |
| 35 #include "components/mus/common/event_param_traits_macros.h" |
| 36 } |
| 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 SIZE_EVENT(T) ParamTraits<T>::GetSize(s, *static_cast<T*>(p.get())); |
| 107 #define WRITE_EVENT(T) \ |
| 108 ParamTraits<T>::Write(m, *static_cast<T*>(p.get())); \ |
| 109 break; |
| 110 #define READ_EVENT(T) \ |
| 111 { \ |
| 112 scoped_ptr<T> event(new T(type, time_stamp, flags)); \ |
| 113 if (!ParamTraits<T>::Read(m, iter, event.get())) { \ |
| 114 p->reset(); \ |
| 115 return false; \ |
| 116 } else { \ |
| 117 *p = std::move(event); \ |
| 118 return true; \ |
| 119 } \ |
| 120 } |
| 121 #define LOG_EVENT(T) return ParamTraits<T>::Log(*static_cast<T*>(p.get()), l); |
| 122 |
| 123 // void SizeEvent(ui::EventType type, int flags, base::PickleSizer* s, |
| 124 // const ui::ScopedEvent& p) { ... } |
| 125 EVENT_IMPL(void, |
| 126 SizeEvent, |
| 127 SIZE_EVENT, |
| 128 /* default switch/case: no-op */, |
| 129 base::PickleSizer* s, |
| 130 const ui::ScopedEvent& p) |
| 131 |
| 132 // void WriteEvent(ui::EventType type, int flags, base::Pickle* m, |
| 133 // const ui::ScopedEvent& p) { ... } |
| 134 EVENT_IMPL(void, |
| 135 WriteEvent, |
| 136 WRITE_EVENT, |
| 137 /* default switch/case: no-op */, |
| 138 base::Pickle* m, |
| 139 const ui::ScopedEvent& p) |
| 140 |
| 141 // bool ReadEvent(ui::EventType type, int flags, base::Pickle* m, |
| 142 // base::PickleIterator* iter, ui::ScopedEvent* p) { ... } |
| 143 EVENT_IMPL(bool, |
| 144 ReadEvent, |
| 145 READ_EVENT, |
| 146 return false;, |
| 147 const base::Pickle* m, |
| 148 base::PickleIterator* iter, |
| 149 ui::ScopedEvent* p) |
| 150 |
| 151 // void LogEvent(ui::EventType type, int flags, const ui::ScopedEvent& p, |
| 152 // std::string* l) { ... } |
| 153 EVENT_IMPL(void, |
| 154 LogEvent, |
| 155 LOG_EVENT, |
| 156 /* default switch/case: no-op */, |
| 157 const ui::ScopedEvent& p, |
| 158 std::string* l) |
| 159 |
| 160 #undef SIZE_EVENT |
| 161 #undef WRITE_EVENT |
| 162 #undef READ_EVENT |
| 163 #undef LOG_EVENT |
| 164 #undef EVENT_IMPL |
| 165 |
| 166 void ParamTraits<ui::ScopedEvent>::GetSize(base::PickleSizer* s, |
| 167 const param_type& p) { |
| 168 DCHECK(p); |
| 169 GetParamSize(s, p->type_); |
| 170 GetParamSize(s, p->name_); |
| 171 GetParamSize(s, p->time_stamp_); |
| 172 GetParamSize(s, p->flags_); |
| 173 GetParamSize(s, p->phase_); |
| 174 GetParamSize(s, p->result_); |
| 175 GetParamSize(s, p->cancelable_); |
| 176 SizeEvent(p->type_, p->time_stamp_, p->flags_, s, p); |
| 177 } |
| 178 |
| 179 void ParamTraits<ui::ScopedEvent>::Write(base::Pickle* m, const param_type& p) { |
| 180 DCHECK(p); |
| 181 WriteParam(m, p->type_); |
| 182 WriteParam(m, p->name_); |
| 183 WriteParam(m, p->time_stamp_); |
| 184 WriteParam(m, p->flags_); |
| 185 WriteParam(m, p->phase_); |
| 186 WriteParam(m, p->result_); |
| 187 WriteParam(m, p->cancelable_); |
| 188 WriteEvent(p->type_, p->time_stamp_, p->flags_, m, p); |
| 189 } |
| 190 |
| 191 bool ParamTraits<ui::ScopedEvent>::Read(const base::Pickle* m, |
| 192 base::PickleIterator* iter, |
| 193 param_type* p) { |
| 194 // Expect: valid ui::ScopedEvent that does not (yet) point to anything. |
| 195 DCHECK(p && !*p); |
| 196 |
| 197 ui::EventType type; |
| 198 std::string name; |
| 199 base::TimeDelta time_stamp; |
| 200 int flags; |
| 201 ui::EventPhase phase; |
| 202 ui::EventResult result; |
| 203 bool cancelable; |
| 204 |
| 205 // Read initial params, then invoke ReadEvent which will reset() |p| to an |
| 206 // instance of the correct concrete event type. |
| 207 if (!ReadParam(m, iter, &type) || !ReadParam(m, iter, &name) || |
| 208 !ReadParam(m, iter, &time_stamp) || !ReadParam(m, iter, &flags) || |
| 209 !ReadParam(m, iter, &phase) || !ReadParam(m, iter, &result) || |
| 210 !ReadParam(m, iter, &cancelable) || |
| 211 !ReadEvent(type, time_stamp, flags, m, iter, p)) |
| 212 return false; |
| 213 |
| 214 // Fill in abstract event information. |
| 215 (*p)->type_ = type; |
| 216 (*p)->name_ = name; |
| 217 (*p)->time_stamp_ = time_stamp; |
| 218 (*p)->flags_ = flags; |
| 219 (*p)->phase_ = phase; |
| 220 (*p)->result_ = result; |
| 221 (*p)->cancelable_ = cancelable; |
| 222 |
| 223 return true; |
| 224 } |
| 225 |
| 226 void ParamTraits<ui::ScopedEvent>::Log(const param_type& p, std::string* l) { |
| 227 l->append("<UI Event: "); |
| 228 LogEvent(p->type_, p->time_stamp_, p->flags_, p, l); |
| 229 l->append(">"); |
| 230 } |
| 231 |
| 232 void ParamTraits<ui::CancelModeEvent>::GetSize(base::PickleSizer* s, |
| 233 const param_type& p) {} |
| 234 |
| 235 void ParamTraits<ui::CancelModeEvent>::Write(base::Pickle* m, |
| 236 const param_type& p) {} |
| 237 |
| 238 bool ParamTraits<ui::CancelModeEvent>::Read(const base::Pickle* m, |
| 239 base::PickleIterator* iter, |
| 240 param_type* p) { |
| 241 return true; |
| 242 } |
| 243 |
| 244 void ParamTraits<ui::CancelModeEvent>::Log(const param_type& p, |
| 245 std::string* l) { |
| 246 l->append("<ui::CancelModeEvent>"); |
| 247 } |
| 248 |
| 249 void ParamTraits<ui::GestureEventDetails::Details>::GetSize( |
| 250 base::PickleSizer* s, |
| 251 const param_type& p) { |
| 252 s->AddBytes(sizeof(param_type)); |
| 253 } |
| 254 |
| 255 void ParamTraits<ui::GestureEventDetails::Details>::Write(base::Pickle* m, |
| 256 const param_type& p) { |
| 257 m->WriteBytes(&p, sizeof(param_type)); |
| 258 } |
| 259 |
| 260 bool ParamTraits<ui::GestureEventDetails::Details>::Read( |
| 261 const base::Pickle* m, |
| 262 base::PickleIterator* iter, |
| 263 param_type* p) { |
| 264 const char* data; |
| 265 if (!iter->ReadBytes(&data, sizeof(param_type))) |
| 266 return false; |
| 267 |
| 268 memcpy(p, data, sizeof(param_type)); |
| 269 return true; |
| 270 } |
| 271 |
| 272 void ParamTraits<ui::GestureEventDetails::Details>::Log(const param_type& p, |
| 273 std::string* l) { |
| 274 l->append("<ui::GestureEventDetails::Details>"); |
| 275 } |
| 276 |
| 277 } // 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