Adds the UserInputMonitor implementation for Mac.

media/audio/audio_input_controller.cc

 // 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 "media/audio/audio_input_controller.h"
 
 #include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/base/limits.h"
 #include "media/base/scoped_histogram_timer.h"
 
+#if defined(OS_MACOSX)
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
 namespace {
 const int kMaxInputChannels = 2;
 
 // TODO(henrika): remove usage of timers and add support for proper
 // notification of when the input device is removed.  This was originally added
 // to resolve http://crbug.com/79936 for Windows platforms.  This then caused
 // breakage (very hard to repro bugs!) on other platforms: See
 // http://crbug.com/226327 and http://crbug.com/230972.
 const int kTimerResetIntervalSeconds = 1;
 #if defined(OS_IOS)
@@ skipping 17 matching lines @@
                                            SyncWriter* sync_writer,
                                            UserInputMonitor* user_input_monitor)
     : creator_loop_(base::MessageLoopProxy::current()),
       handler_(handler),
       stream_(NULL),
       data_is_active_(false),
       state_(kEmpty),
       sync_writer_(sync_writer),
       max_volume_(0.0),
       user_input_monitor_(user_input_monitor),
+      prev_key_down_count_(0),
       key_pressed_(false) {
   DCHECK(creator_loop_.get());
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
@@ skipping 175 matching lines @@
 
   if (no_data_timer_) {
     // Start the data timer. Once |kTimerResetIntervalSeconds| have passed,
     // a callback to DoCheckForNoData() is made.
     no_data_timer_->Reset();
   }
 
   stream_->Start(this);
   handler_->OnRecording(this);
 
+#if defined(OS_MACOSX)
+  prev_key_down_count_ = CGEventSourceCounterForEventType(
+      kCGEventSourceStateHIDSystemState, kCGEventKeyDown);
+#endif  // defined(OS_MACOSX)
+
   if (user_input_monitor_)
     user_input_monitor_->AddKeyStrokeListener(this);
 }
 
 void AudioInputController::DoClose() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");
 
   // Delete the timer on the same thread that created it.
   no_data_timer_.reset();
@@ skipping 81 matching lines @@
                                   double volume) {
   bool key_pressed = false;
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
 
     std::swap(key_pressed, key_pressed_);
   }
 
+  #if defined(OS_MACOSX)

[Robert Sesek, 2013/08/22 20:45:16]

nit: #if should not be indented

+    uint32_t current_count = CGEventSourceCounterForEventType(
+        kCGEventSourceStateHIDSystemState, kCGEventKeyDown);
+    if (current_count != prev_key_down_count_) {
+      key_pressed = true;
+    }
+    prev_key_down_count_ = current_count;
+  #endif  // defined(OS_MACOSX)
+
   // Mark data as active to ensure that the periodic calls to
   // DoCheckForNoData() does not report an error to the event handler.
   SetDataIsActive(true);
 
   // Use SyncSocket if we are in a low-latency mode.
   if (LowLatencyMode()) {
     sync_writer_->Write(data, size, volume, key_pressed);
     sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
     return;
   }
@@ skipping 37 matching lines @@
 
 void AudioInputController::SetDataIsActive(bool enabled) {
   base::subtle::Release_Store(&data_is_active_, enabled);
 }
 
 bool AudioInputController::GetDataIsActive() {
   return (base::subtle::Acquire_Load(&data_is_active_) != false);
 }
 
 }  // namespace media