Adding key press detection in the browser process.

media/audio/audio_input_controller.cc

Index: media/audio/audio_input_controller.cc
diff --git a/media/audio/audio_input_controller.cc b/media/audio/audio_input_controller.cc
index 31e137e2b17e4442c00979e85cbcffa31cd53cba..351434f72d8938914d7c298d5019919ea037f8dc 100644
--- a/media/audio/audio_input_controller.cc
+++ b/media/audio/audio_input_controller.cc
@@ -36,14 +36,17 @@ namespace media {
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
 AudioInputController::AudioInputController(EventHandler* handler,
-                                           SyncWriter* sync_writer)
+                                           SyncWriter* sync_writer,
+                                           KeyPressMonitor* key_press_monitor)
     : creator_loop_(base::MessageLoopProxy::current()),
       handler_(handler),
       stream_(NULL),
       data_is_active_(false),
       state_(kEmpty),
       sync_writer_(sync_writer),
-      max_volume_(0.0) {
+      max_volume_(0.0),
+      key_press_monitor_(key_press_monitor),
+      key_pressed_(false) {
   DCHECK(creator_loop_.get());
 }
 
@@ -56,17 +59,19 @@ scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
-    const std::string& device_id) {
+    const std::string& device_id,
+    KeyPressMonitor* key_press_monitor) {
   DCHECK(audio_manager);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
     return NULL;
 
-  if (factory_)
-    return factory_->Create(audio_manager, event_handler, params);
-
-  scoped_refptr<AudioInputController> controller(new AudioInputController(
-      event_handler, NULL));
+  if (factory_) {
+    return factory_->Create(
+        audio_manager, event_handler, params, key_press_monitor);
+  }
+  scoped_refptr<AudioInputController> controller(
+      new AudioInputController(event_handler, NULL, key_press_monitor));
 
   controller->message_loop_ = audio_manager->GetMessageLoop();
 
@@ -87,7 +92,8 @@ scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& device_id,
-    SyncWriter* sync_writer) {
+    SyncWriter* sync_writer,
+    KeyPressMonitor* key_press_monitor) {
   DCHECK(audio_manager);
   DCHECK(sync_writer);
 
@@ -96,8 +102,8 @@ scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
 
   // Create the AudioInputController object and ensure that it runs on
   // the audio-manager thread.
-  scoped_refptr<AudioInputController> controller(new AudioInputController(
-      event_handler, sync_writer));
+  scoped_refptr<AudioInputController> controller(
+      new AudioInputController(event_handler, sync_writer, key_press_monitor));
   controller->message_loop_ = audio_manager->GetMessageLoop();
 
   // Create and open a new audio input stream from the existing
@@ -116,14 +122,15 @@ scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     EventHandler* event_handler,
     AudioInputStream* stream,
-    SyncWriter* sync_writer) {
+    SyncWriter* sync_writer,
+    KeyPressMonitor* key_press_monitor) {
   DCHECK(sync_writer);
   DCHECK(stream);
 
   // Create the AudioInputController object and ensure that it runs on
   // the audio-manager thread.
-  scoped_refptr<AudioInputController> controller(new AudioInputController(
-      event_handler, sync_writer));
+  scoped_refptr<AudioInputController> controller(
+      new AudioInputController(event_handler, sync_writer, key_press_monitor));
   controller->message_loop_ = message_loop;
 
   // TODO(miu): See TODO at top of file.  Until that's resolved, we need to
@@ -233,6 +240,9 @@ void AudioInputController::DoRecord() {
 
   stream_->Start(this);
   handler_->OnRecording(this);
+
+  if (key_press_monitor_)
+    key_press_monitor_->AddKeyPressListener(this);
 }
 
 void AudioInputController::DoClose() {
@@ -252,6 +262,8 @@ void AudioInputController::DoClose() {
 
     state_ = kClosed;
   }
+  if (key_press_monitor_)
+    key_press_monitor_->RemoveKeyPressListener(this);
 }
 
 void AudioInputController::DoReportError() {
@@ -320,10 +332,13 @@ void AudioInputController::DoCheckForNoData() {
 void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
                                   uint32 size, uint32 hardware_delay_bytes,
                                   double volume) {
+  bool key_pressed = false;
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
+
+    std::swap(key_pressed, key_pressed_);

[tommi (sloooow) - chröme, 2013/08/06 10:57:47]

this resets key_pressed_.  I'm assuming that's intentional but I'm wondering if
that's correct (and perhaps it is as correct and efficient as we can make it
with the current implementation).
In the webrtc implementation the whole keyboard was polled for every audio
callback which while not efficient, behaves differently than this approach and
might tickle the algorithm differently.  I'm just wondering about the background
here...  I guess the question I'm trying to ask is: does it work? :)

[jiayl, 2013/08/06 17:24:11]

I might miss something, but AFAIK this logic produces the same result as the
webrtc implementation.

Take Linux for example, the webrtc implementation is
https://cs.corp.google.com/#perforce10///depot/googleclient/third_party/webrt...

for (i = 0; i < sizeof(szKey); i++)
    state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i];
return state != 0;
where szKey is the current key states, and oldKeyState is the key states of the
previous sampling period.
So |state| is non-zero when a key is pressed in this sampling period but not
pressed in the last sampling period.

In the impl of this CL, key_pressed_ is set true whenever a key is pressed
(holding a key will only set key_pressed_ once). Then we need to reset
key_pressed_ after each sampling so that a key pressed in the last sampling
period will not be carried to the next samplings.

Make sense?

[tommi (sloooow) - chröme, 2013/08/07 11:42:55]

The implementation in this CL behaves slightly differently.
Consider pressing a key and hold it down for a whole second.  In the webrtc
example, keypressed will be true for the whole period while this implementation
will report keypressed as true for only the first audio data callback, then
clear the keypressed variable and report false for the remainder of the period
and then ignore the key-released event.

However, I don't think this really matters for our purposes right now, so the
current approach lgtm.

   }
 
   // Mark data as active to ensure that the periodic calls to
@@ -332,7 +347,7 @@ void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
 
   // Use SyncSocket if we are in a low-latency mode.
   if (LowLatencyMode()) {
-    sync_writer_->Write(data, size, volume);
+    sync_writer_->Write(data, size, volume, key_pressed);
     sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
     return;
   }
@@ -353,8 +368,14 @@ void AudioInputController::OnError(AudioInputStream* stream) {
       &AudioInputController::DoReportError, this));
 }
 
+void AudioInputController::OnKeyPressed() {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  base::AutoLock auto_lock(lock_);
+  key_pressed_ = true;
+}
+
 void AudioInputController::DoStopCloseAndClearStream(
-    base::WaitableEvent *done) {
+    base::WaitableEvent* done) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream to close.