[remoting] Re-enable hotkey monitoring on MacOS.

This CL reverts
http://crrev.com/36980fe26e8d2e0ce2929e22d2e87ea3f88c02e5,
to re-enable LocalHotkeyInputMonitorMac. It also adds back the
dependency on google_toolbox_for_mac, needed for the code to build.

Bug: 1035613
Change-Id: I6e83cc225ab3cbde9f6a1be78caf5afd6295db66
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1975036
Auto-Submit: Lambros Lambrou <lambroslambrou@chromium.org>
Commit-Queue: Jamie Walch <jamiewalch@chromium.org>
Reviewed-by: Jamie Walch <jamiewalch@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#726204}

remoting/host/DEPS

@@ -20,6 +20,7 @@ include_rules = [
   "+services/device/public",
   "+services/device/wake_lock/power_save_blocker",
   "+services/network",
+  "+third_party/google_toolbox_for_mac",
   "+third_party/grpc",
   "+third_party/jsoncpp",
   "+third_party/skia",

remoting/host/input_monitor/BUILD.gn

@@ -39,6 +39,10 @@ source_set("input_monitor") {
     deps += [ "//ui/ozone" ]
   }
 
+  if (is_mac) {
+    deps += [ "//third_party/google_toolbox_for_mac" ]
+  }
+
   if (!use_x11 || (is_chromeos && !use_ozone)) {
     sources -= [
       "local_hotkey_input_monitor_x11.cc",

remoting/host/input_monitor/local_hotkey_input_monitor_mac.mm

@@ -3,16 +3,232 @@
 // found in the LICENSE file.
 
 #include "remoting/host/input_monitor/local_hotkey_input_monitor.h"
+
+#import <AppKit/AppKit.h>
+
+#include <cstdint>
+#include <utility>
+
+#include "base/bind.h"
 #include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/sequence_checker.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
+#import "third_party/google_toolbox_for_mac/src/AppKit/GTMCarbonEvent.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.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 {
+
+class LocalHotkeyInputMonitorMac : public LocalHotkeyInputMonitor {
+ public:
+  // Invoked by LocalHotkeyInputMonitorManager.
+  class EventHandler {
+   public:
+    virtual ~EventHandler() = default;
+
+    virtual void OnDisconnectShortcut() = 0;
+  };
+
+  LocalHotkeyInputMonitorMac(
+      scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      base::OnceClosure disconnect_callback);
+  ~LocalHotkeyInputMonitorMac() override;
+
+ private:
+  // The implementation resides in LocalHotkeyInputMonitorMac::Core class.
+  class Core;
+  scoped_refptr<Core> core_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
+  DISALLOW_COPY_AND_ASSIGN(LocalHotkeyInputMonitorMac);
+};
+
+}  // namespace
+}  // namespace remoting
+
+@interface LocalHotkeyInputMonitorManager : NSObject {
+ @private
+  GTMCarbonHotKey* _hotKey;
+  remoting::LocalHotkeyInputMonitorMac::EventHandler* _monitor;
+}
+
+- (id)initWithMonitor:
+    (remoting::LocalHotkeyInputMonitorMac::EventHandler*)monitor;
+
+// Called when the hotKey is hit.
+- (void)hotKeyHit:(GTMCarbonHotKey*)hotKey;
+
+// Must be called when the LocalHotkeyInputMonitorManager is no longer needed.
+// Similar to NSTimer in that more than a simple release is required.
+- (void)invalidate;
+
+@end
+
+@implementation LocalHotkeyInputMonitorManager
+
+- (id)initWithMonitor:
+    (remoting::LocalHotkeyInputMonitorMac::EventHandler*)monitor {
+  if ((self = [super init])) {
+    _monitor = monitor;
+
+    GTMCarbonEventDispatcherHandler* handler =
+        [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
+    _hotKey = [handler registerHotKey:kEscKeyCode
+                            modifiers:(NSAlternateKeyMask | NSControlKeyMask)
+                               target:self
+                               action:@selector(hotKeyHit:)
+                             userInfo:nil
+                          whenPressed:YES];
+    if (!_hotKey) {
+      LOG(ERROR) << "registerHotKey failed.";
+      [self release];
+      return nil;
+    }
+  }
+  return self;
+}
+
+- (void)hotKeyHit:(GTMCarbonHotKey*)hotKey {
+  _monitor->OnDisconnectShortcut();
+}
+
+- (void)invalidate {
+  if (_hotKey) {
+    GTMCarbonEventDispatcherHandler* handler =
+        [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
+    [handler unregisterHotKey:_hotKey];
+    _hotKey = nullptr;
+  }
+}
+
+@end
+
+namespace remoting {
+namespace {
+
+class LocalHotkeyInputMonitorMac::Core
+    : public base::RefCountedThreadSafe<Core>,
+      public EventHandler {
+ public:
+  Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+       base::OnceClosure disconnect_callback);
+
+  void Start();
+  void Stop();
+
+ private:
+  friend class base::RefCountedThreadSafe<Core>;
+  ~Core() override;
+
+  void StartOnUiThread();
+  void StopOnUiThread();
+
+  // EventHandler interface.
+  void OnDisconnectShortcut() override;
+
+  // Task runner on which public methods of this class must be called.
+  scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
+
+  // Task runner on which |window_| is created.
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
+
+  LocalHotkeyInputMonitorManager* manager_;
+
+  // Invoked in the |caller_task_runner_| thread to report session disconnect
+  // requests.
+  base::OnceClosure disconnect_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+LocalHotkeyInputMonitorMac::LocalHotkeyInputMonitorMac(
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    base::OnceClosure disconnect_callback)
+    : core_(new Core(caller_task_runner,
+                     ui_task_runner,
+                     std::move(disconnect_callback))) {
+  core_->Start();
+}
+
+LocalHotkeyInputMonitorMac::~LocalHotkeyInputMonitorMac() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  core_->Stop();
+}
+
+LocalHotkeyInputMonitorMac::Core::Core(
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    base::OnceClosure disconnect_callback)
+    : caller_task_runner_(caller_task_runner),
+      ui_task_runner_(ui_task_runner),
+      manager_(nil),
+      disconnect_callback_(std::move(disconnect_callback)) {
+  DCHECK(disconnect_callback_);
+}
+
+void LocalHotkeyInputMonitorMac::Core::Start() {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  ui_task_runner_->PostTask(FROM_HERE,
+                            base::BindOnce(&Core::StartOnUiThread, this));
+}
+
+void LocalHotkeyInputMonitorMac::Core::Stop() {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  ui_task_runner_->PostTask(FROM_HERE,
+                            base::BindOnce(&Core::StopOnUiThread, this));
+}
+
+LocalHotkeyInputMonitorMac::Core::~Core() {
+  DCHECK_EQ(manager_, nil);
+}
+
+void LocalHotkeyInputMonitorMac::Core::StartOnUiThread() {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+
+  manager_ = [[LocalHotkeyInputMonitorManager alloc] initWithMonitor:this];
+}
+
+void LocalHotkeyInputMonitorMac::Core::StopOnUiThread() {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+
+  [manager_ invalidate];
+  [manager_ release];
+  manager_ = nil;
+}
+
+void LocalHotkeyInputMonitorMac::Core::OnDisconnectShortcut() {
+  if (disconnect_callback_) {
+    caller_task_runner_->PostTask(FROM_HERE, std::move(disconnect_callback_));
+  }
+}
+
+}  // namespace
 
 std::unique_ptr<LocalHotkeyInputMonitor> LocalHotkeyInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::OnceClosure disconnect_callback) {
-  return nullptr;
+  return std::make_unique<LocalHotkeyInputMonitorMac>(
+      caller_task_runner, ui_task_runner, std::move(disconnect_callback));
 }
 
 }  // namespace remoting