Adds the UserInputMonitor implementation for Mac.

media/base/user_input_monitor.cc

 // Copyright 2013 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 "media/base/user_input_monitor.h"
 
 #include "third_party/skia/include/core/SkPoint.h"
 
+#if defined(OS_MACOSX)
+#include <ApplicationServices/ApplicationServices.h>
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "base/time/time.h"
+#endif  // defined(OS_MACOSX)
+
 namespace media {
 
 #ifdef DISABLE_USER_INPUT_MONITOR
 scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
   return scoped_ptr<UserInputMonitor>();
 }
 #endif  // DISABLE_USER_INPUT_MONITOR
 
@@ skipping 14 matching lines @@
 void UserInputMonitor::RemoveMouseListener(MouseEventListener* listener) {
   base::AutoLock auto_lock(lock_);
   mouse_listeners_.RemoveObserver(listener);
   if (mouse_listeners_.size() == 0) {
     StopMouseMonitoring();
     monitoring_mouse_ = false;
     DVLOG(2) << "Stopped mouse monitoring.";
   }
 }
 void UserInputMonitor::AddKeyStrokeListener(KeyStrokeListener* listener) {
-  base::AutoLock auto_lock(lock_);
-  key_stroke_listeners_.AddObserver(listener);
-  if (!monitoring_keyboard_) {
-    StartKeyboardMonitoring();
-    monitoring_keyboard_ = true;
-    DVLOG(2) << "Started keyboard monitoring.";
+  bool start_polling = false;
+  {
+    base::AutoLock auto_lock(lock_);
+    key_stroke_listeners_.AddObserver(listener);
+    if (!monitoring_keyboard_) {
+  #if !defined(OS_MACOSX)
+      StartKeyboardMonitoring();
+  #else
+      start_polling = true;
+  #endif  // defined(OS_MACOSX)
+      monitoring_keyboard_ = true;
+      DVLOG(2) << "Started keyboard monitoring.";
+    }
+  }
+
+  if (start_polling) {
+    PollKeyState();
   }
 }
 void UserInputMonitor::RemoveKeyStrokeListener(KeyStrokeListener* listener) {
   base::AutoLock auto_lock(lock_);
   key_stroke_listeners_.RemoveObserver(listener);
   if (key_stroke_listeners_.size() == 0) {
+#if !defined(OS_MACOSX)
     StopKeyboardMonitoring();
+#endif  // !defined(OS_MACOSX)
+
     monitoring_keyboard_ = false;
     DVLOG(2) << "Stopped keyboard monitoring.";
   }
 }
 
 UserInputMonitor::UserInputMonitor()
     : monitoring_mouse_(false), monitoring_keyboard_(false) {}
 
 void UserInputMonitor::OnMouseEvent(const SkIPoint& position) {
   base::AutoLock auto_lock(lock_);
@@ skipping 11 matching lines @@
     pressed_keys_.insert(key_code);
     DVLOG(6) << "Key stroke detected.";
     FOR_EACH_OBSERVER(KeyStrokeListener, key_stroke_listeners_, OnKeyStroke());
   } else {
     DCHECK_EQ(ui::ET_KEY_RELEASED, event);
     DCHECK(pressed_keys_.find(key_code) != pressed_keys_.end());
     pressed_keys_.erase(key_code);
   }
 }
 
