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 "remoting/client/plugin/pepper_input_handler.h" 6 7 #include "base/logging.h" 8 #include "ppapi/cpp/image_data.h" 9 #include "ppapi/cpp/input_event.h" 10 #include "ppapi/cpp/module_impl.h" 11 #include "ppapi/cpp/mouse_cursor.h" 12 #include "ppapi/cpp/point.h" 13 #include "ppapi/cpp/var.h" 14 #include "remoting/proto/event.pb.h" 15 #include "ui/events/keycodes/dom4/keycode_converter.h" 16 17 namespace remoting { 18 19 PepperInputHandler::PepperInputHandler( 20 pp::Instance* instance) 21 : pp::MouseLock(instance), 22 instance_(instance), 23 input_stub_(NULL), 24 callback_factory_(this), 25 has_focus_(false), 26 send_mouse_input_when_unfocused_(false), 27 mouse_lock_state_(MouseLockDisallowed), 28 wheel_delta_x_(0), 29 wheel_delta_y_(0), 30 wheel_ticks_x_(0), 31 wheel_ticks_y_(0) { 32 } 33 34 PepperInputHandler::~PepperInputHandler() {} 35 36 // Helper function to get the USB key code using the Dev InputEvent interface. 37 uint32_t GetUsbKeyCode(pp::KeyboardInputEvent pp_key_event) { 38 // Get the DOM3 |code| as a string. 39 std::string codestr = pp_key_event.GetCode().AsString(); 40 41 // Convert the |code| string into a USB keycode. 42 return ui::KeycodeConverter::CodeToUsbKeycode(codestr.c_str()); 43 } 44 45 bool PepperInputHandler::HandleInputEvent(const pp::InputEvent& event) { 46 switch (event.GetType()) { 47 case PP_INPUTEVENT_TYPE_CONTEXTMENU: { 48 // We need to return true here or else we'll get a local (plugin) context 49 // menu instead of the mouseup event for the right click. 50 return true; 51 } 52 53 case PP_INPUTEVENT_TYPE_KEYDOWN: 54 case PP_INPUTEVENT_TYPE_KEYUP: { 55 pp::KeyboardInputEvent pp_key_event(event); 56 uint32_t modifiers = event.GetModifiers(); 57 uint32_t lock_states = 0; 58 59 if (modifiers & PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY) 60 lock_states |= protocol::KeyEvent::LOCK_STATES_CAPSLOCK; 61 62 if (modifiers & PP_INPUTEVENT_MODIFIER_NUMLOCKKEY) 63 lock_states |= protocol::KeyEvent::LOCK_STATES_NUMLOCK; 64 65 protocol::KeyEvent key_event; 66 key_event.set_usb_keycode(GetUsbKeyCode(pp_key_event)); 67 key_event.set_pressed(event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN); 68 key_event.set_lock_states(lock_states); 69 70 if (input_stub_) 71 input_stub_->InjectKeyEvent(key_event); 72 return true; 73 } 74 75 case PP_INPUTEVENT_TYPE_MOUSEDOWN: 76 case PP_INPUTEVENT_TYPE_MOUSEUP: { 77 if (!has_focus_ && !send_mouse_input_when_unfocused_) 78 return false; 79 80 pp::MouseInputEvent pp_mouse_event(event); 81 protocol::MouseEvent mouse_event; 82 switch (pp_mouse_event.GetButton()) { 83 case PP_INPUTEVENT_MOUSEBUTTON_LEFT: 84 mouse_event.set_button(protocol::MouseEvent::BUTTON_LEFT); 85 break; 86 case PP_INPUTEVENT_MOUSEBUTTON_MIDDLE: 87 mouse_event.set_button(protocol::MouseEvent::BUTTON_MIDDLE); 88 break; 89 case PP_INPUTEVENT_MOUSEBUTTON_RIGHT: 90 mouse_event.set_button(protocol::MouseEvent::BUTTON_RIGHT); 91 break; 92 case PP_INPUTEVENT_MOUSEBUTTON_NONE: 93 break; 94 } 95 if (mouse_event.has_button()) { 96 bool is_down = (event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN); 97 mouse_event.set_button_down(is_down); 98 mouse_event.set_x(pp_mouse_event.GetPosition().x()); 99 mouse_event.set_y(pp_mouse_event.GetPosition().y()); 100 101 // Add relative movement if the mouse is locked. 102 if (mouse_lock_state_ == MouseLockOn) { 103 pp::Point delta = pp_mouse_event.GetMovement(); 104 mouse_event.set_delta_x(delta.x()); 105 mouse_event.set_delta_y(delta.y()); 106 } 107 108 if (input_stub_) 109 input_stub_->InjectMouseEvent(mouse_event); 110 } 111 return true; 112 } 113 114 case PP_INPUTEVENT_TYPE_MOUSEMOVE: 115 case PP_INPUTEVENT_TYPE_MOUSEENTER: 116 case PP_INPUTEVENT_TYPE_MOUSELEAVE: { 117 if (!has_focus_ && !send_mouse_input_when_unfocused_) 118 return false; 119 120 pp::MouseInputEvent pp_mouse_event(event); 121 protocol::MouseEvent mouse_event; 122 mouse_event.set_x(pp_mouse_event.GetPosition().x()); 123 mouse_event.set_y(pp_mouse_event.GetPosition().y()); 124 125 // Add relative movement if the mouse is locked. 126 if (mouse_lock_state_ == MouseLockOn) { 127 pp::Point delta = pp_mouse_event.GetMovement(); 128 mouse_event.set_delta_x(delta.x()); 129 mouse_event.set_delta_y(delta.y()); 130 } 131 132 if (input_stub_) 133 input_stub_->InjectMouseEvent(mouse_event); 134 return true; 135 } 136 137 case PP_INPUTEVENT_TYPE_WHEEL: { 138 if (!has_focus_ && !send_mouse_input_when_unfocused_) 139 return false; 140 141 pp::WheelInputEvent pp_wheel_event(event); 142 143 // Don't handle scroll-by-page events, for now. 144 if (pp_wheel_event.GetScrollByPage()) 145 return false; 146 147 // Add this event to our accumulated sub-pixel deltas and clicks. 148 pp::FloatPoint delta = pp_wheel_event.GetDelta(); 149 wheel_delta_x_ += delta.x(); 150 wheel_delta_y_ += delta.y(); 151 pp::FloatPoint ticks = pp_wheel_event.GetTicks(); 152 wheel_ticks_x_ += ticks.x(); 153 wheel_ticks_y_ += ticks.y(); 154 155 // If there is at least a pixel's movement, emit an event. We don't 156 // ever expect to accumulate one tick's worth of scrolling without 157 // accumulating a pixel's worth at the same time, so this is safe. 158 int delta_x = static_cast<int>(wheel_delta_x_); 159 int delta_y = static_cast<int>(wheel_delta_y_); 160 if (delta_x != 0 || delta_y != 0) { 161 wheel_delta_x_ -= delta_x; 162 wheel_delta_y_ -= delta_y; 163 protocol::MouseEvent mouse_event; 164 mouse_event.set_wheel_delta_x(delta_x); 165 mouse_event.set_wheel_delta_y(delta_y); 166 167 // Always include the ticks in the event, even if insufficient pixel 168 // scrolling has accumulated for a single tick. This informs hosts 169 // that can't inject pixel-based scroll events that the client will 170 // accumulate them into tick-based scrolling, which gives a better 171 // overall experience than trying to do this host-side. 172 int ticks_x = static_cast<int>(wheel_ticks_x_); 173 int ticks_y = static_cast<int>(wheel_ticks_y_); 174 wheel_ticks_x_ -= ticks_x; 175 wheel_ticks_y_ -= ticks_y; 176 mouse_event.set_wheel_ticks_x(ticks_x); 177 mouse_event.set_wheel_ticks_y(ticks_y); 178 179 if (input_stub_) 180 input_stub_->InjectMouseEvent(mouse_event); 181 } 182 return true; 183 } 184 185 case PP_INPUTEVENT_TYPE_CHAR: 186 // Consume but ignore character input events. 187 return true; 188 189 default: { 190 VLOG(0) << "Unhandled input event: " << event.GetType(); 191 break; 192 } 193 } 194 195 return false; 196 } 197 198 void PepperInputHandler::AllowMouseLock() { 199 DCHECK_EQ(mouse_lock_state_, MouseLockDisallowed); 200 mouse_lock_state_ = MouseLockOff; 201 } 202 203 void PepperInputHandler::DidChangeFocus(bool has_focus) { 204 has_focus_ = has_focus; 205 if (has_focus_) 206 RequestMouseLock(); 207 } 208 209 void PepperInputHandler::SetMouseCursor(scoped_ptr<pp::ImageData> image, 210 const pp::Point& hotspot) { 211 cursor_image_ = image.Pass(); 212 cursor_hotspot_ = hotspot; 213 214 if (mouse_lock_state_ != MouseLockDisallowed && !cursor_image_) { 215 RequestMouseLock(); 216 } else { 217 CancelMouseLock(); 218 } 219 } 220 221 void PepperInputHandler::MouseLockLost() { 222 DCHECK(mouse_lock_state_ == MouseLockOn || 223 mouse_lock_state_ == MouseLockCancelling); 224 225 mouse_lock_state_ = MouseLockOff; 226 UpdateMouseCursor(); 227 } 228 229 void PepperInputHandler::RequestMouseLock() { 230 // Request mouse lock only if the plugin is focused, the host-supplied cursor 231 // is empty and no callback is pending. 232 if (has_focus_ && !cursor_image_ && mouse_lock_state_ == MouseLockOff) { 233 pp::CompletionCallback callback = 234 callback_factory_.NewCallback(&PepperInputHandler::OnMouseLocked); 235 int result = pp::MouseLock::LockMouse(callback); 236 DCHECK_EQ(result, PP_OK_COMPLETIONPENDING); 237 238 // Hide cursor to avoid it becoming a black square (see crbug.com/285809). 239 pp::MouseCursor::SetCursor(instance_, PP_MOUSECURSOR_TYPE_NONE); 240 241 mouse_lock_state_ = MouseLockRequestPending; 242 } 243 } 244 245 void PepperInputHandler::CancelMouseLock() { 246 switch (mouse_lock_state_) { 247 case MouseLockDisallowed: 248 case MouseLockOff: 249 UpdateMouseCursor(); 250 break; 251 252 case MouseLockCancelling: 253 break; 254 255 case MouseLockRequestPending: 256 // The mouse lock request is pending. Delay UnlockMouse() call until 257 // the callback is called. 258 mouse_lock_state_ = MouseLockCancelling; 259 break; 260 261 case MouseLockOn: 262 pp::MouseLock::UnlockMouse(); 263 264 // Note that mouse-lock has been cancelled. We will continue to receive 265 // locked events until MouseLockLost() is called back. 266 mouse_lock_state_ = MouseLockCancelling; 267 break; 268 269 default: 270 NOTREACHED(); 271 } 272 } 273 274 void PepperInputHandler::UpdateMouseCursor() { 275 DCHECK(mouse_lock_state_ == MouseLockDisallowed || 276 mouse_lock_state_ == MouseLockOff); 277 278 if (cursor_image_) { 279 pp::MouseCursor::SetCursor(instance_, PP_MOUSECURSOR_TYPE_CUSTOM, 280 *cursor_image_, 281 cursor_hotspot_); 282 } else { 283 // If there is no cursor shape stored, either because the host never 284 // supplied one, or we were previously in mouse-lock mode, then use 285 // a standard arrow pointer. 286 pp::MouseCursor::SetCursor(instance_, PP_MOUSECURSOR_TYPE_POINTER); 287 } 288 } 289 290 void PepperInputHandler::OnMouseLocked(int error) { 291 DCHECK(mouse_lock_state_ == MouseLockRequestPending || 292 mouse_lock_state_ == MouseLockCancelling); 293 294 bool should_cancel = (mouse_lock_state_ == MouseLockCancelling); 295 296 // See if the operation succeeded. 297 if (error == PP_OK) { 298 mouse_lock_state_ = MouseLockOn; 299 } else { 300 mouse_lock_state_ = MouseLockOff; 301 UpdateMouseCursor(); 302 } 303 304 // Cancel as needed. 305 if (should_cancel) 306 CancelMouseLock(); 307 } 308 309 } // namespace remoting 310