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,
+                                           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) {
+      max_volume_(0.0),
+      user_input_monitor_(user_input_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,
+    UserInputMonitor* user_input_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, user_input_monitor);
+  }
+  scoped_refptr<AudioInputController> controller(
+      new AudioInputController(event_handler, NULL, user_input_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,
+    UserInputMonitor* user_input_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, user_input_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,
+    UserInputMonitor* user_input_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, user_input_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 (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();
 
   if (state_ != kClosed) {
     DoStopCloseAndClearStream(NULL);
     SetDataIsActive(false);
 
     if (LowLatencyMode()) {
       sync_writer_->Close();
     }
 
     state_ = kClosed;
   }
+  if (user_input_monitor_)

[DaleCurtis, 2013/08/12 20:24:11]

Should this be in the (state_ != kClosed) block? You might get a double removal
this way.

+    user_input_monitor_->RemoveKeyStrokeListener(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_);
   }
 
   // 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() {
+  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