Adds the UserInputMonitor implementation for Mac.

media/base/user_input_monitor_linux.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 <sys/select.h>
 #include <unistd.h>
 #define XK_MISCELLANY
 #include <X11/keysymdef.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_libevent.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/non_thread_safe.h"
+#include "media/base/keyboard_event_counter.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 
 // These includes need to be later than dictated by the style guide due to
 // Xlib header pollution, specifically the min, max, and Status macros.
 #include <X11/XKBlib.h>
 #include <X11/Xlibint.h>
 #include <X11/extensions/record.h>
 
 namespace media {
 
 namespace {
 
 class UserInputMonitorLinux : public base::NonThreadSafe,
                               public UserInputMonitor {
  public:
   UserInputMonitorLinux(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
   virtual ~UserInputMonitorLinux();
 
+  virtual size_t GetKeyPressCount() const OVERRIDE;
+
  private:
   enum EventType {
     MOUSE_EVENT,
     KEYBOARD_EVENT
   };
 
   // The actual implementation resides in UserInputMonitorLinux::Core class.
   // Must be called on the io_task_runner thread.
   class Core : public base::RefCountedThreadSafe<Core>,
                public base::MessagePumpLibevent::Watcher {
@@ skipping 37 matching lines @@
   virtual void StopMouseMonitoring() OVERRIDE;
   virtual void StartKeyboardMonitoring() OVERRIDE;
   virtual void StopKeyboardMonitoring() OVERRIDE;
 
   void OnMouseEvent(const SkIPoint& position);
   void OnKeyboardEvent(ui::EventType event, ui::KeyboardCode key_code);
 
   // Task runner on which X Window events are received.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<Core> core_;
+  KeyboardEventCounter counter_;
 
   DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
 };
 
 UserInputMonitorLinux::UserInputMonitorLinux(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : io_task_runner_(io_task_runner),
       core_(new Core(base::Bind(&UserInputMonitorLinux::OnMouseEvent,
                                 base::Unretained(this)),
                      base::Bind(&UserInputMonitorLinux::OnKeyboardEvent,
                                 base::Unretained(this)))) {}
 
 UserInputMonitorLinux::~UserInputMonitorLinux() {}
 
+size_t UserInputMonitorLinux::GetKeyPressCount() const {
+  return counter_.GetKeyPressCount();
+}
+
 void UserInputMonitorLinux::StartMouseMonitoring() {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::StartMonitor, core_.get(), MOUSE_EVENT));
 }
 
 void UserInputMonitorLinux::StopMouseMonitoring() {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::StopMonitor, core_.get(), MOUSE_EVENT));
 }
 
 void UserInputMonitorLinux::StartKeyboardMonitoring() {
+  counter_.Reset();
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::StartMonitor, core_.get(), KEYBOARD_EVENT));
 }
 
 void UserInputMonitorLinux::StopKeyboardMonitoring() {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::StopMonitor, core_.get(), KEYBOARD_EVENT));
 }
 
 void UserInputMonitorLinux::OnMouseEvent(const SkIPoint& position) {
   UserInputMonitor::OnMouseEvent(position);
 }
 
 void UserInputMonitorLinux::OnKeyboardEvent(ui::EventType event,
                                             ui::KeyboardCode key_code) {
-  UserInputMonitor::OnKeyboardEvent(event, key_code);
+  counter_.OnKeyboardEvent(event, key_code);
 }
 
 UserInputMonitorLinux::Core::Core(const MouseCallback& mouse_callback,
                                   const KeyboardCallback& keyboard_callback)
     : display_(NULL),
       x_record_display_(NULL),
       x_record_context_(0),
       mouse_callback_(mouse_callback),
       keyboard_callback_(keyboard_callback) {
   x_record_range_[0] = NULL;
@@ skipping 177 matching lines @@
 }  // namespace
 
 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>(
       new UserInputMonitorLinux(io_task_runner));
 }
 
 }  // namespace media