Fix Ctrl+Alt+Esc keyboard shortcut in Me2Me host.

remoting/host/local_input_monitor_mac.mm

 // 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/local_input_monitor.h"
 
 #import <AppKit/AppKit.h>
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
-#include "remoting/host/chromoting_host.h"
+#include "remoting/host/mouse_move_observer.h"
+#include "third_party/skia/include/core/SkPoint.h"
 #import "third_party/GTM/AppKit/GTMCarbonEvent.h"
 
 // Esc Key Code is 53.
 // http://boredzo.org/blog/wp-content/uploads/2007/05/IMTx-virtual-keycodes.pdf
 static const NSUInteger kEscKeyCode = 53;
 
+namespace remoting {
+
 namespace {
-typedef std::set<scoped_refptr<remoting::ChromotingHost> > Hosts;
-}
+
+class LocalInputMonitorMac : public LocalInputMonitor {

[Jamie, 2012/05/25 21:19:24]

I realize that you inherited this from the older code, but I got confused
initially with the variable name |monitors_|, thinking it was referring to VDUs.
I wonder if Observer might be a better terminology throughout? Right now it's a
bit inconsistent, particuarly wrt comments vs. code.

[Sergey Ulanov, 2012/05/25 21:59:30]

Yes, I agree that the current terminology is confusing, but I don't think that
renaming monitors_ to observers_ would make it better, as observers_ can be
confused with MouseMoveObservers. I renamed LocalInputMonitorImpl to
LocalInputMonitorManager - this makes relationship between
LocalInputMonitorManager and LocalInputMonitorMac clearer, though it's not
completely correct to call it a manager.

+ public:
+  LocalInputMonitorMac() : mouse_move_observer_(NULL) {}
+  virtual ~LocalInputMonitorMac();
+  virtual void Start(MouseMoveObserver* mouse_move_observer,
+                     const base::Closure& disconnect_callback) OVERRIDE;
+  virtual void Stop() OVERRIDE;
+
+  void OnMouseMoved(const SkIPoint& new_pos);
+  void OnDisconnectShortcut();
+
+ private:
+  MouseMoveObserver* mouse_move_observer_;
+  base::Closure disconnect_callback_;
+  DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorMac);
+};
+
+typedef std::set<remoting::LocalInputMonitorMac*> LocalInputMonitors;
+
+}  // namespace
+
+}  // namespace remoting
 
 @interface LocalInputMonitorImpl : NSObject {
  @private
   GTMCarbonHotKey* hotKey_;
   CFRunLoopSourceRef mouseRunLoopSource_;
   base::mac::ScopedCFTypeRef<CFMachPortRef> mouseMachPort_;
-  base::Lock hostsLock_;
-  Hosts hosts_;
+  base::Lock lock_;
+  remoting::LocalInputMonitors monitors_;
 }
 
 // Called when the hotKey is hit.
 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey;
 
 // Called when the local mouse moves
 - (void)localMouseMoved:(const SkIPoint&)mousePos;
 
 // Must be called when the LocalInputMonitorImpl is no longer to be used.
 // Similar to NSTimer in that more than a simple release is required.
 - (void)invalidate;
 
-// Called to add a host to the list of those to be Shutdown() when the hotkey
-// is pressed.
-- (void)addHost:(remoting::ChromotingHost*)host;
+// Called to add a monitor.
+- (void)addMonitor:(remoting::LocalInputMonitorMac*)monitor;
 
-// Called to remove a host. Returns true if it was the last host being
-// monitored, in which case the object should be destroyed.
-- (bool)removeHost:(remoting::ChromotingHost*)host;
-
-// Disabled disconnection keyboard shortcut.
-- (void)disableShortcut;
+// Called to remove a mouse move observers. Returns true if it was the

[Jamie, 2012/05/25 21:19:24]

s/observers/observer/

[Sergey Ulanov, 2012/05/25 21:59:30]

It actually removes monitor.

