| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2010 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 "webkit/glue/plugins/pepper_event_conversion.h" | |
| 6 | |
| 7 #include "base/i18n/char_iterator.h" | |
| 8 #include "base/logging.h" | |
| 9 #include "base/scoped_ptr.h" | |
| 10 #include "base/string_util.h" | |
| 11 #include "base/utf_string_conversions.h" | |
| 12 #include "base/utf_string_conversion_utils.h" | |
| 13 #include "ppapi/c/pp_input_event.h" | |
| 14 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h" | |
| 15 #include "webkit/glue/plugins/pepper_common.h" | |
| 16 | |
| 17 using WebKit::WebInputEvent; | |
| 18 using WebKit::WebKeyboardEvent; | |
| 19 using WebKit::WebMouseEvent; | |
| 20 using WebKit::WebMouseWheelEvent; | |
| 21 | |
| 22 namespace { | |
| 23 | |
| 24 PP_InputEvent_Type ConvertEventTypes(WebInputEvent::Type wetype) { | |
| 25 switch (wetype) { | |
| 26 case WebInputEvent::MouseDown: | |
| 27 return PP_INPUTEVENT_TYPE_MOUSEDOWN; | |
| 28 case WebInputEvent::MouseUp: | |
| 29 return PP_INPUTEVENT_TYPE_MOUSEUP; | |
| 30 case WebInputEvent::MouseMove: | |
| 31 return PP_INPUTEVENT_TYPE_MOUSEMOVE; | |
| 32 case WebInputEvent::MouseEnter: | |
| 33 return PP_INPUTEVENT_TYPE_MOUSEENTER; | |
| 34 case WebInputEvent::MouseLeave: | |
| 35 return PP_INPUTEVENT_TYPE_MOUSELEAVE; | |
| 36 case WebInputEvent::MouseWheel: | |
| 37 return PP_INPUTEVENT_TYPE_MOUSEWHEEL; | |
| 38 case WebInputEvent::RawKeyDown: | |
| 39 return PP_INPUTEVENT_TYPE_RAWKEYDOWN; | |
| 40 case WebInputEvent::KeyDown: | |
| 41 return PP_INPUTEVENT_TYPE_KEYDOWN; | |
| 42 case WebInputEvent::KeyUp: | |
| 43 return PP_INPUTEVENT_TYPE_KEYUP; | |
| 44 case WebInputEvent::Char: | |
| 45 return PP_INPUTEVENT_TYPE_CHAR; | |
| 46 case WebInputEvent::Undefined: | |
| 47 default: | |
| 48 return PP_INPUTEVENT_TYPE_UNDEFINED; | |
| 49 } | |
| 50 } | |
| 51 | |
| 52 // Generates a PP_InputEvent with the fields common to all events, as well as | |
| 53 // the event type from the given web event. Event-specific fields will be zero | |
| 54 // initialized. | |
| 55 PP_InputEvent GetPPEventWithCommonFieldsAndType( | |
| 56 const WebInputEvent& web_event) { | |
| 57 PP_InputEvent result; | |
| 58 memset(&result, 0, sizeof(PP_InputEvent)); | |
| 59 result.type = ConvertEventTypes(web_event.type); | |
| 60 // TODO(brettw) http://code.google.com/p/chromium/issues/detail?id=57448 | |
| 61 // This should use a tick count rather than the wall clock time that WebKit | |
| 62 // uses. | |
| 63 result.time_stamp = web_event.timeStampSeconds; | |
| 64 return result; | |
| 65 } | |
| 66 | |
| 67 void AppendKeyEvent(const WebInputEvent& event, | |
| 68 std::vector<PP_InputEvent>* pp_events) { | |
| 69 const WebKeyboardEvent& key_event = | |
| 70 reinterpret_cast<const WebKeyboardEvent&>(event); | |
| 71 PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event); | |
| 72 result.u.key.modifier = key_event.modifiers; | |
| 73 result.u.key.key_code = key_event.windowsKeyCode; | |
| 74 pp_events->push_back(result); | |
| 75 } | |
| 76 | |
| 77 void AppendCharEvent(const WebInputEvent& event, | |
| 78 std::vector<PP_InputEvent>* pp_events) { | |
| 79 const WebKeyboardEvent& key_event = | |
| 80 reinterpret_cast<const WebKeyboardEvent&>(event); | |
| 81 | |
| 82 // This is a bit complex, the input event will normally just have one 16-bit | |
| 83 // character in it, but may be zero or more than one. The text array is | |
| 84 // just padded with 0 values for the unused ones, but is not necessarily | |
| 85 // null-terminated. | |
| 86 // | |
| 87 // Here we see how many UTF-16 characters we have. | |
| 88 size_t utf16_char_count = 0; | |
| 89 while (utf16_char_count < WebKeyboardEvent::textLengthCap && | |
| 90 key_event.text[utf16_char_count]) | |
| 91 utf16_char_count++; | |
| 92 | |
| 93 // Make a separate PP_InputEvent for each Unicode character in the input. | |
| 94 base::UTF16CharIterator iter(key_event.text, utf16_char_count); | |
| 95 while (!iter.end()) { | |
| 96 PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event); | |
| 97 result.u.character.modifier = key_event.modifiers; | |
| 98 | |
| 99 std::string utf8_char; | |
| 100 base::WriteUnicodeCharacter(iter.get(), &utf8_char); | |
| 101 base::strlcpy(result.u.character.text, utf8_char.c_str(), | |
| 102 sizeof(result.u.character.text)); | |
| 103 | |
| 104 pp_events->push_back(result); | |
| 105 iter.Advance(); | |
| 106 } | |
| 107 } | |
| 108 | |
| 109 void AppendMouseEvent(const WebInputEvent& event, | |
| 110 std::vector<PP_InputEvent>* pp_events) { | |
| 111 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonNone) == | |
| 112 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE), | |
| 113 MouseNone); | |
| 114 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonLeft) == | |
| 115 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT), | |
| 116 MouseLeft); | |
| 117 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonRight) == | |
| 118 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT), | |
| 119 MouseRight); | |
| 120 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonMiddle) == | |
| 121 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE), | |
| 122 MouseMiddle); | |
| 123 | |
| 124 const WebMouseEvent& mouse_event = | |
| 125 reinterpret_cast<const WebMouseEvent&>(event); | |
| 126 PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event); | |
| 127 result.u.mouse.modifier = mouse_event.modifiers; | |
| 128 result.u.mouse.button = | |
| 129 static_cast<PP_InputEvent_MouseButton>(mouse_event.button); | |
| 130 result.u.mouse.x = static_cast<float>(mouse_event.x); | |
| 131 result.u.mouse.y = static_cast<float>(mouse_event.y); | |
| 132 result.u.mouse.click_count = mouse_event.clickCount; | |
| 133 pp_events->push_back(result); | |
| 134 } | |
| 135 | |
| 136 void AppendMouseWheelEvent(const WebInputEvent& event, | |
| 137 std::vector<PP_InputEvent>* pp_events) { | |
| 138 const WebMouseWheelEvent& mouse_wheel_event = | |
| 139 reinterpret_cast<const WebMouseWheelEvent&>(event); | |
| 140 PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event); | |
| 141 result.u.wheel.modifier = mouse_wheel_event.modifiers; | |
| 142 result.u.wheel.delta_x = mouse_wheel_event.deltaX; | |
| 143 result.u.wheel.delta_y = mouse_wheel_event.deltaY; | |
| 144 result.u.wheel.wheel_ticks_x = mouse_wheel_event.wheelTicksX; | |
| 145 result.u.wheel.wheel_ticks_y = mouse_wheel_event.wheelTicksY; | |
| 146 result.u.wheel.scroll_by_page = | |
| 147 pepper::BoolToPPBool(!!mouse_wheel_event.scrollByPage); | |
| 148 pp_events->push_back(result); | |
| 149 } | |
| 150 | |
| 151 | |
| 152 WebKeyboardEvent* BuildKeyEvent(const PP_InputEvent& event) { | |
| 153 WebKeyboardEvent* key_event = new WebKeyboardEvent(); | |
| 154 switch (event.type) { | |
| 155 case PP_INPUTEVENT_TYPE_RAWKEYDOWN: | |
| 156 key_event->type = WebInputEvent::RawKeyDown; | |
| 157 break; | |
| 158 case PP_INPUTEVENT_TYPE_KEYDOWN: | |
| 159 key_event->type = WebInputEvent::KeyDown; | |
| 160 break; | |
| 161 case PP_INPUTEVENT_TYPE_KEYUP: | |
| 162 key_event->type = WebInputEvent::KeyUp; | |
| 163 break; | |
| 164 default: | |
| 165 NOTREACHED(); | |
| 166 } | |
| 167 key_event->timeStampSeconds = event.time_stamp; | |
| 168 key_event->modifiers = event.u.key.modifier; | |
| 169 key_event->windowsKeyCode = event.u.key.key_code; | |
| 170 return key_event; | |
| 171 } | |
| 172 | |
| 173 WebKeyboardEvent* BuildCharEvent(const PP_InputEvent& event) { | |
| 174 WebKeyboardEvent* key_event = new WebKeyboardEvent(); | |
| 175 key_event->type = WebInputEvent::Char; | |
| 176 key_event->timeStampSeconds = event.time_stamp; | |
| 177 key_event->modifiers = event.u.character.modifier; | |
| 178 | |
| 179 // Make sure to not read beyond the buffer in case some bad code doesn't | |
| 180 // NULL-terminate it (this is called from plugins). | |
| 181 size_t text_length_cap = WebKeyboardEvent::textLengthCap; | |
| 182 size_t text_len = 0; | |
| 183 while (text_len < text_length_cap && event.u.character.text[text_len]) | |
| 184 text_len++; | |
| 185 string16 text16 = UTF8ToUTF16(std::string(event.u.character.text, text_len)); | |
| 186 | |
| 187 memset(key_event->text, 0, text_length_cap); | |
| 188 memset(key_event->unmodifiedText, 0, text_length_cap); | |
| 189 for (size_t i = 0; | |
| 190 i < std::min(text_length_cap, text16.size()); | |
| 191 ++i) | |
| 192 key_event->text[i] = text16[i]; | |
| 193 return key_event; | |
| 194 } | |
| 195 | |
| 196 WebMouseEvent* BuildMouseEvent(const PP_InputEvent& event) { | |
| 197 WebMouseEvent* mouse_event = new WebMouseEvent(); | |
| 198 switch (event.type) { | |
| 199 case PP_INPUTEVENT_TYPE_MOUSEDOWN: | |
| 200 mouse_event->type = WebInputEvent::MouseDown; | |
| 201 break; | |
| 202 case PP_INPUTEVENT_TYPE_MOUSEUP: | |
| 203 mouse_event->type = WebInputEvent::MouseUp; | |
| 204 break; | |
| 205 case PP_INPUTEVENT_TYPE_MOUSEMOVE: | |
| 206 mouse_event->type = WebInputEvent::MouseMove; | |
| 207 break; | |
| 208 case PP_INPUTEVENT_TYPE_MOUSEENTER: | |
| 209 mouse_event->type = WebInputEvent::MouseEnter; | |
| 210 break; | |
| 211 case PP_INPUTEVENT_TYPE_MOUSELEAVE: | |
| 212 mouse_event->type = WebInputEvent::MouseLeave; | |
| 213 break; | |
| 214 default: | |
| 215 NOTREACHED(); | |
| 216 } | |
| 217 mouse_event->timeStampSeconds = event.time_stamp; | |
| 218 mouse_event->modifiers = event.u.mouse.modifier; | |
| 219 mouse_event->button = | |
| 220 static_cast<WebMouseEvent::Button>(event.u.mouse.button); | |
| 221 mouse_event->x = static_cast<int>(event.u.mouse.x); | |
| 222 mouse_event->y = static_cast<int>(event.u.mouse.y); | |
| 223 mouse_event->clickCount = event.u.mouse.click_count; | |
| 224 return mouse_event; | |
| 225 } | |
| 226 | |
| 227 WebMouseWheelEvent* BuildMouseWheelEvent(const PP_InputEvent& event) { | |
| 228 WebMouseWheelEvent* mouse_wheel_event = new WebMouseWheelEvent(); | |
| 229 mouse_wheel_event->type = WebInputEvent::MouseWheel; | |
| 230 mouse_wheel_event->timeStampSeconds = event.time_stamp; | |
| 231 mouse_wheel_event->modifiers = event.u.wheel.modifier; | |
| 232 mouse_wheel_event->deltaX = event.u.wheel.delta_x; | |
| 233 mouse_wheel_event->deltaY = event.u.wheel.delta_y; | |
| 234 mouse_wheel_event->wheelTicksX = event.u.wheel.wheel_ticks_x; | |
| 235 mouse_wheel_event->wheelTicksY = event.u.wheel.wheel_ticks_y; | |
| 236 mouse_wheel_event->scrollByPage = event.u.wheel.scroll_by_page; | |
| 237 return mouse_wheel_event; | |
| 238 } | |
| 239 | |
| 240 } // namespace | |
| 241 | |
| 242 namespace pepper { | |
| 243 | |
| 244 void CreatePPEvent(const WebInputEvent& event, | |
| 245 std::vector<PP_InputEvent>* pp_events) { | |
| 246 pp_events->clear(); | |
| 247 | |
| 248 switch (event.type) { | |
| 249 case WebInputEvent::MouseDown: | |
| 250 case WebInputEvent::MouseUp: | |
| 251 case WebInputEvent::MouseMove: | |
| 252 case WebInputEvent::MouseEnter: | |
| 253 case WebInputEvent::MouseLeave: | |
| 254 AppendMouseEvent(event, pp_events); | |
| 255 break; | |
| 256 case WebInputEvent::MouseWheel: | |
| 257 AppendMouseWheelEvent(event, pp_events); | |
| 258 break; | |
| 259 case WebInputEvent::RawKeyDown: | |
| 260 case WebInputEvent::KeyDown: | |
| 261 case WebInputEvent::KeyUp: | |
| 262 AppendKeyEvent(event, pp_events); | |
| 263 break; | |
| 264 case WebInputEvent::Char: | |
| 265 AppendCharEvent(event, pp_events); | |
| 266 break; | |
| 267 case WebInputEvent::Undefined: | |
| 268 default: | |
| 269 break; | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 WebInputEvent* CreateWebInputEvent(const PP_InputEvent& event) { | |
| 274 scoped_ptr<WebInputEvent> web_input_event; | |
| 275 switch (event.type) { | |
| 276 case PP_INPUTEVENT_TYPE_UNDEFINED: | |
| 277 return NULL; | |
| 278 case PP_INPUTEVENT_TYPE_MOUSEDOWN: | |
| 279 case PP_INPUTEVENT_TYPE_MOUSEUP: | |
| 280 case PP_INPUTEVENT_TYPE_MOUSEMOVE: | |
| 281 case PP_INPUTEVENT_TYPE_MOUSEENTER: | |
| 282 case PP_INPUTEVENT_TYPE_MOUSELEAVE: | |
| 283 web_input_event.reset(BuildMouseEvent(event)); | |
| 284 break; | |
| 285 case PP_INPUTEVENT_TYPE_MOUSEWHEEL: | |
| 286 web_input_event.reset(BuildMouseWheelEvent(event)); | |
| 287 break; | |
| 288 case PP_INPUTEVENT_TYPE_RAWKEYDOWN: | |
| 289 case PP_INPUTEVENT_TYPE_KEYDOWN: | |
| 290 case PP_INPUTEVENT_TYPE_KEYUP: | |
| 291 web_input_event.reset(BuildKeyEvent(event)); | |
| 292 break; | |
| 293 case PP_INPUTEVENT_TYPE_CHAR: | |
| 294 web_input_event.reset(BuildCharEvent(event)); | |
| 295 break; | |
| 296 } | |
| 297 | |
| 298 return web_input_event.release(); | |
| 299 } | |
| 300 | |
| 301 } // namespace pepper | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 5828003:
Move the Pepper implementation from webkit/glue/plugins/pepper_* to... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/