+void UserInputMonitor::PollKeyState() {

[DaleCurtis, 2013/08/19 23:49:00]

Seems like this should go in UserInputMonitorMac, no?  Instead of reimplementing
your KeyPress detection, can it just call OnKeyboardEvent() with the relevant
event and key_code?

[jiayl, 2013/08/20 00:21:15]

I would need another pressed_key_map in UserInputMonitorMac to keep track of the
pressed keys and fire Key_released notification while UserInputMonitor already
has a pressed_keys_. I put PollKeyState in UserInputMonitor to avoid the
duplication. If you think it's worthwhile for readability, I can move it into
UserInputMonitorMac.

[DaleCurtis, 2013/08/20 00:35:54]

If you allow OnKeyboardEvent() to be called w/ ET_KEY_RELEASED for keys not in
the pressed_keys_ set you can just call it instead of managing two maps.

I'd recommend introducing a protected method call OnKeyboardEvent_Locked() in
this case so you're not constantly reacquiring the AutoLock.

[jiayl, 2013/08/20 00:42:59]

So you mean firing Key_release for all keys not in a pressed state? That seems
too spamy, since you'll get callback for all keys in every poll if no typing is
happening.

[DaleCurtis, 2013/08/20 00:52:18]

OnKeyboardEvent() doesn't fire anything for ET_KEY_RELEASED.  What do you mean?

+#if defined(OS_MACOSX)
+  {
+    base::AutoLock auto_lock(lock_);
+    if (!monitoring_keyboard_)
+      return;
+  }
+  bool key_pressed = false;
+
+  // 0x5d is key "9", after that comes function keys.
+  for (int key_index = 0; key_index <= 0x5d; ++key_index) {
+    bool key_state = CGEventSourceKeyState(kCGEventSourceStateHIDSystemState,
+                                            key_index);

[DaleCurtis, 2013/08/19 23:49:00]

Indent is off.

[jiayl, 2013/08/20 00:21:15]

Done.

+
+    if (key_state && pressed_keys_.find(key_index) == pressed_keys_.end()) {

[DaleCurtis, 2013/08/19 23:49:00]

Save result so you're not calling find() twice.

[jiayl, 2013/08/20 00:21:15]

Done.

+      key_pressed = true;;
+      pressed_keys_.insert(key_index);
+    } else if (!key_state &&
+                pressed_keys_.find(key_index) != pressed_keys_.end()) {

[DaleCurtis, 2013/08/19 23:49:00]

Ditto.

[jiayl, 2013/08/20 00:21:15]

Done.

+      pressed_keys_.erase(key_index);
+    }
+  }
+
+  if (key_pressed) {
+    base::AutoLock auto_lock(lock_);
+    DVLOG(6) << "Key stroke detected.";
+    FOR_EACH_OBSERVER(KeyStrokeListener, key_stroke_listeners_, OnKeyStroke());
+  }
+
+  base::MessageLoop::current()->PostDelayedTask(

[DaleCurtis, 2013/08/19 23:49:00]

Which loop is this running on? It looks like it'll happen on whoever calls
AddKeyStrokeListener() first.  Instead you should probably have it execute on
the IO or UI loop.  Also this class is not RefCounted, so you need to ensure the
callback is not outstanding during destruction.  Usually you'd do this using a
CancellableClosure, but you may have difficulty due to your threading situation.

[jiayl, 2013/08/20 00:21:15]

Yeh, this is gross. But I don't want to run it on Browser IO/UI thread since
it's pretty expensive. Ideally it should run on a worker thread. How about
passing the audio thread to UserInputMonitor ctor and run on that? :)

[DaleCurtis, 2013/08/20 00:35:54]

Well not only is it gross, it doesn't work: consider the case where the message
loop the listener was added on goes away.  Also you say that you don't want it
on the UI or IO thread, but there's no guarantee current() isn't one of those.

How long does it take to scan all the keyboard codes? Also, you say you can't
get key events w/o assistive tech enabled, but what about:

https://developer.apple.com/library/mac/DOCUMENTATION/Cocoa/Conceptual/EventO...

Specifically
https://developer.apple.com/library/mac/DOCUMENTATION/Cocoa/Reference/Applica...

[DaleCurtis, 2013/08/20 00:40:00]

Ah, nevermind those require Assistive as well :/

[jiayl, 2013/08/20 00:42:59]

Right, the document says
A global event monitor looks for user-input events dispatched to applications
other than the one in which it is installed. The monitor cannot modify an event
or prevent its normal delivery. And it may only monitor key events *if
accessibility is enabled or if the application is trusted for accessibility*.

which is not true for Chrome on Mac, by default.
I think HenrikG mentioned that it took a few milliseconds to poll all keys.

[DaleCurtis, 2013/08/20 00:52:18]

Can we ask users for assistive access?  FYI, on OSX the Audio Thread is the UI
thread, so I don't think that'll work either if you don't want this running on
the UI thread.

+      FROM_HERE,
+      base::Bind(&UserInputMonitor::PollKeyState, base::Unretained(this)),
+      base::TimeDelta::FromMilliseconds(10));
+#endif  // defined(OS_MACOSX)
+}
+
 }  // namespace media