Clamp events before they are sent to EventExecutors.

remoting/host/event_executor_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/event_executor.h"
 
 #include <set>
 
 #include <X11/Xlib.h>
 #include <X11/XF86keysym.h>
@@ skipping 16 matching lines @@
 using protocol::MouseEvent;
 
 // USB to XKB keycode map table.
 #define USB_KEYMAP(usb, xkb, win, mac) {usb, xkb}
 #include "remoting/host/usb_keycode_map.h"
 #undef USB_KEYMAP
 
 // A class to generate events on Linux.
 class EventExecutorLinux : public EventExecutor {
  public:
-  EventExecutorLinux(MessageLoop* message_loop, Capturer* capturer);
+  EventExecutorLinux(MessageLoop* message_loop);
   virtual ~EventExecutorLinux();
 
   bool Init();
 
   // Clipboard stub interface.
   virtual void InjectClipboardEvent(const ClipboardEvent& event)
       OVERRIDE;
 
   // InputStub interface.
   virtual void InjectKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual void InjectMouseEvent(const MouseEvent& event) OVERRIDE;
 
  private:
   // |mode| is one of the AutoRepeatModeOn, AutoRepeatModeOff,
   // AutoRepeatModeDefault constants defined by the XChangeKeyboardControl()
   // API.
   void SetAutoRepeatForKey(int keycode, int mode);
   void InjectScrollWheelClicks(int button, int count);
 
   MessageLoop* message_loop_;
 
   std::set<int> pressed_keys_;
 
   // X11 graphics context.
   Display* display_;
   Window root_window_;
-  int width_;
-  int height_;
 
   int test_event_base_;
   int test_error_base_;
 
   DISALLOW_COPY_AND_ASSIGN(EventExecutorLinux);
 };
 
 int MouseButtonToX11ButtonNumber(MouseEvent::MouseButton button) {
   switch (button) {
     case MouseEvent::BUTTON_LEFT:
@@ skipping 181 matching lines @@
   /* VKEY_NONAME */ -1, /* VKEY_PA1 */ -1, /* VKEY_OEM_CLEAR */ -1, -1
 };
 
 int ChromotocolKeycodeToX11Keysym(int32_t keycode) {
   if (keycode < 0 || keycode > 255)
     return kInvalidKeycode;
 
   return kUsVkeyToKeysym[keycode];
 }
 
-EventExecutorLinux::EventExecutorLinux(MessageLoop* message_loop,
-                                       Capturer* capturer)
+EventExecutorLinux::EventExecutorLinux(MessageLoop* message_loop)
     : message_loop_(message_loop),
       display_(XOpenDisplay(NULL)),
-      root_window_(BadValue),
-      width_(0),
-      height_(0) {
+      root_window_(BadValue) {
 }
 
 EventExecutorLinux::~EventExecutorLinux() {
   CHECK(pressed_keys_.empty());
 }
 
 bool EventExecutorLinux::Init() {
   CHECK(display_);
 
   root_window_ = RootWindow(display_, DefaultScreen(display_));
   if (root_window_ == BadValue) {
     LOG(ERROR) << "Unable to get the root window";
     return false;
   }
 
   // TODO(ajwong): Do we want to check the major/minor version at all for XTest?
   int major = 0;
   int minor = 0;
   if (!XTestQueryExtension(display_, &test_event_base_, &test_error_base_,
                            &major, &minor)) {
     LOG(ERROR) << "Server does not support XTest.";
     return false;
   }
 
-  // Grab the width and height so we can figure out if mouse moves are out of
-  // range.
-  XWindowAttributes root_attr;
-  // TODO(ajwong): Handle resolution changes.
-  if (!XGetWindowAttributes(display_, root_window_, &root_attr)) {
-    LOG(ERROR) << "Unable to get window attributes";
-    return false;
-  }
-
-  width_ = root_attr.width;
-  height_ = root_attr.height;
   return true;
 }
 
 void EventExecutorLinux::InjectClipboardEvent(const ClipboardEvent& event) {
   // TODO(simonmorris): Implement clipboard injection.
 }
 
 void EventExecutorLinux::InjectKeyEvent(const KeyEvent& event) {
   // HostEventDispatcher should filter events missing the pressed field.
   DCHECK(event.has_pressed());
@@ skipping 57 matching lines @@
   control.auto_repeat_mode = mode;
   XChangeKeyboardControl(display_, KBKey | KBAutoRepeatMode, &control);
 }
 
 void EventExecutorLinux::InjectScrollWheelClicks(int button, int count) {
   for (int i = 0; i < count; i++) {
     // Generate a button-down and a button-up to simulate a wheel click.
     XTestFakeButtonEvent(display_, button, true, CurrentTime);
     XTestFakeButtonEvent(display_, button, false, CurrentTime);
   }
-  XFlush(display_);
 }
 
 void EventExecutorLinux::InjectMouseEvent(const MouseEvent& event) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&EventExecutorLinux::InjectMouseEvent,
                    base::Unretained(this), event));
     return;
   }
 
   if (event.has_x() && event.has_y()) {
-    if (event.x() < 0 || event.y() < 0 ||
-        event.x() > width_ || event.y() > height_) {
-      // A misbehaving client may send these. Drop events that are out of range.
-      // TODO(ajwong): How can we log this sanely? We don't want to DOS the
-      // server with a misbehaving client by logging like crazy.
-      return;
-    }
-
     VLOG(3) << "Moving mouse to " << event.x()
             << "," << event.y();
     XTestFakeMotionEvent(display_, DefaultScreen(display_),
                          event.x(), event.y(),
                          CurrentTime);
-    XFlush(display_);
   }
 
   if (event.has_button() && event.has_button_down()) {
     int button_number = MouseButtonToX11ButtonNumber(event.button());
 
     if (button_number < 0) {
       LOG(WARNING) << "Ignoring unknown button type: " << event.button();
       return;
     }
 
     VLOG(3) << "Button " << event.button()
             << " received, sending "
             << (event.button_down() ? "down " : "up ")
             << button_number;
     XTestFakeButtonEvent(display_, button_number, event.button_down(),
                          CurrentTime);
-    XFlush(display_);
   }
 
   if (event.has_wheel_offset_y() && event.wheel_offset_y() != 0) {
     int dy = event.wheel_offset_y();
     InjectScrollWheelClicks(VerticalScrollWheelToX11ButtonNumber(dy), abs(dy));
   }
   if (event.has_wheel_offset_x() && event.wheel_offset_x() != 0) {
     int dx = event.wheel_offset_x();
     InjectScrollWheelClicks(HorizontalScrollWheelToX11ButtonNumber(dx),
                             abs(dx));
   }
+
+  XFlush(display_);
 }
 
 }  // namespace
 
 scoped_ptr<protocol::HostEventStub> EventExecutor::Create(
     MessageLoop* message_loop, Capturer* capturer) {
   scoped_ptr<EventExecutorLinux> executor(
-      new EventExecutorLinux(message_loop, capturer));
-  if (!executor->Init()) {
-    executor.reset(NULL);
-  }
+      new EventExecutorLinux(message_loop));
+  if (!executor->Init())
+    return scoped_ptr<protocol::HostEventStub>(NULL);
   return executor.PassAs<protocol::HostEventStub>();
 }
 
 }  // namespace remoting