| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "content/browser/renderer_host/web_input_event_aura.h" | |
| 6 | |
| 7 #include "build/build_config.h" | |
| 8 #include "content/browser/renderer_host/input/web_input_event_util.h" | |
| 9 #include "ui/aura/client/screen_position_client.h" | |
| 10 #include "ui/aura/window.h" | |
| 11 #include "ui/events/base_event_utils.h" | |
| 12 #include "ui/events/blink/blink_event_util.h" | |
| 13 #include "ui/events/event.h" | |
| 14 #include "ui/events/event_utils.h" | |
| 15 #include "ui/events/keycodes/dom/keycode_converter.h" | |
| 16 #include "ui/events/keycodes/keyboard_code_conversion.h" | |
| 17 | |
| 18 namespace content { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 gfx::Point GetScreenLocationFromEvent(const ui::LocatedEvent& event) { | |
| 23 if (!event.target()) | |
| 24 return event.root_location(); | |
| 25 | |
| 26 aura::Window* root = | |
| 27 static_cast<aura::Window*>(event.target())->GetRootWindow(); | |
| 28 aura::client::ScreenPositionClient* spc = | |
| 29 aura::client::GetScreenPositionClient(root); | |
| 30 if (!spc) | |
| 31 return event.root_location(); | |
| 32 | |
| 33 gfx::Point screen_location(event.root_location()); | |
| 34 spc->ConvertPointToScreen(root, &screen_location); | |
| 35 return screen_location; | |
| 36 } | |
| 37 | |
| 38 blink::WebPointerProperties::PointerType EventPointerTypeToWebPointerType( | |
| 39 ui::EventPointerType pointer_type) { | |
| 40 switch (pointer_type) { | |
| 41 case ui::EventPointerType::POINTER_TYPE_UNKNOWN: | |
| 42 return blink::WebPointerProperties::PointerType::Unknown; | |
| 43 case ui::EventPointerType::POINTER_TYPE_MOUSE: | |
| 44 return blink::WebPointerProperties::PointerType::Mouse; | |
| 45 case ui::EventPointerType::POINTER_TYPE_PEN: | |
| 46 return blink::WebPointerProperties::PointerType::Pen; | |
| 47 case ui::EventPointerType::POINTER_TYPE_TOUCH: | |
| 48 return blink::WebPointerProperties::PointerType::Touch; | |
| 49 } | |
| 50 NOTREACHED() << "Unexpected EventPointerType"; | |
| 51 return blink::WebPointerProperties::PointerType::Unknown; | |
| 52 } | |
| 53 | |
| 54 // Creates a WebGestureEvent from a ui::GestureEvent. Note that it does not | |
| 55 // populate the event coordinates (i.e. |x|, |y|, |globalX|, and |globalY|). So | |
| 56 // the caller must populate these fields. | |
| 57 blink::WebGestureEvent MakeWebGestureEventFromUIEvent( | |
| 58 const ui::GestureEvent& event) { | |
| 59 return ui::CreateWebGestureEvent( | |
| 60 event.details(), event.time_stamp(), event.location_f(), | |
| 61 event.root_location_f(), event.flags(), event.unique_touch_event_id()); | |
| 62 } | |
| 63 | |
| 64 } // namespace | |
| 65 | |
| 66 #if defined(OS_WIN) | |
| 67 blink::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent( | |
| 68 const base::NativeEvent& native_event, | |
| 69 const base::TimeTicks& time_stamp, | |
| 70 blink::WebPointerProperties::PointerType pointer_type); | |
| 71 blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent( | |
| 72 const base::NativeEvent& native_event, | |
| 73 const base::TimeTicks& time_stamp, | |
| 74 blink::WebPointerProperties::PointerType pointer_type); | |
| 75 blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent( | |
| 76 const base::NativeEvent& native_event, | |
| 77 const base::TimeTicks& time_stamp); | |
| 78 blink::WebGestureEvent MakeWebGestureEventFromNativeEvent( | |
| 79 const base::NativeEvent& native_event, | |
| 80 const base::TimeTicks& time_stamp); | |
| 81 #endif | |
| 82 | |
| 83 blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( | |
| 84 const ui::KeyEvent& event) { | |
| 85 blink::WebKeyboardEvent webkit_event; | |
| 86 | |
| 87 webkit_event.timeStampSeconds = | |
| 88 ui::EventTimeStampToSeconds(event.time_stamp()); | |
| 89 webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags()) | | |
| 90 DomCodeToWebInputEventModifiers(event.code()); | |
| 91 | |
| 92 switch (event.type()) { | |
| 93 case ui::ET_KEY_PRESSED: | |
| 94 webkit_event.type = event.is_char() ? blink::WebInputEvent::Char : | |
| 95 blink::WebInputEvent::RawKeyDown; | |
| 96 break; | |
| 97 case ui::ET_KEY_RELEASED: | |
| 98 webkit_event.type = blink::WebInputEvent::KeyUp; | |
| 99 break; | |
| 100 default: | |
| 101 NOTREACHED(); | |
| 102 } | |
| 103 | |
| 104 if (webkit_event.modifiers & blink::WebInputEvent::AltKey) | |
| 105 webkit_event.isSystemKey = true; | |
| 106 | |
| 107 // TODO(dtapuska): crbug.com/570388. Ozone appears to deliver | |
| 108 // key_code events that aren't "located" for the keypad like | |
| 109 // Windows and X11 do and blink expects. | |
| 110 webkit_event.windowsKeyCode = | |
| 111 ui::NonLocatedToLocatedKeypadKeyboardCode(event.key_code(), event.code()); | |
| 112 webkit_event.nativeKeyCode = | |
| 113 ui::KeycodeConverter::DomCodeToNativeKeycode(event.code()); | |
| 114 webkit_event.domCode = static_cast<int>(event.code()); | |
| 115 webkit_event.domKey = static_cast<int>(event.GetDomKey()); | |
| 116 webkit_event.unmodifiedText[0] = event.GetUnmodifiedText(); | |
| 117 webkit_event.text[0] = event.GetText(); | |
| 118 | |
| 119 return webkit_event; | |
| 120 } | |
| 121 | |
| 122 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( | |
| 123 const ui::ScrollEvent& event) { | |
| 124 blink::WebMouseWheelEvent webkit_event; | |
| 125 | |
| 126 webkit_event.type = blink::WebInputEvent::MouseWheel; | |
| 127 webkit_event.button = blink::WebMouseEvent::ButtonNone; | |
| 128 webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags()); | |
| 129 webkit_event.timeStampSeconds = | |
| 130 ui::EventTimeStampToSeconds(event.time_stamp()); | |
| 131 webkit_event.hasPreciseScrollingDeltas = true; | |
| 132 | |
| 133 float offset_ordinal_x = 0.f; | |
| 134 float offset_ordinal_y = 0.f; | |
| 135 if ((event.flags() & ui::EF_SHIFT_DOWN) != 0 && event.x_offset() == 0) { | |
| 136 webkit_event.deltaX = event.y_offset(); | |
| 137 webkit_event.deltaY = 0; | |
| 138 offset_ordinal_x = event.y_offset_ordinal(); | |
| 139 offset_ordinal_y = event.x_offset_ordinal(); | |
| 140 } else { | |
| 141 webkit_event.deltaX = event.x_offset(); | |
| 142 webkit_event.deltaY = event.y_offset(); | |
| 143 offset_ordinal_x = event.x_offset_ordinal(); | |
| 144 offset_ordinal_y = event.y_offset_ordinal(); | |
| 145 } | |
| 146 | |
| 147 if (offset_ordinal_x != 0.f && webkit_event.deltaX != 0.f) | |
| 148 webkit_event.accelerationRatioX = offset_ordinal_x / webkit_event.deltaX; | |
| 149 webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick; | |
| 150 webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick; | |
| 151 if (offset_ordinal_y != 0.f && webkit_event.deltaY != 0.f) | |
| 152 webkit_event.accelerationRatioY = offset_ordinal_y / webkit_event.deltaY; | |
| 153 | |
| 154 webkit_event.pointerType = | |
| 155 EventPointerTypeToWebPointerType(event.pointer_details().pointer_type); | |
| 156 return webkit_event; | |
| 157 } | |
| 158 | |
| 159 blink::WebGestureEvent MakeWebGestureEventFromAuraEvent( | |
| 160 const ui::ScrollEvent& event) { | |
| 161 blink::WebGestureEvent webkit_event; | |
| 162 | |
| 163 switch (event.type()) { | |
| 164 case ui::ET_SCROLL_FLING_START: | |
| 165 webkit_event.type = blink::WebInputEvent::GestureFlingStart; | |
| 166 webkit_event.data.flingStart.velocityX = event.x_offset(); | |
| 167 webkit_event.data.flingStart.velocityY = event.y_offset(); | |
| 168 break; | |
| 169 case ui::ET_SCROLL_FLING_CANCEL: | |
| 170 webkit_event.type = blink::WebInputEvent::GestureFlingCancel; | |
| 171 break; | |
| 172 case ui::ET_SCROLL: | |
| 173 NOTREACHED() << "Invalid gesture type: " << event.type(); | |
| 174 break; | |
| 175 default: | |
| 176 NOTREACHED() << "Unknown gesture type: " << event.type(); | |
| 177 } | |
| 178 | |
| 179 webkit_event.sourceDevice = blink::WebGestureDeviceTouchpad; | |
| 180 webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags()); | |
| 181 webkit_event.timeStampSeconds = | |
| 182 ui::EventTimeStampToSeconds(event.time_stamp()); | |
| 183 return webkit_event; | |
| 184 } | |
| 185 | |
| 186 blink::WebMouseEvent MakeWebMouseEventFromAuraEvent( | |
| 187 const ui::MouseEvent& event); | |
| 188 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( | |
| 189 const ui::MouseWheelEvent& event); | |
| 190 | |
| 191 // General approach: | |
| 192 // | |
| 193 // ui::Event only carries a subset of possible event data provided to Aura by | |
| 194 // the host platform. WebKit utilizes a larger subset of that information than | |
| 195 // Aura itself. WebKit includes some built in cracking functionality that we | |
| 196 // rely on to obtain this information cleanly and consistently. | |
| 197 // | |
| 198 // The only place where an ui::Event's data differs from what the underlying | |
| 199 // base::NativeEvent would provide is position data, since we would like to | |
| 200 // provide coordinates relative to the aura::Window that is hosting the | |
| 201 // renderer, not the top level platform window. | |
| 202 // | |
| 203 // The approach is to fully construct a blink::WebInputEvent from the | |
| 204 // ui::Event's base::NativeEvent, and then replace the coordinate fields with | |
| 205 // the translated values from the ui::Event. | |
| 206 // | |
| 207 // The exception is mouse events on linux. The ui::MouseEvent contains enough | |
| 208 // necessary information to construct a WebMouseEvent. So instead of extracting | |
| 209 // the information from the XEvent, which can be tricky when supporting both | |
| 210 // XInput2 and XInput, the WebMouseEvent is constructed from the | |
| 211 // ui::MouseEvent. This will not be necessary once only XInput2 is supported. | |
| 212 // | |
| 213 | |
| 214 blink::WebMouseEvent MakeWebMouseEvent(const ui::MouseEvent& event) { | |
| 215 // Construct an untranslated event from the platform event data. | |
| 216 blink::WebMouseEvent webkit_event = | |
| 217 #if defined(OS_WIN) | |
| 218 // On Windows we have WM_ events comming from desktop and pure aura | |
| 219 // events comming from metro mode. | |
| 220 event.native_event().message && (event.type() != ui::ET_MOUSE_EXITED) | |
| 221 ? MakeUntranslatedWebMouseEventFromNativeEvent( | |
| 222 event.native_event(), event.time_stamp(), | |
| 223 EventPointerTypeToWebPointerType( | |
| 224 event.pointer_details().pointer_type)) | |
| 225 : MakeWebMouseEventFromAuraEvent(event); | |
| 226 #else | |
| 227 MakeWebMouseEventFromAuraEvent(event); | |
| 228 #endif | |
| 229 // Replace the event's coordinate fields with translated position data from | |
| 230 // |event|. | |
| 231 webkit_event.windowX = webkit_event.x = event.x(); | |
| 232 webkit_event.windowY = webkit_event.y = event.y(); | |
| 233 | |
| 234 #if defined(OS_WIN) | |
| 235 if (event.native_event().message) | |
| 236 return webkit_event; | |
| 237 #endif | |
| 238 const gfx::Point screen_point = GetScreenLocationFromEvent(event); | |
| 239 webkit_event.globalX = screen_point.x(); | |
| 240 webkit_event.globalY = screen_point.y(); | |
| 241 | |
| 242 return webkit_event; | |
| 243 } | |
| 244 | |
| 245 blink::WebMouseWheelEvent MakeWebMouseWheelEvent( | |
| 246 const ui::MouseWheelEvent& event) { | |
| 247 #if defined(OS_WIN) | |
| 248 // Construct an untranslated event from the platform event data. | |
| 249 blink::WebMouseWheelEvent webkit_event = | |
| 250 event.native_event().message | |
| 251 ? MakeUntranslatedWebMouseWheelEventFromNativeEvent( | |
| 252 event.native_event(), event.time_stamp(), | |
| 253 EventPointerTypeToWebPointerType( | |
| 254 event.pointer_details().pointer_type)) | |
| 255 : MakeWebMouseWheelEventFromAuraEvent(event); | |
| 256 #else | |
| 257 blink::WebMouseWheelEvent webkit_event = | |
| 258 MakeWebMouseWheelEventFromAuraEvent(event); | |
| 259 #endif | |
| 260 | |
| 261 // Replace the event's coordinate fields with translated position data from | |
| 262 // |event|. | |
| 263 webkit_event.windowX = webkit_event.x = event.x(); | |
| 264 webkit_event.windowY = webkit_event.y = event.y(); | |
| 265 | |
| 266 const gfx::Point screen_point = GetScreenLocationFromEvent(event); | |
| 267 webkit_event.globalX = screen_point.x(); | |
| 268 webkit_event.globalY = screen_point.y(); | |
| 269 | |
| 270 return webkit_event; | |
| 271 } | |
| 272 | |
| 273 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(const ui::ScrollEvent& event) { | |
| 274 #if defined(OS_WIN) | |
| 275 // Construct an untranslated event from the platform event data. | |
| 276 blink::WebMouseWheelEvent webkit_event = | |
| 277 event.native_event().message | |
| 278 ? MakeUntranslatedWebMouseWheelEventFromNativeEvent( | |
| 279 event.native_event(), event.time_stamp(), | |
| 280 EventPointerTypeToWebPointerType( | |
| 281 event.pointer_details().pointer_type)) | |
| 282 : MakeWebMouseWheelEventFromAuraEvent(event); | |
| 283 #else | |
| 284 blink::WebMouseWheelEvent webkit_event = | |
| 285 MakeWebMouseWheelEventFromAuraEvent(event); | |
| 286 #endif | |
| 287 | |
| 288 // Replace the event's coordinate fields with translated position data from | |
| 289 // |event|. | |
| 290 webkit_event.windowX = webkit_event.x = event.x(); | |
| 291 webkit_event.windowY = webkit_event.y = event.y(); | |
| 292 | |
| 293 const gfx::Point screen_point = GetScreenLocationFromEvent(event); | |
| 294 webkit_event.globalX = screen_point.x(); | |
| 295 webkit_event.globalY = screen_point.y(); | |
| 296 | |
| 297 return webkit_event; | |
| 298 } | |
| 299 | |
| 300 blink::WebKeyboardEvent MakeWebKeyboardEvent(const ui::KeyEvent& event) { | |
| 301 // Windows can figure out whether or not to construct a RawKeyDown or a Char | |
| 302 // WebInputEvent based on the type of message carried in | |
| 303 // event.native_event(). X11 is not so fortunate, there is no separate | |
| 304 // translated event type, so DesktopHostLinux sends an extra KeyEvent with | |
| 305 // is_char() == true. We need to pass the ui::KeyEvent to the X11 function | |
| 306 // to detect this case so the right event type can be constructed. | |
| 307 #if defined(OS_WIN) | |
| 308 if (event.HasNativeEvent()) { | |
| 309 // Key events require no translation by the aura system. | |
| 310 blink::WebKeyboardEvent webkit_event(MakeWebKeyboardEventFromNativeEvent( | |
| 311 event.native_event(), event.time_stamp())); | |
| 312 webkit_event.modifiers |= DomCodeToWebInputEventModifiers(event.code()); | |
| 313 webkit_event.domCode = static_cast<int>(event.code()); | |
| 314 webkit_event.domKey = static_cast<int>(event.GetDomKey()); | |
| 315 return webkit_event; | |
| 316 } | |
| 317 #endif | |
| 318 return MakeWebKeyboardEventFromAuraEvent(event); | |
| 319 } | |
| 320 | |
| 321 blink::WebGestureEvent MakeWebGestureEvent(const ui::GestureEvent& event) { | |
| 322 blink::WebGestureEvent gesture_event; | |
| 323 #if defined(OS_WIN) | |
| 324 if (event.HasNativeEvent()) | |
| 325 gesture_event = MakeWebGestureEventFromNativeEvent(event.native_event(), | |
| 326 event.time_stamp()); | |
| 327 else | |
| 328 gesture_event = MakeWebGestureEventFromUIEvent(event); | |
| 329 #else | |
| 330 gesture_event = MakeWebGestureEventFromUIEvent(event); | |
| 331 #endif | |
| 332 | |
| 333 gesture_event.x = event.x(); | |
| 334 gesture_event.y = event.y(); | |
| 335 | |
| 336 const gfx::Point screen_point = GetScreenLocationFromEvent(event); | |
| 337 gesture_event.globalX = screen_point.x(); | |
| 338 gesture_event.globalY = screen_point.y(); | |
| 339 | |
| 340 return gesture_event; | |
| 341 } | |
| 342 | |
| 343 blink::WebGestureEvent MakeWebGestureEvent(const ui::ScrollEvent& event) { | |
| 344 blink::WebGestureEvent gesture_event; | |
| 345 | |
| 346 #if defined(OS_WIN) | |
| 347 gesture_event = MakeWebGestureEventFromNativeEvent(event.native_event(), | |
| 348 event.time_stamp()); | |
| 349 #else | |
| 350 gesture_event = MakeWebGestureEventFromAuraEvent(event); | |
| 351 #endif | |
| 352 | |
| 353 gesture_event.x = event.x(); | |
| 354 gesture_event.y = event.y(); | |
| 355 | |
| 356 const gfx::Point screen_point = GetScreenLocationFromEvent(event); | |
| 357 gesture_event.globalX = screen_point.x(); | |
| 358 gesture_event.globalY = screen_point.y(); | |
| 359 | |
| 360 return gesture_event; | |
| 361 } | |
| 362 | |
| 363 blink::WebGestureEvent MakeWebGestureEventFlingCancel() { | |
| 364 blink::WebGestureEvent gesture_event; | |
| 365 | |
| 366 // All other fields are ignored on a GestureFlingCancel event. | |
| 367 gesture_event.type = blink::WebInputEvent::GestureFlingCancel; | |
| 368 gesture_event.timeStampSeconds = | |
| 369 ui::EventTimeStampToSeconds(ui::EventTimeForNow()); | |
| 370 gesture_event.sourceDevice = blink::WebGestureDeviceTouchpad; | |
| 371 return gesture_event; | |
| 372 } | |
| 373 | |
| 374 blink::WebMouseEvent MakeWebMouseEventFromAuraEvent( | |
| 375 const ui::MouseEvent& event) { | |
| 376 blink::WebMouseEvent webkit_event; | |
| 377 | |
| 378 webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags()); | |
| 379 webkit_event.timeStampSeconds = | |
| 380 ui::EventTimeStampToSeconds(event.time_stamp()); | |
| 381 webkit_event.button = blink::WebMouseEvent::ButtonNone; | |
| 382 int button_flags = event.flags(); | |
| 383 if (event.type() == ui::ET_MOUSE_PRESSED || | |
| 384 event.type() == ui::ET_MOUSE_RELEASED) { | |
| 385 // We want to use changed_button_flags() for mouse pressed & released. | |
| 386 // These flags can be used only if they are set which is not always the case | |
| 387 // (see e.g. GetChangedMouseButtonFlagsFromNative() in events_win.cc). | |
| 388 if (event.changed_button_flags()) | |
| 389 button_flags = event.changed_button_flags(); | |
| 390 } | |
| 391 if (button_flags & ui::EF_LEFT_MOUSE_BUTTON) | |
| 392 webkit_event.button = blink::WebMouseEvent::ButtonLeft; | |
| 393 if (button_flags & ui::EF_MIDDLE_MOUSE_BUTTON) | |
| 394 webkit_event.button = blink::WebMouseEvent::ButtonMiddle; | |
| 395 if (button_flags & ui::EF_RIGHT_MOUSE_BUTTON) | |
| 396 webkit_event.button = blink::WebMouseEvent::ButtonRight; | |
| 397 | |
| 398 switch (event.type()) { | |
| 399 case ui::ET_MOUSE_PRESSED: | |
| 400 webkit_event.type = blink::WebInputEvent::MouseDown; | |
| 401 webkit_event.clickCount = event.GetClickCount(); | |
| 402 break; | |
| 403 case ui::ET_MOUSE_RELEASED: | |
| 404 webkit_event.type = blink::WebInputEvent::MouseUp; | |
| 405 webkit_event.clickCount = event.GetClickCount(); | |
| 406 break; | |
| 407 case ui::ET_MOUSE_ENTERED: | |
| 408 case ui::ET_MOUSE_EXITED: | |
| 409 case ui::ET_MOUSE_MOVED: | |
| 410 case ui::ET_MOUSE_DRAGGED: | |
| 411 webkit_event.type = blink::WebInputEvent::MouseMove; | |
| 412 break; | |
| 413 default: | |
| 414 NOTIMPLEMENTED() << "Received unexpected event: " << event.type(); | |
| 415 break; | |
| 416 } | |
| 417 | |
| 418 webkit_event.tiltX = roundf(event.pointer_details().tilt_x); | |
| 419 webkit_event.tiltY = roundf(event.pointer_details().tilt_y); | |
| 420 webkit_event.force = event.pointer_details().force; | |
| 421 webkit_event.pointerType = | |
| 422 EventPointerTypeToWebPointerType(event.pointer_details().pointer_type); | |
| 423 | |
| 424 return webkit_event; | |
| 425 } | |
| 426 | |
| 427 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( | |
| 428 const ui::MouseWheelEvent& event) { | |
| 429 blink::WebMouseWheelEvent webkit_event; | |
| 430 | |
| 431 webkit_event.type = blink::WebInputEvent::MouseWheel; | |
| 432 webkit_event.button = blink::WebMouseEvent::ButtonNone; | |
| 433 webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags()); | |
| 434 webkit_event.timeStampSeconds = | |
| 435 ui::EventTimeStampToSeconds(event.time_stamp()); | |
| 436 | |
| 437 if ((event.flags() & ui::EF_SHIFT_DOWN) != 0 && event.x_offset() == 0) { | |
| 438 webkit_event.deltaX = event.y_offset(); | |
| 439 webkit_event.deltaY = 0; | |
| 440 } else { | |
| 441 webkit_event.deltaX = event.x_offset(); | |
| 442 webkit_event.deltaY = event.y_offset(); | |
| 443 } | |
| 444 | |
| 445 webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick; | |
| 446 webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick; | |
| 447 | |
| 448 webkit_event.tiltX = roundf(event.pointer_details().tilt_x); | |
| 449 webkit_event.tiltY = roundf(event.pointer_details().tilt_y); | |
| 450 webkit_event.force = event.pointer_details().force; | |
| 451 webkit_event.pointerType = | |
| 452 EventPointerTypeToWebPointerType(event.pointer_details().pointer_type); | |
| 453 | |
| 454 return webkit_event; | |
| 455 } | |
| 456 | |
| 457 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2234023002:
Refactor WebInputEventAura to ui/events/blink (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master