remoting/host/local_input_monitor_mac.mm

   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/host/local_input_monitor.h"
   6
   7 #import <AppKit/AppKit.h>
   8 #include <set>
   9
  10 #include "base/bind.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/mac/scoped_cftyperef.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/single_thread_task_runner.h"
  17 #include "base/synchronization/lock.h"
  18 #include "base/threading/non_thread_safe.h"
  19 #include "remoting/host/client_session_control.h"
  20 #include "third_party/skia/include/core/SkPoint.h"
  21 #import "third_party/GTM/AppKit/GTMCarbonEvent.h"
  22
  23 // Esc Key Code is 53.
  24 // http://boredzo.org/blog/wp-content/uploads/2007/05/IMTx-virtual-keycodes.pdf
  25 static const NSUInteger kEscKeyCode = 53;
  26
  27 namespace remoting {
  28 namespace {
  29
  30 class LocalInputMonitorMac : public base::NonThreadSafe,
  31                              public LocalInputMonitor {
  32  public:
  33   // Invoked by LocalInputMonitorManager.
  34   class EventHandler {
  35    public:
  36     virtual ~EventHandler() {}
  37
  38     virtual void OnLocalMouseMoved(const SkIPoint& position) = 0;
  39     virtual void OnDisconnectShortcut() = 0;
  40   };
  41
  42   LocalInputMonitorMac(
  43       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  44       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
  45       base::WeakPtr<ClientSessionControl> client_session_control);
  46   virtual ~LocalInputMonitorMac();
  47
  48  private:
  49   // The actual implementation resides in LocalInputMonitorMac::Core class.
  50   class Core;
  51   scoped_refptr<Core> core_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorMac);
  54 };
  55
  56 }  // namespace
  57 }  // namespace remoting
  58
  59 @interface LocalInputMonitorManager : NSObject {
  60  @private
  61   GTMCarbonHotKey* hotKey_;
  62   CFRunLoopSourceRef mouseRunLoopSource_;
  63   base::ScopedCFTypeRef<CFMachPortRef> mouseMachPort_;
  64   remoting::LocalInputMonitorMac::EventHandler* monitor_;
  65 }
  66
  67 - (id)initWithMonitor:(remoting::LocalInputMonitorMac::EventHandler*)monitor;
  68
  69 // Called when the hotKey is hit.
  70 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey;
  71
  72 // Called when the local mouse moves
  73 - (void)localMouseMoved:(const SkIPoint&)mousePos;
  74
  75 // Must be called when the LocalInputMonitorManager is no longer to be used.
  76 // Similar to NSTimer in that more than a simple release is required.
  77 - (void)invalidate;
  78
  79 @end
  80
  81 static CGEventRef LocalMouseMoved(CGEventTapProxy proxy, CGEventType type,
  82                                   CGEventRef event, void* context) {
  83   int64_t pid = CGEventGetIntegerValueField(event, kCGEventSourceUnixProcessID);
  84   if (pid == 0) {
  85     CGPoint cgMousePos = CGEventGetLocation(event);
  86     SkIPoint mousePos = SkIPoint::Make(cgMousePos.x, cgMousePos.y);
  87     [static_cast<LocalInputMonitorManager*>(context) localMouseMoved:mousePos];
  88   }
  89   return NULL;
  90 }
  91
  92 @implementation LocalInputMonitorManager
  93
  94 - (id)initWithMonitor:(remoting::LocalInputMonitorMac::EventHandler*)monitor {
  95   if ((self = [super init])) {
  96     monitor_ = monitor;
  97
  98     GTMCarbonEventDispatcherHandler* handler =
  99         [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
 100     hotKey_ = [handler registerHotKey:kEscKeyCode
 101                              modifiers:(NSAlternateKeyMask | NSControlKeyMask)
 102                                 target:self
 103                                 action:@selector(hotKeyHit:)
 104                               userInfo:nil
 105                            whenPressed:YES];
 106     if (!hotKey_) {
 107       LOG(ERROR) << "registerHotKey failed.";
 108     }
 109     mouseMachPort_.reset(CGEventTapCreate(
 110         kCGSessionEventTap, kCGHeadInsertEventTap, kCGEventTapOptionListenOnly,
 111         1 << kCGEventMouseMoved, LocalMouseMoved, self));
 112     if (mouseMachPort_) {
 113       mouseRunLoopSource_ = CFMachPortCreateRunLoopSource(
 114           NULL, mouseMachPort_, 0);
 115       CFRunLoopAddSource(
 116           CFRunLoopGetMain(), mouseRunLoopSource_, kCFRunLoopCommonModes);
 117     } else {
 118       LOG(ERROR) << "CGEventTapCreate failed.";
 119     }
 120     if (!hotKey_ && !mouseMachPort_) {
 121       [self release];
 122       return nil;
 123     }
 124   }
 125   return self;
 126 }
 127
 128 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey {
 129   monitor_->OnDisconnectShortcut();
 130 }
 131
 132 - (void)localMouseMoved:(const SkIPoint&)mousePos {
 133   monitor_->OnLocalMouseMoved(mousePos);
 134 }
 135
 136 - (void)invalidate {
 137   if (hotKey_) {
 138     GTMCarbonEventDispatcherHandler* handler =
 139         [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
 140     [handler unregisterHotKey:hotKey_];
 141     hotKey_ = NULL;
 142   }
 143   if (mouseRunLoopSource_) {
 144     CFMachPortInvalidate(mouseMachPort_);
 145     CFRunLoopRemoveSource(
 146         CFRunLoopGetMain(), mouseRunLoopSource_, kCFRunLoopCommonModes);
 147     CFRelease(mouseRunLoopSource_);
 148     mouseMachPort_.reset(0);
 149     mouseRunLoopSource_ = NULL;
 150   }
 151 }
 152
 153 @end
 154
 155 namespace remoting {
 156 namespace {
 157
 158 class LocalInputMonitorMac::Core
 159     : public base::RefCountedThreadSafe<Core>,
 160       public EventHandler {
 161  public:
 162   Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 163        scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 164        base::WeakPtr<ClientSessionControl> client_session_control);
 165
 166   void Start();
 167   void Stop();
 168
 169  private:
 170   friend class base::RefCountedThreadSafe<Core>;
 171   virtual ~Core();
 172
 173   void StartOnUiThread();
 174   void StopOnUiThread();
 175
 176   // EventHandler interface.
 177   virtual void OnLocalMouseMoved(const SkIPoint& position) OVERRIDE;
 178   virtual void OnDisconnectShortcut() OVERRIDE;
 179
 180   // Task runner on which public methods of this class must be called.
 181   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 182
 183   // Task runner on which |window_| is created.
 184   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 185
 186   LocalInputMonitorManager* manager_;
 187
 188   // Invoked in the |caller_task_runner_| thread to report local mouse events
 189   // and session disconnect requests.
 190   base::WeakPtr<ClientSessionControl> client_session_control_;
 191
 192   DISALLOW_COPY_AND_ASSIGN(Core);
 193 };
 194
 195 LocalInputMonitorMac::LocalInputMonitorMac(
 196     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 197     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 198     base::WeakPtr<ClientSessionControl> client_session_control)
 199     : core_(new Core(caller_task_runner,
 200                      ui_task_runner,
 201                      client_session_control)) {
 202   core_->Start();
 203 }
 204
 205 LocalInputMonitorMac::~LocalInputMonitorMac() {
 206   core_->Stop();
 207 }
 208
 209 LocalInputMonitorMac::Core::Core(
 210     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 211     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 212     base::WeakPtr<ClientSessionControl> client_session_control)
 213     : caller_task_runner_(caller_task_runner),
 214       ui_task_runner_(ui_task_runner),
 215       manager_(nil),
 216       client_session_control_(client_session_control) {
 217   DCHECK(client_session_control_);
 218 }
 219
 220 void LocalInputMonitorMac::Core::Start() {
 221   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 222
 223   ui_task_runner_->PostTask(FROM_HERE,
 224                             base::Bind(&Core::StartOnUiThread, this));
 225 }
 226
 227 void LocalInputMonitorMac::Core::Stop() {
 228   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 229
 230   ui_task_runner_->PostTask(FROM_HERE, base::Bind(&Core::StopOnUiThread, this));
 231 }
 232
 233 LocalInputMonitorMac::Core::~Core() {
 234   DCHECK(manager_ == nil);
 235 }
 236
 237 void LocalInputMonitorMac::Core::StartOnUiThread() {
 238   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 239
 240   manager_ = [[LocalInputMonitorManager alloc] initWithMonitor:this];
 241 }
 242
 243 void LocalInputMonitorMac::Core::StopOnUiThread() {
 244   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 245
 246   [manager_ invalidate];
 247   [manager_ release];
 248   manager_ = nil;
 249 }
 250
 251 void LocalInputMonitorMac::Core::OnLocalMouseMoved(const SkIPoint& position) {
 252   caller_task_runner_->PostTask(
 253       FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
 254                             client_session_control_,
 255                             position));
 256 }
 257
 258 void LocalInputMonitorMac::Core::OnDisconnectShortcut() {
 259   caller_task_runner_->PostTask(
 260       FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
 261                             client_session_control_));
 262 }
 263
 264 }  // namespace
 265
 266 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
 267     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 268     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
 269     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 270     base::WeakPtr<ClientSessionControl> client_session_control) {
 271   return scoped_ptr<LocalInputMonitor>(
 272       new LocalInputMonitorMac(caller_task_runner,
 273                                ui_task_runner,
 274                                client_session_control));
 275 }
 276
 277 }  // namespace remoting