Adding key press detection in the browser process.

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"
@@ skipping 18 matching lines @@
 const int kTimerInitialIntervalSeconds = 5;
 #endif  // defined(OS_IOS)
 }
 
 namespace media {
 
 // static
 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());
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
 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();
 
   // Create and open a new audio input stream from the existing
   // audio-device thread.
   if (!controller->message_loop_->PostTask(FROM_HERE,
           base::Bind(&AudioInputController::DoCreate, controller,
                      base::Unretained(audio_manager), params, device_id))) {
     controller = NULL;
   }
 
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
     AudioManager* audio_manager,
     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);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
     return NULL;
 
   // 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
   // audio-device thread. Use the provided audio-input device.
   if (!controller->message_loop_->PostTask(FROM_HERE,
           base::Bind(&AudioInputController::DoCreate, controller,
                      base::Unretained(audio_manager), params, device_id))) {
     controller = NULL;
   }
 
   return controller;
 }
 
 // static
 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
   // disable the error auto-detection here (since the audio mirroring
   // implementation will reliably report error and close events).  Note, of
   // course, that we're assuming CreateForStream() has been called for the audio
   // mirroring use case only.
   if (!controller->message_loop_->PostTask(
           FROM_HERE,
           base::Bind(&AudioInputController::DoCreateForStream, controller,
@@ skipping 89 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 (key_press_monitor_)
+    key_press_monitor_->AddKeyPressListener(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();
 
   if (state_ != kClosed) {
     DoStopCloseAndClearStream(NULL);
     SetDataIsActive(false);
 
     if (LowLatencyMode()) {
       sync_writer_->Close();
     }
 
     state_ = kClosed;
   }
+  if (key_press_monitor_)
+    key_press_monitor_->RemoveKeyPressListener(this);
 }
 
 void AudioInputController::DoReportError() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   handler_->OnError(this);
 }
 
 void AudioInputController::DoSetVolume(double volume) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_GE(volume, 0);
@@ skipping 48 matching lines @@
   // |kTimerResetIntervalSeconds|.
   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;
   {
     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
   // 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);
+    sync_writer_->Write(data, size, volume, key_pressed);
     sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
     return;
   }
 
   handler_->OnData(this, data, size);
 }
 
 void AudioInputController::OnClose(AudioInputStream* stream) {
   DVLOG(1) << "AudioInputController::OnClose()";
   // TODO(satish): Sometimes the device driver closes the input stream without
   // us asking for it (may be if the device was unplugged?). Check how to handle
   // such cases here.
 }
 
 void AudioInputController::OnError(AudioInputStream* stream) {
   // Handle error on the audio-manager thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &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.
   if (stream_ != NULL) {
     stream_->Stop();
     stream_->Close();
     stream_ = NULL;
   }
 
   // Should be last in the method, do not touch "this" from here on.
   if (done != NULL)
     done->Signal();
 }
 
 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