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 268 matching lines @@
   no_data_timer_->Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds),
       base::Bind(&AudioInputController::DoCheckForNoData,
       base::Unretained(this)));
 }
 
 void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
                                   uint32 size, uint32 hardware_delay_bytes,
                                   double volume) {
   bool key_pressed = false;
+#if defined(OS_MACOSX)
+  uint32_t current_count = CGEventSourceCounterForEventType(

[Mark Mentovai, 2013/08/22 18:27:52]

I don’t know much about when this thing is called. Is it guaranteed to be called
frequently? Or does it ever “pause?”

If it pauses, then when “unpaused,” you’ll need to reset prev_key_down_count_ to
the current counter value, otherwise it’ll give a false positive if any key had
been pressed during the paused interval.

In any case, if there isn’t a very long pause between the time an object of this
class is constructed and when OnData starts being called, you should initialize
prev_key_down_count_ to the correct value in the constructor. Then you can
remove the != 0 check on line 345. If the constructor is inappropriate but there
is some “start” function, you can initialize prev_key_down_count_ there instead.

[jiayl, 2013/08/22 18:51:16]

Done initialization in DoRecord.
I don't think it ever pauses unless the device is removed.
Dale, could you confirm?

+      kCGEventSourceStateHIDSystemState, kCGEventKeyDown);
+  if (current_count > prev_key_down_count_ && prev_key_down_count_ != 0) {

[Mark Mentovai, 2013/08/22 18:27:52]

If you change > to !=, then this handles rollover (counter overflow) too.

[jiayl, 2013/08/22 18:51:16]

Done.

+    key_pressed = true;
+  }
+  prev_key_down_count_ = current_count;
+#else
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
 
     std::swap(key_pressed, key_pressed_);
   }
+#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 38 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