+// last observer, in which case the object should be destroyed.
+- (bool)removeMonitor:(remoting::LocalInputMonitorMac*)monitor;
 
 @end
 
 static CGEventRef LocalMouseMoved(CGEventTapProxy proxy, CGEventType type,
                                   CGEventRef event, void* context) {
   int64_t pid = CGEventGetIntegerValueField(event, kCGEventSourceUnixProcessID);
   if (pid == 0) {
     CGPoint cgMousePos = CGEventGetLocation(event);
     SkIPoint mousePos = SkIPoint::Make(cgMousePos.x, cgMousePos.y);
     [static_cast<LocalInputMonitorImpl*>(context) localMouseMoved:mousePos];
@@ skipping 29 matching lines @@
     }
     if (!hotKey_ && !mouseMachPort_) {
       [self release];
       return nil;
     }
   }
   return self;
 }
 
 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey {
-  base::AutoLock lock(hostsLock_);
-  for (Hosts::const_iterator i = hosts_.begin(); i != hosts_.end(); ++i) {
-    (*i)->Shutdown(base::Closure());
+  base::AutoLock lock(lock_);
+  for (remoting::LocalInputMonitors::const_iterator i = monitors_.begin();
+       i != monitors_.end(); ++i) {
+    (*i)->OnDisconnectShortcut();
   }
 }
 
 - (void)localMouseMoved:(const SkIPoint&)mousePos {
-  base::AutoLock lock(hostsLock_);
-  for (Hosts::const_iterator i = hosts_.begin(); i != hosts_.end(); ++i) {
-    (*i)->LocalMouseMoved(mousePos);
+  base::AutoLock lock(lock_);
+  for (remoting::LocalInputMonitors::const_iterator i = monitors_.begin();
+       i != monitors_.end(); ++i) {
+    (*i)->OnMouseMoved(mousePos);
   }
 }
 
 - (void)invalidate {
   if (hotKey_) {
     GTMCarbonEventDispatcherHandler* handler =
         [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
     [handler unregisterHotKey:hotKey_];
     hotKey_ = NULL;
   }
   if (mouseRunLoopSource_) {
     CFMachPortInvalidate(mouseMachPort_);
     CFRunLoopRemoveSource(
         CFRunLoopGetMain(), mouseRunLoopSource_, kCFRunLoopCommonModes);
     CFRelease(mouseRunLoopSource_);
     mouseMachPort_.reset(0);
     mouseRunLoopSource_ = NULL;
   }
 }
 
-- (void)addHost:(remoting::ChromotingHost*)host {
-  base::AutoLock lock(hostsLock_);
-  hosts_.insert(host);
+- (void)addMonitor:(remoting::LocalInputMonitorMac*)monitor {
+  base::AutoLock lock(lock_);
+  monitors_.insert(monitor);
 }
 
-- (bool)removeHost:(remoting::ChromotingHost*)host {
-  base::AutoLock lock(hostsLock_);
-  hosts_.erase(host);
-  return hosts_.empty();
-}
-
-- (void)disableShortcut {
-  if (hotKey_) {
-    GTMCarbonEventDispatcherHandler* handler =
-        [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
-    [handler unregisterHotKey:hotKey_];
-    hotKey_ = NULL;
-  }
+- (bool)removeMonitor:(remoting::LocalInputMonitorMac*)monitor {
+  base::AutoLock lock(lock_);
+  monitors_.erase(monitor);
+  return monitors_.empty();
 }
 
 @end
 
 namespace remoting {
 
 namespace {
 
-class LocalInputMonitorMac : public LocalInputMonitor {
- public:
-  LocalInputMonitorMac() : host_(NULL) {}
-  virtual ~LocalInputMonitorMac();
-  virtual void Start(ChromotingHost* host) OVERRIDE;
-  virtual void Stop() OVERRIDE;
-  virtual void DisableShortcutOnMac() OVERRIDE;
-
- private:
-  ChromotingHost* host_;
-  DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorMac);
-};
-
-base::LazyInstance<base::Lock>::Leaky monitor_lock = LAZY_INSTANCE_INITIALIZER;
-LocalInputMonitorImpl* local_input_monitor = NULL;
+base::LazyInstance<base::Lock>::Leaky g_monitor_lock =
+    LAZY_INSTANCE_INITIALIZER;
+LocalInputMonitorImpl* g_local_input_monitor = NULL;
 
 }  // namespace
 
 LocalInputMonitorMac::~LocalInputMonitorMac() {
   Stop();
 }
 
-void LocalInputMonitorMac::Start(ChromotingHost* host) {
-  base::AutoLock lock(monitor_lock.Get());
-  if (!local_input_monitor)
-    local_input_monitor = [[LocalInputMonitorImpl alloc] init];
-  CHECK(local_input_monitor);
-  [local_input_monitor addHost:host];
-  host_ = host;
+void LocalInputMonitorMac::Start(MouseMoveObserver* mouse_move_observer,
+                                 const base::Closure& disconnect_callback) {
+  base::AutoLock lock(g_monitor_lock.Get());
+  if (!g_local_input_monitor)
+    g_local_input_monitor = [[LocalInputMonitorImpl alloc] init];
+  CHECK(g_local_input_monitor);
+  mouse_move_observer_ = mouse_move_observer;
+  disconnect_callback_ = disconnect_callback;
+  [g_local_input_monitor addMonitor:this];
 }
 
 void LocalInputMonitorMac::Stop() {
-  base::AutoLock lock(monitor_lock.Get());
-  if ([local_input_monitor removeHost:host_]) {
-    [local_input_monitor invalidate];
-    [local_input_monitor release];
-    local_input_monitor = nil;
+  base::AutoLock lock(g_monitor_lock.Get());
+  if ([g_local_input_monitor removeMonitor:this]) {
+    [g_local_input_monitor invalidate];
+    [g_local_input_monitor release];
+    g_local_input_monitor = nil;
   }
 }
 
-void LocalInputMonitorMac::DisableShortcutOnMac() {
-  [local_input_monitor disableShortcut];
+void LocalInputMonitorMac::OnMouseMoved(const SkIPoint& new_pos) {
+  mouse_move_observer_->OnMouseMoved(new_pos);
+}
+
+void LocalInputMonitorMac::OnDisconnectShortcut() {
+  disconnect_callback_.Run();
 }
 
 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create() {
   return scoped_ptr<LocalInputMonitor>(new LocalInputMonitorMac());
 }
 
 }  // namespace remoting