Clamp events before they are sent to EventExecutors.

remoting/host/event_executor_mac.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 <ApplicationServices/ApplicationServices.h>
 #include <Carbon/Carbon.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/message_loop.h"
-#include "remoting/host/capturer.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/protocol/message_decoder.h"
+#include "third_party/skia/include/core/SkPoint.h"
 
 namespace remoting {
 
 namespace {
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::MouseEvent;
 
 // USB to Mac keycode mapping table.
 #define USB_KEYMAP(usb, xkb, win, mac) {usb, mac}
 #include "remoting/host/usb_keycode_map.h"
 #undef USB_KEYMAP
 
 // A class to generate events on Mac.
 class EventExecutorMac : public EventExecutor {
  public:
-  EventExecutorMac(MessageLoop* message_loop, Capturer* capturer);
+  EventExecutorMac(MessageLoop* message_loop);
   virtual ~EventExecutorMac() {}
 
   // ClipboardStub 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:
   MessageLoop* message_loop_;
-  Capturer* capturer_;
-  int last_x_, last_y_;
-  int mouse_buttons_;
+  SkIPoint mouse_pos_;
+  uint32 mouse_button_state_;
 
   DISALLOW_COPY_AND_ASSIGN(EventExecutorMac);
 };
 
 EventExecutorMac::EventExecutorMac(
-    MessageLoop* message_loop, Capturer* capturer)
-    : message_loop_(message_loop),
-      capturer_(capturer), last_x_(0), last_y_(0), mouse_buttons_(0) {
+    MessageLoop* message_loop)
+    : message_loop_(message_loop), mouse_button_state_(0) {
 }
 
 // Hard-coded mapping from Virtual Key codes to Mac KeySyms.
 // This mapping is only valid if both client and host are using a
 // US English keyboard layout.
 // Because we're passing VK codes on the wire, with no Scancode,
 // "extended" flag, etc, things like distinguishing left & right
 // Shift keys doesn't work.
 //
 // TODO(wez): Replace this with something more closely tied to what
@@ skipping 200 matching lines @@
   // We use the deprecated event injection API because the new one doesn't
   // work with switched-out sessions (curtain mode).
   CGError error = CGPostKeyboardEvent(0, keycode, event.pressed());
   if (error != kCGErrorSuccess) {
     LOG(WARNING) << "CGPostKeyboardEvent error " << error;
   }
 }
 
 void EventExecutorMac::InjectMouseEvent(const MouseEvent& event) {
   if (event.has_x() && event.has_y()) {
-    // TODO(wez): Checking the validity of the MouseEvent should be done in core
-    // cross-platform code, not here!
     // TODO(wez): This code assumes that MouseEvent(0,0) (top-left of client view)
     // corresponds to local (0,0) (top-left of primary monitor).  That won't in
     // general be true on multi-monitor systems, though.
-    SkISize size = capturer_->size_most_recent();
-    if (event.x() >= 0 || event.y() >= 0 ||
-        event.x() < size.width() || event.y() < size.height()) {
-      VLOG(3) << "Moving mouse to " << event.x() << "," << event.y();
-      last_x_ = event.x();
-      last_y_ = event.y();
-    } else {
-      VLOG(1) << "Invalid mouse position " << event.x() << "," << event.y();
-    }
+    VLOG(3) << "Moving mouse to " << event.x() << "," << event.y();
+    mouse_pos_ = SkIPoint::Make(event.x(), event.y());
   }
   if (event.has_button() && event.has_button_down()) {
     if (event.button() >= 1 && event.button() <= 3) {
       VLOG(2) << "Button " << event.button()
               << (event.button_down() ? " down" : " up");
       int button_change = 1 << (event.button() - 1);
       if (event.button_down())
-        mouse_buttons_ |= button_change;
+        mouse_button_state_ |= button_change;
       else
-        mouse_buttons_ &= ~button_change;
+        mouse_button_state_ &= ~button_change;
     } else {
       VLOG(1) << "Unknown mouse button: " << event.button();
     }
   }
   // We use the deprecated CGPostMouseEvent API because we receive low-level
   // mouse events, whereas CGEventCreateMouseEvent is for injecting higher-level
   // events. For example, the deprecated APIs will detect double-clicks or drags
   // in a way that is consistent with how they would be generated using a local
   // mouse, whereas the new APIs expect us to inject these higher-level events
   // directly.
-  CGPoint position = CGPointMake(last_x_, last_y_);
+  CGPoint position = CGPointMake(mouse_pos_.x(), mouse_pos_.y());
   enum {
     LeftBit = 1 << (MouseEvent::BUTTON_LEFT - 1),
     MiddleBit = 1 << (MouseEvent::BUTTON_MIDDLE - 1),
     RightBit = 1 << (MouseEvent::BUTTON_RIGHT - 1)
   };
   CGError error = CGPostMouseEvent(position, true, 3,
-                                   (mouse_buttons_ & LeftBit) != 0,
-                                   (mouse_buttons_ & RightBit) != 0,
-                                   (mouse_buttons_ & MiddleBit) != 0);
+                                   (mouse_button_state_ & LeftBit) != 0,
+                                   (mouse_button_state_ & RightBit) != 0,
+                                   (mouse_button_state_ & MiddleBit) != 0);
   if (error != kCGErrorSuccess) {
     LOG(WARNING) << "CGPostMouseEvent error " << error;
   }
 
   if (event.has_wheel_offset_x() && event.has_wheel_offset_y()) {
     int dx = event.wheel_offset_x();
     int dy = event.wheel_offset_y();
     // Note that |dy| (the vertical wheel) is the primary wheel.
     error = CGPostScrollWheelEvent(2, dy, dx);
     if (error != kCGErrorSuccess) {
       LOG(WARNING) << "CGPostScrollWheelEvent error " << error;
     }
   }
 }
 
 }  // namespace
 
 scoped_ptr<protocol::HostEventStub> EventExecutor::Create(
     MessageLoop* message_loop, Capturer* capturer) {
   return scoped_ptr<protocol::HostEventStub>(
-      new EventExecutorMac(message_loop, capturer));
+      new EventExecutorMac(message_loop));
 }
 
 }  // namespace remoting