Adds the UserInputMonitor implementation for Mac.

media/base/user_input_monitor.h

 // 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.
 
 #ifndef MEDIA_BASE_USER_INPUT_MONITOR_H_
 #define MEDIA_BASE_USER_INPUT_MONITOR_H_
 
-#include <set>
-
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/synchronization/lock.h"
 #include "media/base/media_export.h"
-#include "ui/base/events/event_constants.h"
-#include "ui/base/keycodes/keyboard_codes.h"
 
 struct SkIPoint;
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace media {
 
 // Monitors and notifies about mouse movements and keyboard events.
 // Thread safe. The thread on which the listenters are called is not guaranteed.
 // The callers should not perform expensive/blocking tasks in the callback since
 // it might be called on the browser UI/IO threads.
+// The object must outlive the browser UI/IO threads to make sure the callbacks
+// will not access deleted object.

[Mark Mentovai, 2013/08/23 20:18:11]

access a deleted object.

[jiayl, 2013/08/23 23:47:58]

Done.

 class MEDIA_EXPORT UserInputMonitor {
  public:
   // The interface to receive mouse movement events.
   class MEDIA_EXPORT MouseEventListener {
    public:
     // |position| is the new mouse position.
     virtual void OnMouseMoved(const SkIPoint& position) = 0;
 
    protected:
     virtual ~MouseEventListener() {}
   };
-  // The interface to receive key stroke events.
-  class MEDIA_EXPORT KeyStrokeListener {
-   public:
-    // Called when any key is pressed. Called only once until the key is
-    // released, i.e. holding down a key for a long period will generate one
-    // callback just when the key is pressed down.
-    virtual void OnKeyStroke() = 0;
-
-   protected:
-    virtual ~KeyStrokeListener() {}
-  };
 
   virtual ~UserInputMonitor();
 
   // Creates a platform-specific instance of UserInputMonitor.
   // |io_task_runner| is the task runner for an IO thread.
   // |ui_task_runner| is the task runner for a UI thread.
   static scoped_ptr<UserInputMonitor> Create(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner);
 
   // The same |listener| should only be added once.
   // The clients should make sure to call Remove*Listener before |listener| is
   // destroyed.
   void AddMouseListener(MouseEventListener* listener);
   void RemoveMouseListener(MouseEventListener* listener);
-  void AddKeyStrokeListener(KeyStrokeListener* listener);
-  void RemoveKeyStrokeListener(KeyStrokeListener* listener);
+
+  // A caller must call EnableKeyPressMonitoring before calling
+  // GetKeyPressCount(), and call DisableKeyPressMonitoring when it no
+  // longer needs it.
+  void EnableKeyPressMonitoring();
+  void DisableKeyPressMonitoring();
+
+  // Returns the number of Keypresses since EnableKeyPressMonitoring is called
+  // for the first time.

[Mark Mentovai, 2013/08/23 20:18:11]

This comment is still confusing, because Enable-Disable will still zero the
count, so a subsequent Enable will start at 0 again despite not being “the first
time.”

I actually think that you don’t need to specify this so tightly. You can say
that it returns the number of keypresses, and that the caller must have enabled
keypress monitoring for it to be valid. That would implicitly refer to the
comment on the Enable/Disable calls above, so you shouldn’t need to say anything
more about it. It would also free you from mandating that you start the count at
0 when Enable is called for the first time. As this code is used, the actual
absolute count or zero reference doesn’t seem to matter, since you only ever
check equality. In fact, the Mac implementation can just return the value it
gets from the system routine directly, without having to subtract or track
initial_key_press_count_ at all. Simpler, right?

Keypresses is not a proper noun and does not use a capital K.

[jiayl, 2013/08/23 23:47:58]

Done.

+  virtual size_t GetKeyPressCount() const = 0;
 
  protected:
   UserInputMonitor();
 
   // Called by the platform-specific sub-classes to propagate the events to the
   // listeners.
   void OnMouseEvent(const SkIPoint& position);
-  void OnKeyboardEvent(ui::EventType event, ui::KeyboardCode key_code);
 
  private:
   virtual void StartMouseMonitoring() = 0;
   virtual void StopMouseMonitoring() = 0;
   virtual void StartKeyboardMonitoring() = 0;
   virtual void StopKeyboardMonitoring() = 0;
 
   base::Lock lock_;
   ObserverList<MouseEventListener, true> mouse_listeners_;
-  ObserverList<KeyStrokeListener, true> key_stroke_listeners_;
   bool monitoring_mouse_;
-  bool monitoring_keyboard_;
-  // The set of keys currently held down. Used for convering raw keyboard events
-  // into KeyStrokeListener callbacks.
-  std::set<ui::KeyboardCode> pressed_keys_;
+  size_t key_press_counter_references_;
 
   DISALLOW_COPY_AND_ASSIGN(UserInputMonitor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_USER_INPUT_MONITOR_H_