Revert 217768 "Adding key press detection in the browser process."

> Adding key press detection in the browser process.
> It works like this on the browser side: 
> A new object KeyPressMonitor is created on BrowserMainLoop and passed to AudioInputRendererHost to pass to AudioInputController.
> AudioInputController::DoRecord calls KeyPressMonitor::AddKeyPressListener --> KeyPressMonitor listens to system key events through UserInputMonitor(only implemented on Linux) --> AudioInputController::OnKeyPressed is called and sets key_pressed_ --> When AudioInputController::OnData called, it writes key_pressed_ to shared memory along with the audio data buffer.
> On the renderer side a new param "key_pressed" is added through the code path of passing the flag to the webrtc voice engine.
> This CL includes all these changes except the implementation of UserInputMonitor for Windows and Mac. The impl of UserInputMonitor is mostly copied from remoting/host/local_input_monitor_linux.cc
> 
> 
> BUG=
> 
> Review URL: https://chromiumcodereview.appspot.com/21183002

TBR=jiayl@chromium.org

Review URL: https://codereview.chromium.org/22871007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@217774 0039d316-1c4b-4281-b951-d872f2087c98

37 files changed, 159 insertions, 931 deletions

diff --git a/content/browser/browser_main_loop.cc b/content/browser/browser_main_loop.cc
index 4194aa8..c51b5c5 100644
--- a/content/browser/browser_main_loop.cc
+++ b/content/browser/browser_main_loop.cc
@@ -52,7 +52,6 @@
 #include "crypto/nss_util.h"
 #include "media/audio/audio_manager.h"
 #include "media/base/media.h"
-#include "media/base/user_input_monitor.h"
 #include "media/midi/midi_manager.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/client_socket_factory.h"
@@ -873,14 +872,6 @@ int BrowserMainLoop::BrowserThreadsStarted() {
         audio_manager_.get(), media_stream_manager_.get()));
   }
 
-  {
-    TRACE_EVENT0(
-        "startup",
-        "BrowserMainLoop::BrowserThreadsStarted::InitUserInputMonitor");
-    user_input_monitor_ = media::UserInputMonitor::Create(
-        io_thread_->message_loop_proxy(), main_thread_->message_loop_proxy());
-  }
-
   // Alert the clipboard class to which threads are allowed to access the
   // clipboard:
   std::vector<base::PlatformThreadId> allowed_clipboard_threads;
diff --git a/content/browser/browser_main_loop.h b/content/browser/browser_main_loop.h
index 83dbafd..7b2879f 100644
--- a/content/browser/browser_main_loop.h
+++ b/content/browser/browser_main_loop.h
@@ -26,7 +26,6 @@ class TraceMemoryController;
 namespace media {
 class AudioManager;
 class MIDIManager;
-class UserInputMonitor;
 }  // namespace media
 
 namespace net {
@@ -87,9 +86,6 @@ class CONTENT_EXPORT BrowserMainLoop {
   MediaStreamManager* media_stream_manager() const {
     return media_stream_manager_.get();
   }
-  media::UserInputMonitor* user_input_monitor() const {
-    return user_input_monitor_.get();
-  }
   media::MIDIManager* midi_manager() const { return midi_manager_.get(); }
   base::Thread* indexed_db_thread() const { return indexed_db_thread_.get(); }
 
@@ -126,8 +122,6 @@ class CONTENT_EXPORT BrowserMainLoop {
   scoped_ptr<base::PowerMonitor> power_monitor_;
   scoped_ptr<base::HighResolutionTimerManager> hi_res_timer_manager_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
-  // user_input_monitor_ has to outlive audio_manager_, so declared first.
-  scoped_ptr<media::UserInputMonitor> user_input_monitor_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<media::MIDIManager> midi_manager_;
   scoped_ptr<AudioMirroringManager> audio_mirroring_manager_;
diff --git a/content/browser/renderer_host/media/audio_input_renderer_host.cc b/content/browser/renderer_host/media/audio_input_renderer_host.cc
index 1c02109..4a2f731 100644
--- a/content/browser/renderer_host/media/audio_input_renderer_host.cc
+++ b/content/browser/renderer_host/media/audio_input_renderer_host.cc
@@ -51,12 +51,11 @@ AudioInputRendererHost::AudioEntry::~AudioEntry() {}
 AudioInputRendererHost::AudioInputRendererHost(
     media::AudioManager* audio_manager,
     MediaStreamManager* media_stream_manager,
-    AudioMirroringManager* audio_mirroring_manager,
-    media::UserInputMonitor* user_input_monitor)
+    AudioMirroringManager* audio_mirroring_manager)
     : audio_manager_(audio_manager),
       media_stream_manager_(media_stream_manager),
-      audio_mirroring_manager_(audio_mirroring_manager),
-      user_input_monitor_(user_input_monitor) {}
+      audio_mirroring_manager_(audio_mirroring_manager) {
+}
 
 AudioInputRendererHost::~AudioInputRendererHost() {
   DCHECK(audio_entries_.empty());
@@ -273,23 +272,20 @@ void AudioInputRendererHost::OnCreateStream(
     entry->controller = media::AudioInputController::CreateForStream(
         audio_manager_->GetMessageLoop(),
         this,
-        WebContentsAudioInputStream::Create(device_id,
-                                            audio_params,
-                                            audio_manager_->GetWorkerLoop(),
-                                            audio_mirroring_manager_),
-        entry->writer.get(),
-        user_input_monitor_);
+        WebContentsAudioInputStream::Create(
+            device_id, audio_params, audio_manager_->GetWorkerLoop(),
+            audio_mirroring_manager_),
+        entry->writer.get());
   } else {
     // TODO(henrika): replace CreateLowLatency() with Create() as soon
     // as satish has ensured that Speech Input also uses the default low-
     // latency path. See crbug.com/112472 for details.
-    entry->controller =
-        media::AudioInputController::CreateLowLatency(audio_manager_,
-                                                      this,
-                                                      audio_params,
-                                                      device_id,
-                                                      entry->writer.get(),
-                                                      user_input_monitor_);
+    entry->controller = media::AudioInputController::CreateLowLatency(
+        audio_manager_,
+        this,
+        audio_params,
+        device_id,
+        entry->writer.get());
   }
 
   if (!entry->controller.get()) {
diff --git a/content/browser/renderer_host/media/audio_input_renderer_host.h b/content/browser/renderer_host/media/audio_input_renderer_host.h
index 5df1fc6..d16ebfa 100644
--- a/content/browser/renderer_host/media/audio_input_renderer_host.h
+++ b/content/browser/renderer_host/media/audio_input_renderer_host.h
@@ -44,7 +44,6 @@
 namespace media {
 class AudioManager;
 class AudioParameters;
-class UserInputMonitor;
 }
 
 namespace content {
@@ -56,11 +55,10 @@ class CONTENT_EXPORT AudioInputRendererHost
       public media::AudioInputController::EventHandler {
  public:
   // Called from UI thread from the owner of this object.
-  // |user_input_monitor| is used for typing detection and can be NULL.
-  AudioInputRendererHost(media::AudioManager* audio_manager,
-                         MediaStreamManager* media_stream_manager,
-                         AudioMirroringManager* audio_mirroring_manager,
-                         media::UserInputMonitor* user_input_monitor);
+  AudioInputRendererHost(
+      media::AudioManager* audio_manager,
+      MediaStreamManager* media_stream_manager,
+      AudioMirroringManager* audio_mirroring_manager);
 
   // BrowserMessageFilter implementation.
   virtual void OnChannelClosing() OVERRIDE;
@@ -156,9 +154,6 @@ class CONTENT_EXPORT AudioInputRendererHost
   // A map of stream IDs to audio sources.
   AudioEntryMap audio_entries_;
 
-  // Raw pointer of the UserInputMonitor.
-  media::UserInputMonitor* user_input_monitor_;
-
   DISALLOW_COPY_AND_ASSIGN(AudioInputRendererHost);
 };
 
diff --git a/content/browser/renderer_host/media/audio_input_sync_writer.cc b/content/browser/renderer_host/media/audio_input_sync_writer.cc
index 369e0a8..572abf3 100644
--- a/content/browser/renderer_host/media/audio_input_sync_writer.cc
+++ b/content/browser/renderer_host/media/audio_input_sync_writer.cc
@@ -29,17 +29,14 @@ void AudioInputSyncWriter::UpdateRecordedBytes(uint32 bytes) {
   socket_->Send(&bytes, sizeof(bytes));
 }
 
-uint32 AudioInputSyncWriter::Write(const void* data,
-                                   uint32 size,
-                                   double volume,
-                                   bool key_pressed) {
+uint32 AudioInputSyncWriter::Write(
+    const void* data, uint32 size, double volume) {
   uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
   ptr += current_segment_id_ * shared_memory_segment_size_;
   media::AudioInputBuffer* buffer =
       reinterpret_cast<media::AudioInputBuffer*>(ptr);
   buffer->params.volume = volume;
   buffer->params.size = size;
-  buffer->params.key_pressed = key_pressed;
   memcpy(buffer->audio, data, size);
 
   if (++current_segment_id_ >= shared_memory_segment_count_)
diff --git a/content/browser/renderer_host/media/audio_input_sync_writer.h b/content/browser/renderer_host/media/audio_input_sync_writer.h
index d16911f..4cfe9e3 100644
--- a/content/browser/renderer_host/media/audio_input_sync_writer.h
+++ b/content/browser/renderer_host/media/audio_input_sync_writer.h
@@ -28,10 +28,7 @@ class AudioInputSyncWriter : public media::AudioInputController::SyncWriter {
 
   // media::AudioOutputController::SyncWriter implementation.
   virtual void UpdateRecordedBytes(uint32 bytes) OVERRIDE;
-  virtual uint32 Write(const void* data,
-                       uint32 size,
-                       double volume,
-                       bool key_pressed) OVERRIDE;
+  virtual uint32 Write(const void* data, uint32 size, double volume) OVERRIDE;
   virtual void Close() OVERRIDE;
 
   bool Init();
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index 3b22bc8..e31aff2 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -617,14 +617,11 @@ void RenderProcessHostImpl::CreateMessageFilters() {
   channel_->AddFilter(new AudioInputRendererHost(
       audio_manager,
       media_stream_manager,
-      BrowserMainLoop::GetInstance()->audio_mirroring_manager(),
-      BrowserMainLoop::GetInstance()->user_input_monitor()));
+      BrowserMainLoop::GetInstance()->audio_mirroring_manager()));
   channel_->AddFilter(new AudioRendererHost(
-      GetID(),
-      audio_manager,
+      GetID(), audio_manager,
       BrowserMainLoop::GetInstance()->audio_mirroring_manager(),
-      media_internals,
-      media_stream_manager));
+      media_internals, media_stream_manager));
   channel_->AddFilter(
       new MIDIHost(BrowserMainLoop::GetInstance()->midi_manager()));
   channel_->AddFilter(new MIDIDispatcherHost(GetID(), browser_context));
diff --git a/content/browser/speech/speech_recognizer_impl.cc b/content/browser/speech/speech_recognizer_impl.cc
index 2dae430..2081b2f 100644
--- a/content/browser/speech/speech_recognizer_impl.cc
+++ b/content/browser/speech/speech_recognizer_impl.cc
@@ -564,7 +564,7 @@ SpeechRecognizerImpl::StartRecording(const FSMEventArgs&) {
       new OnDataConverter(input_parameters, output_parameters));
 
   audio_controller_ = AudioInputController::Create(
-      audio_manager, this, input_parameters, device_id_, NULL);
+      audio_manager, this, input_parameters, device_id_);
 
   if (!audio_controller_.get()) {
     return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO));
diff --git a/content/renderer/media/webaudio_capturer_source.cc b/content/renderer/media/webaudio_capturer_source.cc
index 35cd99c..0ab8dc3 100644
--- a/content/renderer/media/webaudio_capturer_source.cc
+++ b/content/renderer/media/webaudio_capturer_source.cc
@@ -96,7 +96,7 @@ void WebAudioCapturerSource::consumeAudio(
   int capture_frames = params_.frames_per_buffer();
   while (fifo_->frames() >= capture_frames) {
     fifo_->Consume(capture_bus_.get(), 0, capture_frames);
-    callback_->Capture(capture_bus_.get(), 0, 1.0, false);
+    callback_->Capture(capture_bus_.get(), 0, 1.0);
   }
 }
 
diff --git a/content/renderer/media/webrtc_audio_capturer.cc b/content/renderer/media/webrtc_audio_capturer.cc
index 26b0fd7..238b2a2 100644
--- a/content/renderer/media/webrtc_audio_capturer.cc
+++ b/content/renderer/media/webrtc_audio_capturer.cc
@@ -102,16 +102,14 @@ class WebRtcAudioCapturer::TrackOwner
                    int number_of_channels,
                    int number_of_frames,
                    int audio_delay_milliseconds,
-                   int volume,
-                   bool key_pressed) {
+                   int volume) {
     base::AutoLock lock(lock_);
     if (delegate_) {
       delegate_->CaptureData(audio_data,
                              number_of_channels,
                              number_of_frames,
                              audio_delay_milliseconds,
-                             volume,
-                             key_pressed);
+                             volume);
     }
   }
 
@@ -426,11 +424,10 @@ void WebRtcAudioCapturer::SetAutomaticGainControl(bool enable) {
 
 void WebRtcAudioCapturer::Capture(media::AudioBus* audio_source,
                                   int audio_delay_milliseconds,
-                                  double volume,
-                                  bool key_pressed) {
-// This callback is driven by AudioInputDevice::AudioThreadCallback if
-// |source_| is AudioInputDevice, otherwise it is driven by client's
-// CaptureCallback.
+                                  double volume) {
+  // This callback is driven by AudioInputDevice::AudioThreadCallback if
+  // |source_| is AudioInputDevice, otherwise it is driven by client's
+  // CaptureCallback.
 #if defined(OS_WIN) || defined(OS_MACOSX)
   DCHECK_LE(volume, 1.0);
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
@@ -474,11 +471,8 @@ void WebRtcAudioCapturer::Capture(media::AudioBus* audio_source,
        it != tracks.end();
        ++it) {
     (*it)->CaptureData(buffer_ref_while_calling->buffer(),
-                       audio_source->channels(),
-                       audio_source->frames(),
-                       audio_delay_milliseconds,
-                       volume,
-                       key_pressed);
+                       audio_source->channels(), audio_source->frames(),
+                       audio_delay_milliseconds, volume_);
   }
 }
 
diff --git a/content/renderer/media/webrtc_audio_capturer.h b/content/renderer/media/webrtc_audio_capturer.h
index caa88d03..e85ea04 100644
--- a/content/renderer/media/webrtc_audio_capturer.h
+++ b/content/renderer/media/webrtc_audio_capturer.h
@@ -108,8 +108,7 @@ class CONTENT_EXPORT WebRtcAudioCapturer
   // Called on the AudioInputDevice audio thread.
   virtual void Capture(media::AudioBus* audio_source,
                        int audio_delay_milliseconds,
-                       double volume,
-                       bool key_pressed) OVERRIDE;
+                       double volume) OVERRIDE;
   virtual void OnCaptureError() OVERRIDE;
 
   // Reconfigures the capturer with a new buffer size and capture parameters.
diff --git a/content/renderer/media/webrtc_audio_capturer_sink_owner.cc b/content/renderer/media/webrtc_audio_capturer_sink_owner.cc
index 59de510..cb6a813 100644
--- a/content/renderer/media/webrtc_audio_capturer_sink_owner.cc
+++ b/content/renderer/media/webrtc_audio_capturer_sink_owner.cc
@@ -18,19 +18,13 @@ int WebRtcAudioCapturerSinkOwner::CaptureData(const std::vector<int>& channels,
                                               int number_of_frames,
                                               int audio_delay_milliseconds,
                                               int current_volume,
-                                              bool need_audio_processing,
-                                              bool key_pressed) {
+                                              bool need_audio_processing) {
   base::AutoLock lock(lock_);
   if (delegate_) {
-    delegate_->CaptureData(channels,
-                           audio_data,
-                           sample_rate,
-                           number_of_channels,
-                           number_of_frames,
-                           audio_delay_milliseconds,
-                           current_volume,
-                           need_audio_processing,
-                           key_pressed);
+    return delegate_->CaptureData(channels, audio_data, sample_rate,
+                                  number_of_channels, number_of_frames,
+                                  audio_delay_milliseconds, current_volume,
+                                  need_audio_processing);
   }
 
   return 0;
diff --git a/content/renderer/media/webrtc_audio_capturer_sink_owner.h b/content/renderer/media/webrtc_audio_capturer_sink_owner.h
index f338209..a3641b8 100644
--- a/content/renderer/media/webrtc_audio_capturer_sink_owner.h
+++ b/content/renderer/media/webrtc_audio_capturer_sink_owner.h
@@ -31,8 +31,7 @@ class WebRtcAudioCapturerSinkOwner
                           int number_of_frames,
                           int audio_delay_milliseconds,
                           int current_volume,
-                          bool need_audio_processing,
-                          bool key_pressed) OVERRIDE;
+                          bool need_audio_processing) OVERRIDE;
 
   virtual void SetCaptureFormat(const media::AudioParameters& params) OVERRIDE;
 
diff --git a/content/renderer/media/webrtc_audio_device_impl.cc b/content/renderer/media/webrtc_audio_device_impl.cc
index 93e024b..c40e0a2 100644
--- a/content/renderer/media/webrtc_audio_device_impl.cc
+++ b/content/renderer/media/webrtc_audio_device_impl.cc
@@ -59,8 +59,7 @@ int WebRtcAudioDeviceImpl::CaptureData(const std::vector<int>& channels,
                                        int number_of_frames,
                                        int audio_delay_milliseconds,
                                        int current_volume,
-                                       bool need_audio_processing,
-                                       bool key_pressed) {
+                                       bool need_audio_processing) {
   int total_delay_ms = 0;
   {
     base::AutoLock auto_lock(lock_);
@@ -76,9 +75,11 @@ int WebRtcAudioDeviceImpl::CaptureData(const std::vector<int>& channels,
   // Write audio samples in blocks of 10 milliseconds to the registered
   // webrtc::AudioTransport sink. Keep writing until our internal byte
   // buffer is empty.
+  // TODO(niklase): Wire up the key press detection.
   const int16* audio_buffer = audio_data;
   const int samples_per_10_msec = (sample_rate / 100);
   int accumulated_audio_samples = 0;
+  bool key_pressed = false;
   uint32_t new_volume = 0;
   while (accumulated_audio_samples < number_of_frames) {
     // Deliver 10ms of recorded 16-bit linear PCM audio.
diff --git a/content/renderer/media/webrtc_audio_device_impl.h b/content/renderer/media/webrtc_audio_device_impl.h
index b644178..ef3cb7c 100644
--- a/content/renderer/media/webrtc_audio_device_impl.h
+++ b/content/renderer/media/webrtc_audio_device_impl.h
@@ -223,8 +223,7 @@ class WebRtcAudioCapturerSink {
                           int number_of_frames,
                           int audio_delay_milliseconds,
                           int current_volume,
-                          bool need_audio_processing,
-                          bool key_pressed) = 0;
+                          bool need_audio_processing) = 0;
 
   // Set the format for the capture audio parameters.
   virtual void SetCaptureFormat(const media::AudioParameters& params) = 0;
@@ -340,8 +339,7 @@ class CONTENT_EXPORT WebRtcAudioDeviceImpl
                           int number_of_frames,
                           int audio_delay_milliseconds,
                           int current_volume,
-                          bool need_audio_processing,
-                          bool key_pressed) OVERRIDE;
+                          bool need_audio_processing) OVERRIDE;
 
   // Called on the main render thread.
   virtual void SetCaptureFormat(const media::AudioParameters& params) OVERRIDE;
diff --git a/content/renderer/media/webrtc_audio_device_unittest.cc b/content/renderer/media/webrtc_audio_device_unittest.cc
index a08ea93..6746ab6 100644
--- a/content/renderer/media/webrtc_audio_device_unittest.cc
+++ b/content/renderer/media/webrtc_audio_device_unittest.cc
@@ -221,8 +221,7 @@ class MockWebRtcAudioCapturerSink : public WebRtcAudioCapturerSink {
                           int number_of_frames,
                           int audio_delay_milliseconds,
                           int current_volume,
-                          bool need_audio_processing,
-                          bool key_pressed) OVERRIDE {
+                          bool need_audio_processing) OVERRIDE {
     // Signal that a callback has been received.
     event_->Signal();
     return 0;
@@ -382,13 +381,8 @@ int RunWebRtcLoopbackTimeTest(media::AudioManager* manager,
     capturer_sink->CaptureData(
         voe_channels,
         reinterpret_cast<int16*>(capture_data.get() + input_packet_size * j),
-        params.sample_rate(),
-        params.channels(),
-        params.frames_per_buffer(),
-        kHardwareLatencyInMs,
-        1.0,
-        enable_apm,
-        false);
+        params.sample_rate(), params.channels(), params.frames_per_buffer(),
+        kHardwareLatencyInMs, 1.0, enable_apm);
 
     // Receiving data from WebRtc.
     renderer_source->RenderData(
diff --git a/content/renderer/media/webrtc_local_audio_renderer.cc b/content/renderer/media/webrtc_local_audio_renderer.cc
index af65d8d..11c125f 100644
--- a/content/renderer/media/webrtc_local_audio_renderer.cc
+++ b/content/renderer/media/webrtc_local_audio_renderer.cc
@@ -52,14 +52,13 @@ void WebRtcLocalAudioRenderer::OnRenderError() {
 
 // content::WebRtcAudioCapturerSink implementation
 int WebRtcLocalAudioRenderer::CaptureData(const std::vector<int>& channels,
-                                          const int16* audio_data,
-                                          int sample_rate,
-                                          int number_of_channels,
-                                          int number_of_frames,
-                                          int audio_delay_milliseconds,
-                                          int current_volume,
-                                          bool need_audio_processing,
-                                          bool key_pressed) {
+                                           const int16* audio_data,
+                                           int sample_rate,
+                                           int number_of_channels,
+                                           int number_of_frames,
+                                           int audio_delay_milliseconds,
+                                           int current_volume,
+                                           bool need_audio_processing) {
   TRACE_EVENT0("audio", "WebRtcLocalAudioRenderer::CaptureData");
   base::AutoLock auto_lock(thread_lock_);
 
diff --git a/content/renderer/media/webrtc_local_audio_renderer.h b/content/renderer/media/webrtc_local_audio_renderer.h
index f58aee3..2930393 100644
--- a/content/renderer/media/webrtc_local_audio_renderer.h
+++ b/content/renderer/media/webrtc_local_audio_renderer.h
@@ -78,8 +78,7 @@ class CONTENT_EXPORT WebRtcLocalAudioRenderer
                           int number_of_frames,
                           int audio_delay_milliseconds,
                           int current_volume,
-                          bool need_audio_processing,
-                          bool key_pressed) OVERRIDE;
+                          bool need_audio_processing) OVERRIDE;
 
   // Can be called on different user thread.
   virtual void SetCaptureFormat(const media::AudioParameters& params) OVERRIDE;
diff --git a/content/renderer/media/webrtc_local_audio_track.cc b/content/renderer/media/webrtc_local_audio_track.cc
index cae6bfe..de86a3c 100644
--- a/content/renderer/media/webrtc_local_audio_track.cc
+++ b/content/renderer/media/webrtc_local_audio_track.cc
@@ -47,8 +47,7 @@ void WebRtcLocalAudioTrack::CaptureData(const int16* audio_data,
                                         int number_of_channels,
                                         int number_of_frames,
                                         int audio_delay_milliseconds,
-                                        int volume,
-                                        bool key_pressed) {
+                                        int volume) {
   scoped_refptr<WebRtcAudioCapturer> capturer;
   std::vector<int> voe_channels;
   int sample_rate = 0;
@@ -69,15 +68,10 @@ void WebRtcLocalAudioTrack::CaptureData(const int16* audio_data,
 
   // Feed the data to the sinks.
   for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it) {
-    int new_volume = (*it)->CaptureData(voe_channels,
-                                        audio_data,
-                                        sample_rate,
-                                        number_of_channels,
-                                        number_of_frames,
-                                        audio_delay_milliseconds,
-                                        volume,
-                                        need_audio_processing_,
-                                        key_pressed);
+    int new_volume = (*it)->CaptureData(voe_channels, audio_data, sample_rate,
+                                        number_of_channels, number_of_frames,
+                                        audio_delay_milliseconds, volume,
+                                        need_audio_processing_);
     if (new_volume != 0 && capturer.get())
       capturer->SetVolume(new_volume);
   }
diff --git a/content/renderer/media/webrtc_local_audio_track.h b/content/renderer/media/webrtc_local_audio_track.h
index 0f4e712..7cb8c85 100644
--- a/content/renderer/media/webrtc_local_audio_track.h
+++ b/content/renderer/media/webrtc_local_audio_track.h
@@ -61,8 +61,7 @@ class CONTENT_EXPORT WebRtcLocalAudioTrack
                    int number_of_channels,
                    int number_of_frames,
                    int audio_delay_milliseconds,
-                   int volume,
-                   bool key_pressed);
+                   int volume);
 
   // Method called by the capturer to set the audio parameters used by source
   // of the capture data..
diff --git a/content/renderer/media/webrtc_local_audio_track_unittest.cc b/content/renderer/media/webrtc_local_audio_track_unittest.cc
index b75ca79..4720e45 100644
--- a/content/renderer/media/webrtc_local_audio_track_unittest.cc
+++ b/content/renderer/media/webrtc_local_audio_track_unittest.cc
@@ -50,7 +50,7 @@ class FakeAudioThread : public base::PlatformThread::Delegate {
           static_cast<media::AudioCapturerSource::CaptureCallback*>(
               capturer_.get());
       audio_bus_->Zero();
-      callback->Capture(audio_bus_.get(), 0, 0, false);
+      callback->Capture(audio_bus_.get(), 0, 0);
 
       // Sleep 1ms to yield the resource for the main thread.
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
@@ -103,27 +103,20 @@ class MockWebRtcAudioCapturerSink : public WebRtcAudioCapturerSink {
                   int number_of_frames,
                   int audio_delay_milliseconds,
                   int current_volume,
-                  bool need_audio_processing,
-                  bool key_pressed) OVERRIDE {
-    CaptureData(channels.size(),
-                sample_rate,
-                number_of_channels,
-                number_of_frames,
-                audio_delay_milliseconds,
-                current_volume,
-                need_audio_processing,
-                key_pressed);
+                  bool need_audio_processing) OVERRIDE {
+    CaptureData(channels.size(), sample_rate, number_of_channels,
+                number_of_frames, audio_delay_milliseconds, current_volume,
+                need_audio_processing);
     return 0;
   }
-  MOCK_METHOD8(CaptureData,
-               void(int number_of_network_channels,
-                    int sample_rate,
-                    int number_of_channels,
-                    int number_of_frames,
-                    int audio_delay_milliseconds,
-                    int current_volume,
-                    bool need_audio_processing,
-                    bool key_pressed));
+  MOCK_METHOD7(CaptureData, void(int number_of_network_channels,
+                                 int sample_rate,
+                                 int number_of_channels,
+                                 int number_of_frames,
+                                 int audio_delay_milliseconds,
+                                 int current_volume,
+                                 bool need_audio_processing));
+
   MOCK_METHOD1(SetCaptureFormat, void(const media::AudioParameters& params));
 };
 
@@ -180,16 +173,10 @@ TEST_F(WebRtcLocalAudioTrackTest, ConnectAndDisconnectOneSink) {
   const media::AudioParameters params = capturer_->audio_parameters();
   base::WaitableEvent event(false, false);
   EXPECT_CALL(*sink, SetCaptureFormat(_)).WillOnce(Return());
-  EXPECT_CALL(*sink,
-              CaptureData(kNumberOfNetworkChannels,
-                          params.sample_rate(),
-                          params.channels(),
-                          params.frames_per_buffer(),
-                          0,
-                          0,
-                          false,
-                          false)).Times(AtLeast(1))
-      .WillRepeatedly(SignalEvent(&event));
+  EXPECT_CALL(*sink, CaptureData(
+      kNumberOfNetworkChannels, params.sample_rate(), params.channels(),
+      params.frames_per_buffer(), 0, 0, false))
+      .Times(AtLeast(1)).WillRepeatedly(SignalEvent(&event));
   track->AddSink(sink.get());
 
   EXPECT_TRUE(event.TimedWait(TestTimeouts::tiny_timeout()));
@@ -220,29 +207,18 @@ TEST_F(WebRtcLocalAudioTrackTest, DISABLED_DisableEnableAudioTrack) {
   const media::AudioParameters params = capturer_->audio_parameters();
   base::WaitableEvent event(false, false);
   EXPECT_CALL(*sink, SetCaptureFormat(_)).WillOnce(Return());
-  EXPECT_CALL(*sink,
-              CaptureData(1,
-                          params.sample_rate(),
-                          params.channels(),
-                          params.frames_per_buffer(),
-                          0,
-                          0,
-                          false,
-                          false)).Times(0);
+  EXPECT_CALL(*sink, CaptureData(
+      1, params.sample_rate(), params.channels(),
+      params.frames_per_buffer(), 0, 0, false))
+      .Times(0);
   track->AddSink(sink.get());
   EXPECT_FALSE(event.TimedWait(TestTimeouts::tiny_timeout()));
 
   event.Reset();
-  EXPECT_CALL(*sink,
-              CaptureData(1,
-                          params.sample_rate(),
-                          params.channels(),
-                          params.frames_per_buffer(),
-                          0,
-                          0,
-                          false,
-                          false)).Times(AtLeast(1))
-      .WillRepeatedly(SignalEvent(&event));
+  EXPECT_CALL(*sink, CaptureData(
+      1, params.sample_rate(), params.channels(),
+      params.frames_per_buffer(), 0, 0, false))
+      .Times(AtLeast(1)).WillRepeatedly(SignalEvent(&event));
   EXPECT_TRUE(track->set_enabled(true));
   EXPECT_TRUE(event.TimedWait(TestTimeouts::tiny_timeout()));
   track->RemoveSink(sink.get());
@@ -267,16 +243,10 @@ TEST_F(WebRtcLocalAudioTrackTest, MultipleAudioTracks) {
   const media::AudioParameters params = capturer_->audio_parameters();
   base::WaitableEvent event_1(false, false);
   EXPECT_CALL(*sink_1, SetCaptureFormat(_)).WillOnce(Return());
-  EXPECT_CALL(*sink_1,
-              CaptureData(1,
-                          params.sample_rate(),
-                          params.channels(),
-                          params.frames_per_buffer(),
-                          0,
-                          0,
-                          false,
-                          false)).Times(AtLeast(1))
-      .WillRepeatedly(SignalEvent(&event_1));
+  EXPECT_CALL(*sink_1, CaptureData(
+      1, params.sample_rate(), params.channels(),
+      params.frames_per_buffer(), 0, 0, false))
+      .Times(AtLeast(1)).WillRepeatedly(SignalEvent(&event_1));
   track_1->AddSink(sink_1.get());
   EXPECT_TRUE(event_1.TimedWait(TestTimeouts::tiny_timeout()));
 
@@ -294,26 +264,14 @@ TEST_F(WebRtcLocalAudioTrackTest, MultipleAudioTracks) {
   scoped_ptr<MockWebRtcAudioCapturerSink> sink_2(
         new MockWebRtcAudioCapturerSink());
   EXPECT_CALL(*sink_2, SetCaptureFormat(_)).WillOnce(Return());
-  EXPECT_CALL(*sink_1,
-              CaptureData(1,
-                          params.sample_rate(),
-                          params.channels(),
-                          params.frames_per_buffer(),
-                          0,
-                          0,
-                          false,
-                          false)).Times(AtLeast(1))
-      .WillRepeatedly(SignalEvent(&event_1));
-  EXPECT_CALL(*sink_2,
-              CaptureData(1,
-                          params.sample_rate(),
-                          params.channels(),
-                          params.frames_per_buffer(),
-                          0,
-                          0,
-                          false,
-                          false)).Times(AtLeast(1))
-      .WillRepeatedly(SignalEvent(&event_2));
+  EXPECT_CALL(*sink_1, CaptureData(
+      1, params.sample_rate(), params.channels(),
+      params.frames_per_buffer(), 0, 0, false))
+      .Times(AtLeast(1)).WillRepeatedly(SignalEvent(&event_1));
+  EXPECT_CALL(*sink_2, CaptureData(
+      1, params.sample_rate(), params.channels(),
+      params.frames_per_buffer(), 0, 0, false))
+      .Times(AtLeast(1)).WillRepeatedly(SignalEvent(&event_2));
   track_2->AddSink(sink_2.get());
   EXPECT_TRUE(event_1.TimedWait(TestTimeouts::tiny_timeout()));
   EXPECT_TRUE(event_2.TimedWait(TestTimeouts::tiny_timeout()));
@@ -361,7 +319,7 @@ TEST_F(WebRtcLocalAudioTrackTest, StartAndStopAudioTracks) {
   scoped_ptr<MockWebRtcAudioCapturerSink> sink(
       new MockWebRtcAudioCapturerSink());
   event.Reset();
-  EXPECT_CALL(*sink, CaptureData(_, _, _, _, 0, 0, false, false))
+  EXPECT_CALL(*sink, CaptureData(_, _, _, _, 0, 0, false))
       .Times(AnyNumber()).WillRepeatedly(Return());
   EXPECT_CALL(*sink, SetCaptureFormat(_)).Times(1);
   track_1->AddSink(sink.get());
@@ -381,7 +339,7 @@ TEST_F(WebRtcLocalAudioTrackTest, StartAndStopAudioTracks) {
   track_1->Stop();
   track_1 = NULL;
 
-  EXPECT_CALL(*sink, CaptureData(_, _, _, _, 0, 0, false, false))
+  EXPECT_CALL(*sink, CaptureData(_, _, _, _, 0, 0, false))
       .Times(AnyNumber()).WillRepeatedly(Return());
   EXPECT_CALL(*sink, SetCaptureFormat(_)).Times(1);
   track_2->AddSink(sink.get());
@@ -438,10 +396,8 @@ TEST_F(WebRtcLocalAudioTrackTest, ConnectTracksToDifferentCapturers) {
   // Verify the data flow by connecting the |sink_1| to |track_1|.
   scoped_ptr<MockWebRtcAudioCapturerSink> sink_1(
       new MockWebRtcAudioCapturerSink());
-  EXPECT_CALL(
-      *sink_1.get(),
-      CaptureData(
-          kNumberOfNetworkChannelsForTrack1, 48000, 2, _, 0, 0, false, false))
+  EXPECT_CALL(*sink_1.get(), CaptureData(kNumberOfNetworkChannelsForTrack1,
+                                         48000, 2, _, 0, 0, false))
       .Times(AnyNumber()).WillRepeatedly(Return());
   EXPECT_CALL(*sink_1.get(), SetCaptureFormat(_)).Times(1);
   track_1->AddSink(sink_1.get());
@@ -477,10 +433,8 @@ TEST_F(WebRtcLocalAudioTrackTest, ConnectTracksToDifferentCapturers) {
   // Verify the data flow by connecting the |sink_2| to |track_2|.
   scoped_ptr<MockWebRtcAudioCapturerSink> sink_2(
       new MockWebRtcAudioCapturerSink());
-  EXPECT_CALL(
-      *sink_2,
-      CaptureData(
-          kNumberOfNetworkChannelsForTrack2, 44100, 1, _, 0, 0, false, false))
+  EXPECT_CALL(*sink_2, CaptureData(kNumberOfNetworkChannelsForTrack2,
+                                     44100, 1, _, 0, 0, false))
       .Times(AnyNumber()).WillRepeatedly(Return());
   EXPECT_CALL(*sink_2, SetCaptureFormat(_)).Times(1);
   track_2->AddSink(sink_2.get());
diff --git a/content/test/webrtc_audio_device_test.cc b/content/test/webrtc_audio_device_test.cc
index eb2f1c7..c258caf 100644
--- a/content/test/webrtc_audio_device_test.cc
+++ b/content/test/webrtc_audio_device_test.cc
@@ -252,11 +252,9 @@ void MAYBE_WebRTCAudioDeviceTest::CreateChannel(const char* name) {
       media_internals_.get(), media_stream_manager_.get());
   audio_render_host_->OnChannelConnected(base::GetCurrentProcId());
 
-  audio_input_renderer_host_ =
-      new AudioInputRendererHost(audio_manager_.get(),
-                                 media_stream_manager_.get(),
-                                 mirroring_manager_.get(),
-                                 NULL);
+  audio_input_renderer_host_ = new AudioInputRendererHost(
+      audio_manager_.get(), media_stream_manager_.get(),
+      mirroring_manager_.get());
   audio_input_renderer_host_->OnChannelConnected(base::GetCurrentProcId());
 
   channel_.reset(new IPC::Channel(name, IPC::Channel::MODE_SERVER, this));
diff --git a/media/DEPS b/media/DEPS
index 495c804..9c27aba 100644
--- a/media/DEPS
+++ b/media/DEPS
@@ -5,7 +5,6 @@ include_rules = [
   "+third_party/libvpx",
   "+third_party/opus",
   "+third_party/skia",
-  "+ui/base",
   "+ui/gfx",
   "+ui/gl",
 ]
diff --git a/media/audio/audio_input_controller.cc b/media/audio/audio_input_controller.cc
index f7747b9..31e137e 100644
--- a/media/audio/audio_input_controller.cc
+++ b/media/audio/audio_input_controller.cc
@@ -36,17 +36,14 @@ namespace media {
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
 AudioInputController::AudioInputController(EventHandler* handler,
-                                           SyncWriter* sync_writer,
-                                           UserInputMonitor* user_input_monitor)
+                                           SyncWriter* sync_writer)
     : 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),
-      key_pressed_(false) {
+      max_volume_(0.0) {
   DCHECK(creator_loop_.get());
 }
 
@@ -59,19 +56,17 @@ scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
-    const std::string& device_id,
-    UserInputMonitor* user_input_monitor) {
+    const std::string& device_id) {
   DCHECK(audio_manager);
 
   if (!params.IsValid() || (params.channels() > kMaxInputChannels))
     return 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));
+  if (factory_)
+    return factory_->Create(audio_manager, event_handler, params);
+
+  scoped_refptr<AudioInputController> controller(new AudioInputController(
+      event_handler, NULL));
 
   controller->message_loop_ = audio_manager->GetMessageLoop();
 
@@ -92,8 +87,7 @@ scoped_refptr<AudioInputController> AudioInputController::CreateLowLatency(
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& device_id,
-    SyncWriter* sync_writer,
-    UserInputMonitor* user_input_monitor) {
+    SyncWriter* sync_writer) {
   DCHECK(audio_manager);
   DCHECK(sync_writer);
 
@@ -102,8 +96,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, user_input_monitor));
+  scoped_refptr<AudioInputController> controller(new AudioInputController(
+      event_handler, sync_writer));
   controller->message_loop_ = audio_manager->GetMessageLoop();
 
   // Create and open a new audio input stream from the existing
@@ -122,15 +116,14 @@ scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     EventHandler* event_handler,
     AudioInputStream* stream,
-    SyncWriter* sync_writer,
-    UserInputMonitor* user_input_monitor) {
+    SyncWriter* sync_writer) {
   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, user_input_monitor));
+  scoped_refptr<AudioInputController> controller(new AudioInputController(
+      event_handler, sync_writer));
   controller->message_loop_ = message_loop;
 
   // TODO(miu): See TODO at top of file.  Until that's resolved, we need to
@@ -240,9 +233,6 @@ void AudioInputController::DoRecord() {
 
   stream_->Start(this);
   handler_->OnRecording(this);
-
-  if (user_input_monitor_)
-    user_input_monitor_->AddKeyStrokeListener(this);
 }
 
 void AudioInputController::DoClose() {
@@ -261,9 +251,6 @@ void AudioInputController::DoClose() {
     }
 
     state_ = kClosed;
-
-    if (user_input_monitor_)
-      user_input_monitor_->RemoveKeyStrokeListener(this);
   }
 }
 
@@ -333,13 +320,10 @@ 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_);
   }
 
   // Mark data as active to ensure that the periodic calls to
@@ -348,7 +332,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, key_pressed);
+    sync_writer_->Write(data, size, volume);
     sync_writer_->UpdateRecordedBytes(hardware_delay_bytes);
     return;
   }
@@ -369,13 +353,8 @@ void AudioInputController::OnError(AudioInputStream* stream) {
       &AudioInputController::DoReportError, this));
 }
 
-void AudioInputController::OnKeyStroke() {
-  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.
diff --git a/media/audio/audio_input_controller.h b/media/audio/audio_input_controller.h
index 6be4821..586d477 100644
--- a/media/audio/audio_input_controller.h
+++ b/media/audio/audio_input_controller.h
@@ -16,7 +16,6 @@
 #include "base/timer/timer.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
-#include "media/base/user_input_monitor.h"
 
 // An AudioInputController controls an AudioInputStream and records data
 // from this input stream. The two main methods are Record() and Close() and
@@ -75,8 +74,7 @@ namespace media {
 
 class MEDIA_EXPORT AudioInputController
     : public base::RefCountedThreadSafe<AudioInputController>,
-      public AudioInputStream::AudioInputCallback,
-      public UserInputMonitor::KeyStrokeListener {
+      public AudioInputStream::AudioInputCallback {
  public:
   // An event handler that receives events from the AudioInputController. The
   // following methods are all called on the audio thread.
@@ -104,10 +102,7 @@ class MEDIA_EXPORT AudioInputController
 
     // Write certain amount of data from |data|. This method returns
     // number of written bytes.
-    virtual uint32 Write(const void* data,
-                         uint32 size,
-                         double volume,
-                         bool key_pressed) = 0;
+    virtual uint32 Write(const void* data, uint32 size, double volume) = 0;
 
     // Close this synchronous writer.
     virtual void Close() = 0;
@@ -115,15 +110,11 @@ class MEDIA_EXPORT AudioInputController
 
   // AudioInputController::Create() can use the currently registered Factory
   // to create the AudioInputController. Factory is intended for testing only.
-  // |user_input_monitor| is used for typing detection and can be NULL.
   class Factory {
    public:
-    virtual AudioInputController* Create(
-        AudioManager* audio_manager,
-        EventHandler* event_handler,
-        AudioParameters params,
-        UserInputMonitor* user_input_monitor) = 0;
-
+    virtual AudioInputController* Create(AudioManager* audio_manager,
+                                         EventHandler* event_handler,
+                                         AudioParameters params) = 0;
    protected:
     virtual ~Factory() {}
   };
@@ -132,13 +123,11 @@ class MEDIA_EXPORT AudioInputController
   // The audio device will be created on the audio thread, and when that is
   // done, the event handler will receive an OnCreated() call from that same
   // thread. |device_id| is the unique ID of the audio device to be opened.
-  // |user_input_monitor| is used for typing detection and can be NULL.
   static scoped_refptr<AudioInputController> Create(
       AudioManager* audio_manager,
       EventHandler* event_handler,
       const AudioParameters& params,
-      const std::string& device_id,
-      UserInputMonitor* user_input_monitor);
+      const std::string& device_id);
 
   // Sets the factory used by the static method Create(). AudioInputController
   // does not take ownership of |factory|. A value of NULL results in an
@@ -149,28 +138,25 @@ class MEDIA_EXPORT AudioInputController
   // Factory method for creating an AudioInputController for low-latency mode.
   // The audio device will be created on the audio thread, and when that is
   // done, the event handler will receive an OnCreated() call from that same
-  // thread. |user_input_monitor| is used for typing detection and can be NULL.
+  // thread.
   static scoped_refptr<AudioInputController> CreateLowLatency(
       AudioManager* audio_manager,
       EventHandler* event_handler,
       const AudioParameters& params,
       const std::string& device_id,
       // External synchronous writer for audio controller.
-      SyncWriter* sync_writer,
-      UserInputMonitor* user_input_monitor);
+      SyncWriter* sync_writer);
 
   // Factory method for creating an AudioInputController for low-latency mode,
   // taking ownership of |stream|.  The stream will be opened on the audio
   // thread, and when that is done, the event handler will receive an
-  // OnCreated() call from that same thread. |user_input_monitor| is used for
-  // typing detection and can be NULL.
+  // OnCreated() call from that same thread.
   static scoped_refptr<AudioInputController> CreateForStream(
       const scoped_refptr<base::MessageLoopProxy>& message_loop,
       EventHandler* event_handler,
       AudioInputStream* stream,
       // External synchronous writer for audio controller.
-      SyncWriter* sync_writer,
-      UserInputMonitor* user_input_monitor);
+      SyncWriter* sync_writer);
 
   // Starts recording using the created audio input stream.
   // This method is called on the creator thread.
@@ -203,9 +189,6 @@ class MEDIA_EXPORT AudioInputController
 
   bool LowLatencyMode() const { return sync_writer_ != NULL; }
 
-  // Impl of KeyStrokeListener.
-  virtual void OnKeyStroke() OVERRIDE;
-
  protected:
   friend class base::RefCountedThreadSafe<AudioInputController>;
 
@@ -218,9 +201,7 @@ class MEDIA_EXPORT AudioInputController
     kError
   };
 
-  AudioInputController(EventHandler* handler,
-                       SyncWriter* sync_writer,
-                       UserInputMonitor* user_input_monitor);
+  AudioInputController(EventHandler* handler, SyncWriter* sync_writer);
   virtual ~AudioInputController();
 
   // Methods called on the audio thread (owned by the AudioManager).
@@ -285,11 +266,6 @@ class MEDIA_EXPORT AudioInputController
 
   double max_volume_;
 
-  UserInputMonitor* user_input_monitor_;
-
-  // True if any key has been pressed after the last OnData call.
-  bool key_pressed_;
-
   DISALLOW_COPY_AND_ASSIGN(AudioInputController);
 };
 
diff --git a/media/audio/audio_input_controller_unittest.cc b/media/audio/audio_input_controller_unittest.cc
index 6388cbf..b96ef3a 100644
--- a/media/audio/audio_input_controller_unittest.cc
+++ b/media/audio/audio_input_controller_unittest.cc
@@ -83,13 +83,9 @@ TEST_F(AudioInputControllerTest, CreateAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
   AudioParameters params(AudioParameters::AUDIO_FAKE, kChannelLayout,
                          kSampleRate, kBitsPerSample, kSamplesPerPacket);
-
   scoped_refptr<AudioInputController> controller =
-      AudioInputController::Create(audio_manager.get(),
-                                   &event_handler,
-                                   params,
-                                   AudioManagerBase::kDefaultDeviceId,
-                                   NULL);
+      AudioInputController::Create(audio_manager.get(), &event_handler, params,
+                                   AudioManagerBase::kDefaultDeviceId);
   ASSERT_TRUE(controller.get());
 
   // Wait for OnCreated() to fire.
@@ -124,11 +120,8 @@ TEST_F(AudioInputControllerTest, RecordAndClose) {
 
   // Creating the AudioInputController should render an OnCreated() call.
   scoped_refptr<AudioInputController> controller =
-      AudioInputController::Create(audio_manager.get(),
-                                   &event_handler,
-                                   params,
-                                   AudioManagerBase::kDefaultDeviceId,
-                                   NULL);
+      AudioInputController::Create(audio_manager.get(), &event_handler, params,
+                                   AudioManagerBase::kDefaultDeviceId);
   ASSERT_TRUE(controller.get());
 
   // Start recording and trigger one OnRecording() call.
@@ -174,11 +167,8 @@ TEST_F(AudioInputControllerTest, RecordAndError) {
 
   // Creating the AudioInputController should render an OnCreated() call.
   scoped_refptr<AudioInputController> controller =
-      AudioInputController::Create(audio_manager.get(),
-                                   &event_handler,
-                                   params,
-                                   AudioManagerBase::kDefaultDeviceId,
-                                   NULL);
+      AudioInputController::Create(audio_manager.get(), &event_handler, params,
+                                   AudioManagerBase::kDefaultDeviceId);
   ASSERT_TRUE(controller.get());
 
   // Start recording and trigger one OnRecording() call.
@@ -206,17 +196,11 @@ TEST_F(AudioInputControllerTest, SamplesPerPacketTooLarge) {
     .Times(Exactly(0));
 
   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
-  AudioParameters params(AudioParameters::AUDIO_FAKE,
-                         kChannelLayout,
-                         kSampleRate,
-                         kBitsPerSample,
-                         kSamplesPerPacket * 1000);
+  AudioParameters params(AudioParameters::AUDIO_FAKE, kChannelLayout,
+                         kSampleRate, kBitsPerSample, kSamplesPerPacket * 1000);
   scoped_refptr<AudioInputController> controller =
-      AudioInputController::Create(audio_manager.get(),
-                                   &event_handler,
-                                   params,
-                                   AudioManagerBase::kDefaultDeviceId,
-                                   NULL);
+      AudioInputController::Create(audio_manager.get(), &event_handler, params,
+                                   AudioManagerBase::kDefaultDeviceId);
   ASSERT_FALSE(controller.get());
 }
 
@@ -232,17 +216,11 @@ TEST_F(AudioInputControllerTest, CloseTwice) {
       .Times(Exactly(1));
 
   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
-  AudioParameters params(AudioParameters::AUDIO_FAKE,
-                         kChannelLayout,
-                         kSampleRate,
-                         kBitsPerSample,
-                         kSamplesPerPacket);
+  AudioParameters params(AudioParameters::AUDIO_FAKE, kChannelLayout,
+                         kSampleRate, kBitsPerSample, kSamplesPerPacket);
   scoped_refptr<AudioInputController> controller =
-      AudioInputController::Create(audio_manager.get(),
-                                   &event_handler,
-                                   params,
-                                   AudioManagerBase::kDefaultDeviceId,
-                                   NULL);
+      AudioInputController::Create(audio_manager.get(), &event_handler, params,
+                                   AudioManagerBase::kDefaultDeviceId);
   ASSERT_TRUE(controller.get());
 
   controller->Record();
diff --git a/media/audio/audio_input_device.cc b/media/audio/audio_input_device.cc
index 5477be6..87fd571 100644
--- a/media/audio/audio_input_device.cc
+++ b/media/audio/audio_input_device.cc
@@ -294,7 +294,6 @@ void AudioInputDevice::AudioThreadCallback::Process(int pending_data) {
   DCHECK_EQ(buffer->params.size,
             segment_length_ - sizeof(AudioInputBufferParameters));
   double volume = buffer->params.volume;
-  bool key_pressed = buffer->params.key_pressed;
 
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
   int16* memory = reinterpret_cast<int16*>(&buffer->audio[0]);
@@ -309,8 +308,8 @@ void AudioInputDevice::AudioThreadCallback::Process(int pending_data) {
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
-  capture_callback_->Capture(
-      audio_bus_.get(), audio_delay_milliseconds, volume, key_pressed);
+  capture_callback_->Capture(audio_bus_.get(),
+                             audio_delay_milliseconds, volume);
 }
 
 }  // namespace media
diff --git a/media/audio/audio_parameters.h b/media/audio/audio_parameters.h
index bc629a7..2817cd2 100644
--- a/media/audio/audio_parameters.h
+++ b/media/audio/audio_parameters.h
@@ -14,7 +14,6 @@ namespace media {
 struct MEDIA_EXPORT AudioInputBufferParameters {
   double volume;
   uint32 size;
-  bool key_pressed;
 };
 
 // Use a struct-in-struct approach to ensure that we can calculate the required
diff --git a/media/audio/test_audio_input_controller_factory.cc b/media/audio/test_audio_input_controller_factory.cc
index d146231..64bfb9f 100644
--- a/media/audio/test_audio_input_controller_factory.cc
+++ b/media/audio/test_audio_input_controller_factory.cc
@@ -12,9 +12,8 @@ TestAudioInputController::TestAudioInputController(
     AudioManager* audio_manager,
     const AudioParameters& audio_parameters,
     EventHandler* event_handler,
-    SyncWriter* sync_writer,
-    UserInputMonitor* user_input_monitor)
-    : AudioInputController(event_handler, sync_writer, user_input_monitor),
+    SyncWriter* sync_writer)
+    : AudioInputController(event_handler, sync_writer),
       audio_parameters_(audio_parameters),
       factory_(factory),
       event_handler_(event_handler) {
@@ -49,11 +48,10 @@ TestAudioInputControllerFactory::~TestAudioInputControllerFactory() {
 AudioInputController* TestAudioInputControllerFactory::Create(
     AudioManager* audio_manager,
     AudioInputController::EventHandler* event_handler,
-    AudioParameters params,
-    UserInputMonitor* user_input_monitor) {
+    AudioParameters params) {
   DCHECK(!controller_);  // Only one test instance managed at a time.
-  controller_ = new TestAudioInputController(
-      this, audio_manager, params, event_handler, NULL, user_input_monitor);
+  controller_ = new TestAudioInputController(this, audio_manager, params,
+      event_handler, NULL);
   return controller_;
 }
 
diff --git a/media/audio/test_audio_input_controller_factory.h b/media/audio/test_audio_input_controller_factory.h
index 4968c01..0a17947 100644
--- a/media/audio/test_audio_input_controller_factory.h
+++ b/media/audio/test_audio_input_controller_factory.h
@@ -10,7 +10,6 @@
 
 namespace media {
 
-class UserInputMonitor;
 class TestAudioInputControllerFactory;
 
 // TestAudioInputController and TestAudioInputControllerFactory are used for
@@ -57,8 +56,7 @@ class TestAudioInputController : public AudioInputController {
                            AudioManager* audio_manager,
                            const AudioParameters& audio_parameters,
                            EventHandler* event_handler,
-                           SyncWriter* sync_writer,
-                           UserInputMonitor* user_input_monitor);
+                           SyncWriter* sync_writer);
 
   // Returns the event handler installed on the AudioInputController.
   EventHandler* event_handler() const { return event_handler_; }
@@ -96,8 +94,7 @@ class TestAudioInputControllerFactory : public AudioInputController::Factory {
   virtual AudioInputController* Create(
       AudioManager* audio_manager,
       AudioInputController::EventHandler* event_handler,
-      AudioParameters params,
-      UserInputMonitor* user_input_monitor) OVERRIDE;
+      AudioParameters params) OVERRIDE;
 
   void SetDelegateForTests(TestAudioInputControllerDelegate* delegate);
 
diff --git a/media/base/audio_capturer_source.h b/media/base/audio_capturer_source.h
index b584f8a..deae5e2 100644
--- a/media/base/audio_capturer_source.h
+++ b/media/base/audio_capturer_source.h
@@ -26,8 +26,7 @@ class AudioCapturerSource
     // Callback to deliver the captured data from the OS.
     virtual void Capture(AudioBus* audio_source,
                          int audio_delay_milliseconds,
-                         double volume,
-                         bool key_pressed) = 0;
+                         double volume) = 0;
 
     // Signals an error has occurred.
     virtual void OnCaptureError() = 0;
diff --git a/media/base/user_input_monitor.cc b/media/base/user_input_monitor.cc
deleted file mode 100644
index 18b4c80..0000000
--- a/media/base/user_input_monitor.cc
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2013 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/base/user_input_monitor.h"
-
-#include "third_party/skia/include/core/SkPoint.h"
-
-namespace media {
-
-#ifdef DISABLE_USER_INPUT_MONITOR
-scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
-  return scoped_ptr<UserInputMonitor>();
-}
-#endif  // DISABLE_USER_INPUT_MONITOR
-
-UserInputMonitor::~UserInputMonitor() {
-  DCHECK(!monitoring_mouse_);
-  DCHECK(!monitoring_keyboard_);
-}
-
-void UserInputMonitor::AddMouseListener(MouseEventListener* listener) {
-  base::AutoLock auto_lock(lock_);
-  mouse_listeners_.AddObserver(listener);
-  if (!monitoring_mouse_) {
-    StartMouseMonitoring();
-    monitoring_mouse_ = true;
-    DVLOG(2) << "Started mouse monitoring.";
-  }
-}
-void UserInputMonitor::RemoveMouseListener(MouseEventListener* listener) {
-  base::AutoLock auto_lock(lock_);
-  mouse_listeners_.RemoveObserver(listener);
-  if (mouse_listeners_.size() == 0) {
-    StopMouseMonitoring();
-    monitoring_mouse_ = false;
-    DVLOG(2) << "Stopped mouse monitoring.";
-  }
-}
-void UserInputMonitor::AddKeyStrokeListener(KeyStrokeListener* listener) {
-  base::AutoLock auto_lock(lock_);
-  key_stroke_listeners_.AddObserver(listener);
-  if (!monitoring_keyboard_) {
-    StartKeyboardMonitoring();
-    monitoring_keyboard_ = true;
-    DVLOG(2) << "Started keyboard monitoring.";
-  }
-}
-void UserInputMonitor::RemoveKeyStrokeListener(KeyStrokeListener* listener) {
-  base::AutoLock auto_lock(lock_);
-  key_stroke_listeners_.RemoveObserver(listener);
-  if (key_stroke_listeners_.size() == 0) {
-    StopKeyboardMonitoring();
-    monitoring_keyboard_ = false;
-    DVLOG(2) << "Stopped keyboard monitoring.";
-  }
-}
-
-UserInputMonitor::UserInputMonitor()
-    : monitoring_mouse_(false), monitoring_keyboard_(false) {}
-
-void UserInputMonitor::OnMouseEvent(const SkIPoint& position) {
-  base::AutoLock auto_lock(lock_);
-  FOR_EACH_OBSERVER(
-      MouseEventListener, mouse_listeners_, OnMouseMoved(position));
-}
-
-void UserInputMonitor::OnKeyboardEvent(ui::EventType event,
-                                       ui::KeyboardCode key_code) {
-  base::AutoLock auto_lock(lock_);
-  // Updates the pressed keys and maybe notifies the key_stroke_listeners_.
-  if (event == ui::ET_KEY_PRESSED) {
-    if (pressed_keys_.find(key_code) != pressed_keys_.end())
-      return;
-    pressed_keys_.insert(key_code);
-    DVLOG(6) << "Key stroke detected.";
-    FOR_EACH_OBSERVER(KeyStrokeListener, key_stroke_listeners_, OnKeyStroke());
-  } else {
-    DCHECK_EQ(ui::ET_KEY_RELEASED, event);
-    DCHECK(pressed_keys_.find(key_code) != pressed_keys_.end());
-    pressed_keys_.erase(key_code);
-  }
-}
-
-}  // namespace media
diff --git a/media/base/user_input_monitor.h b/media/base/user_input_monitor.h
deleted file mode 100644
index 9eb82f3..0000000
--- a/media/base/user_input_monitor.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2013 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.
-
-#ifndef MEDIA_BASE_USER_INPUT_MONITOR_H_
-#define MEDIA_BASE_USER_INPUT_MONITOR_H_
-
-#include <set>
-
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "base/observer_list.h"
-#include "base/synchronization/lock.h"
-#include "media/base/media_export.h"
-#include "ui/base/events/event_constants.h"
-#include "ui/base/keycodes/keyboard_codes.h"
-
-struct SkIPoint;
-
-namespace base {
-class SingleThreadTaskRunner;
-}  // namespace base
-
-namespace media {
-
-// Monitors and notifies about mouse movements and keyboard events.
-// Thread safe. The thread on which the listenters are called is not guaranteed.
-// The callers should not perform expensive/blocking tasks in the callback since
-// it might be called on the browser UI/IO threads.
-class MEDIA_EXPORT UserInputMonitor {
- public:
-  // The interface to receive mouse movement events.
-  class MEDIA_EXPORT MouseEventListener {
-   public:
-    // |position| is the new mouse position.
-    virtual void OnMouseMoved(const SkIPoint& position) = 0;
-
-   protected:
-    virtual ~MouseEventListener() {}
-  };
-  // The interface to receive key stroke events.
-  class MEDIA_EXPORT KeyStrokeListener {
-   public:
-    // Called when any key is pressed. Called only once until the key is
-    // released, i.e. holding down a key for a long period will generate one
-    // callback just when the key is pressed down.
-    virtual void OnKeyStroke() = 0;
-
-   protected:
-    virtual ~KeyStrokeListener() {}
-  };
-
-  virtual ~UserInputMonitor();
-
-  // Creates a platform-specific instance of UserInputMonitor.
-  // |io_task_runner| is the task runner for an IO thread.
-  // |ui_task_runner| is the task runner for a UI thread.
-  static scoped_ptr<UserInputMonitor> Create(
-      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-      const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner);
-
-  // The same |listener| should only be added once.
-  // The clients should make sure to call Remove*Listener before |listener| is
-  // destroyed.
-  void AddMouseListener(MouseEventListener* listener);
-  void RemoveMouseListener(MouseEventListener* listener);
-  void AddKeyStrokeListener(KeyStrokeListener* listener);
-  void RemoveKeyStrokeListener(KeyStrokeListener* listener);
-
- protected:
-  UserInputMonitor();
-
-  // Called by the platform-specific sub-classes to propagate the events to the
-  // listeners.
-  void OnMouseEvent(const SkIPoint& position);
-  void OnKeyboardEvent(ui::EventType event, ui::KeyboardCode key_code);
-
- private:
-  virtual void StartMouseMonitoring() = 0;
-  virtual void StopMouseMonitoring() = 0;
-  virtual void StartKeyboardMonitoring() = 0;
-  virtual void StopKeyboardMonitoring() = 0;
-
-  base::Lock lock_;
-  ObserverList<MouseEventListener, true> mouse_listeners_;
-  ObserverList<KeyStrokeListener, true> key_stroke_listeners_;
-  bool monitoring_mouse_;
-  bool monitoring_keyboard_;
-  // The set of keys currently held down. Used for convering raw keyboard events
-  // into KeyStrokeListener callbacks.
-  std::set<ui::KeyboardCode> pressed_keys_;
-
-  DISALLOW_COPY_AND_ASSIGN(UserInputMonitor);
-};
-
-}  // namespace media
-
-#endif  // MEDIA_BASE_USER_INPUT_MONITOR_H_
diff --git a/media/base/user_input_monitor_linux.cc b/media/base/user_input_monitor_linux.cc
deleted file mode 100644
index ee1b774..0000000
--- a/media/base/user_input_monitor_linux.cc
+++ /dev/null
@@ -1,338 +0,0 @@
-// Copyright 2013 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/base/user_input_monitor.h"
-
-#include <sys/select.h>
-#include <unistd.h>
-#define XK_MISCELLANY
-#include <X11/keysymdef.h>
-
-#include "base/basictypes.h"
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_pump_libevent.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/non_thread_safe.h"
-#include "third_party/skia/include/core/SkPoint.h"
-#include "ui/base/keycodes/keyboard_code_conversion_x.h"
-
-// These includes need to be later than dictated by the style guide due to
-// Xlib header pollution, specifically the min, max, and Status macros.
-#include <X11/XKBlib.h>
-#include <X11/Xlibint.h>
-#include <X11/extensions/record.h>
-
-namespace media {
-
-namespace {
-
-class UserInputMonitorLinux : public base::NonThreadSafe,
-                              public UserInputMonitor {
- public:
-  UserInputMonitorLinux(
-      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
-  virtual ~UserInputMonitorLinux();
-
- private:
-  enum EventType {
-    MOUSE_EVENT,
-    KEYBOARD_EVENT
-  };
-
-  // The actual implementation resides in UserInputMonitorLinux::Core class.
-  // Must be called on the io_task_runner thread.
-  class Core : public base::RefCountedThreadSafe<Core>,
-               public base::MessagePumpLibevent::Watcher {
-   public:
-    typedef const base::Callback<void(const SkIPoint&)> MouseCallback;
-    typedef base::Callback<void(ui::EventType event, ui::KeyboardCode key_code)>
-        KeyboardCallback;
-    Core(const MouseCallback& mouse_callback,
-         const KeyboardCallback& keyboard_callback);
-
-    void StartMonitor(EventType type);
-    void StopMonitor(EventType type);
-
-   private:
-    friend class base::RefCountedThreadSafe<Core>;
-    virtual ~Core();
-
-    // base::MessagePumpLibevent::Watcher interface.
-    virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-    virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
-
-    // Processes key and mouse events.
-    void ProcessXEvent(xEvent* event);
-    static void ProcessReply(XPointer self, XRecordInterceptData* data);
-
-    // Used to receive base::MessagePumpLibevent::Watcher events.
-    base::MessagePumpLibevent::FileDescriptorWatcher controller_;
-
-    Display* display_;
-    Display* x_record_display_;
-    XRecordRange* x_record_range_[2];
-    XRecordContext x_record_context_;
-    base::Callback<void(const SkIPoint&)> mouse_callback_;
-    base::Callback<void(ui::EventType event, ui::KeyboardCode key_code)>
-        keyboard_callback_;
-
-    DISALLOW_COPY_AND_ASSIGN(Core);
-  };
-
-  virtual void StartMouseMonitoring() OVERRIDE;
-  virtual void StopMouseMonitoring() OVERRIDE;
-  virtual void StartKeyboardMonitoring() OVERRIDE;
-  virtual void StopKeyboardMonitoring() OVERRIDE;
-
-  void OnMouseEvent(const SkIPoint& position);
-  void OnKeyboardEvent(ui::EventType event, ui::KeyboardCode key_code);
-
-  // Task runner on which X Window events are received.
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-  scoped_refptr<Core> core_;
-
-  DISALLOW_COPY_AND_ASSIGN(UserInputMonitorLinux);
-};
-
-UserInputMonitorLinux::UserInputMonitorLinux(
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
-    : io_task_runner_(io_task_runner),
-      core_(new Core(base::Bind(&UserInputMonitorLinux::OnMouseEvent,
-                                base::Unretained(this)),
-                     base::Bind(&UserInputMonitorLinux::OnKeyboardEvent,
-                                base::Unretained(this)))) {}
-
-UserInputMonitorLinux::~UserInputMonitorLinux() {}
-
-void UserInputMonitorLinux::StartMouseMonitoring() {
-  io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Core::StartMonitor, core_.get(), MOUSE_EVENT));
-}
-
-void UserInputMonitorLinux::StopMouseMonitoring() {
-  io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Core::StopMonitor, core_.get(), MOUSE_EVENT));
-}
-
-void UserInputMonitorLinux::StartKeyboardMonitoring() {
-  io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Core::StartMonitor, core_.get(), KEYBOARD_EVENT));
-}
-
-void UserInputMonitorLinux::StopKeyboardMonitoring() {
-  io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Core::StopMonitor, core_.get(), KEYBOARD_EVENT));
-}
-
-void UserInputMonitorLinux::OnMouseEvent(const SkIPoint& position) {
-  UserInputMonitor::OnMouseEvent(position);
-}
-
-void UserInputMonitorLinux::OnKeyboardEvent(ui::EventType event,
-                                            ui::KeyboardCode key_code) {
-  UserInputMonitor::OnKeyboardEvent(event, key_code);
-}
-
-UserInputMonitorLinux::Core::Core(const MouseCallback& mouse_callback,
-                                  const KeyboardCallback& keyboard_callback)
-    : display_(NULL),
-      x_record_display_(NULL),
-      x_record_context_(0),
-      mouse_callback_(mouse_callback),
-      keyboard_callback_(keyboard_callback) {
-  x_record_range_[0] = NULL;
-  x_record_range_[1] = NULL;
-}
-
-UserInputMonitorLinux::Core::~Core() {
-  DCHECK(!display_);
-  DCHECK(!x_record_display_);
-  DCHECK(!x_record_range_[0]);
-  DCHECK(!x_record_range_[1]);
-  DCHECK(!x_record_context_);
-}
-
-void UserInputMonitorLinux::Core::StartMonitor(EventType type) {
-  DCHECK(base::MessageLoopForIO::current());
-  // TODO(jamiewalch): We should pass the display in. At that point, since
-  // XRecord needs a private connection to the X Server for its data channel
-  // and both channels are used from a separate thread, we'll need to duplicate
-  // them with something like the following:
-  //   XOpenDisplay(DisplayString(display));
-  if (!display_)
-    display_ = XOpenDisplay(NULL);
-
-  if (!x_record_display_)
-    x_record_display_ = XOpenDisplay(NULL);
-
-  if (!display_ || !x_record_display_) {
-    LOG(ERROR) << "Couldn't open X display";
-    return;
-  }
-
-  int xr_opcode, xr_event, xr_error;
-  if (!XQueryExtension(display_, "RECORD", &xr_opcode, &xr_event, &xr_error)) {
-    LOG(ERROR) << "X Record extension not available.";
-    return;
-  }
-
-  if (!x_record_range_[type])
-    x_record_range_[type] = XRecordAllocRange();
-
-  if (!x_record_range_[type]) {
-    LOG(ERROR) << "XRecordAllocRange failed.";
-    return;
-  }
-
-  if (type == MOUSE_EVENT) {
-    x_record_range_[type]->device_events.first = MotionNotify;
-    x_record_range_[type]->device_events.last = MotionNotify;
-  } else {
-    DCHECK_EQ(KEYBOARD_EVENT, type);
-    x_record_range_[type]->device_events.first = KeyPress;
-    x_record_range_[type]->device_events.last = KeyRelease;
-  }
-
-  if (x_record_context_) {
-    XRecordDisableContext(display_, x_record_context_);
-    XFlush(display_);
-    XRecordFreeContext(x_record_display_, x_record_context_);
-    x_record_context_ = 0;
-  }
-  XRecordRange** record_range_to_use =
-      (x_record_range_[0] && x_record_range_[1]) ? x_record_range_
-                                                 : &x_record_range_[type];
-  int number_of_ranges = (x_record_range_[0] && x_record_range_[1]) ? 2 : 1;
-
-  XRecordClientSpec client_spec = XRecordAllClients;
-  x_record_context_ = XRecordCreateContext(x_record_display_,
-                                           0,
-                                           &client_spec,
-                                           1,
-                                           record_range_to_use,
-                                           number_of_ranges);
-  if (!x_record_context_) {
-    LOG(ERROR) << "XRecordCreateContext failed.";
-    return;
-  }
-
-  if (!XRecordEnableContextAsync(x_record_display_,
-                                 x_record_context_,
-                                 &Core::ProcessReply,
-                                 reinterpret_cast<XPointer>(this))) {
-    LOG(ERROR) << "XRecordEnableContextAsync failed.";
-    return;
-  }
-
-  if (!x_record_range_[0] || !x_record_range_[1]) {
-    // Register OnFileCanReadWithoutBlocking() to be called every time there is
-    // something to read from |x_record_display_|.
-    base::MessageLoopForIO* message_loop = base::MessageLoopForIO::current();
-    int result =
-        message_loop->WatchFileDescriptor(ConnectionNumber(x_record_display_),
-                                          true,
-                                          base::MessageLoopForIO::WATCH_READ,
-                                          &controller_,
-                                          this);
-    if (!result) {
-      LOG(ERROR) << "Failed to create X record task.";
-      return;
-    }
-  }
-
-  // Fetch pending events if any.
-  OnFileCanReadWithoutBlocking(ConnectionNumber(x_record_display_));
-}
-
-void UserInputMonitorLinux::Core::StopMonitor(EventType type) {
-  DCHECK(base::MessageLoopForIO::current());
-
-  if (x_record_range_[type]) {
-    XFree(x_record_range_[type]);
-    x_record_range_[type] = NULL;
-  }
-  if (x_record_range_[0] || x_record_range_[1])
-    return;
-
-  // Context must be disabled via the control channel because we can't send
-  // any X protocol traffic over the data channel while it's recording.
-  if (x_record_context_) {
-    XRecordDisableContext(display_, x_record_context_);
-    XFlush(display_);
-    XRecordFreeContext(x_record_display_, x_record_context_);
-    x_record_context_ = 0;
-
-    controller_.StopWatchingFileDescriptor();
-    if (x_record_display_) {
-      XCloseDisplay(x_record_display_);
-      x_record_display_ = NULL;
-    }
-    if (display_) {
-      XCloseDisplay(display_);
-      display_ = NULL;
-    }
-  }
-}
-
-void UserInputMonitorLinux::Core::OnFileCanReadWithoutBlocking(int fd) {
-  DCHECK(base::MessageLoopForIO::current());
-  XEvent event;
-  // Fetch pending events if any.
-  while (XPending(x_record_display_)) {
-    XNextEvent(x_record_display_, &event);
-  }
-}
-
-void UserInputMonitorLinux::Core::OnFileCanWriteWithoutBlocking(int fd) {
-  NOTREACHED();
-}
-
-void UserInputMonitorLinux::Core::ProcessXEvent(xEvent* event) {
-  if (event->u.u.type == MotionNotify) {
-    SkIPoint position(SkIPoint::Make(event->u.keyButtonPointer.rootX,
-                                     event->u.keyButtonPointer.rootY));
-    mouse_callback_.Run(position);
-  } else {
-    ui::EventType type;
-    if (event->u.u.type == KeyPress) {
-      type = ui::ET_KEY_PRESSED;
-    } else if (event->u.u.type == KeyRelease) {
-      type = ui::ET_KEY_RELEASED;
-    } else {
-      NOTREACHED();
-    }
-
-    KeySym key_sym = XkbKeycodeToKeysym(display_, event->u.u.detail, 0, 0);
-    ui::KeyboardCode key_code = ui::KeyboardCodeFromXKeysym(key_sym);
-    keyboard_callback_.Run(type, key_code);
-  }
-}
-
-// static
-void UserInputMonitorLinux::Core::ProcessReply(XPointer self,
-                                               XRecordInterceptData* data) {
-  if (data->category == XRecordFromServer) {
-    xEvent* event = reinterpret_cast<xEvent*>(data->data);
-    reinterpret_cast<Core*>(self)->ProcessXEvent(event);
-  }
-  XRecordFreeData(data);
-}
-
-}  // namespace
-
-scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
-  return scoped_ptr<UserInputMonitor>(
-      new UserInputMonitorLinux(io_task_runner));
-}
-
-}  // namespace media
diff --git a/media/base/user_input_monitor_mac.mm b/media/base/user_input_monitor_mac.mm
deleted file mode 100644
index 4ffad42..0000000
--- a/media/base/user_input_monitor_mac.mm
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2013 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/base/user_input_monitor.h"
-
-namespace media {
-
-// TODO(jiayl): add the implementation.
-scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
-    const scoped_refptr<base::SingleThreadTaskRunner>& input_task_runner,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
-  return scoped_ptr<UserInputMonitor>();
-}
-
-}  // namespace media
diff --git a/media/base/user_input_monitor_win.cc b/media/base/user_input_monitor_win.cc
deleted file mode 100644
index 4ffad42..0000000
--- a/media/base/user_input_monitor_win.cc
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2013 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/base/user_input_monitor.h"
-
-namespace media {
-
-// TODO(jiayl): add the implementation.
-scoped_ptr<UserInputMonitor> UserInputMonitor::Create(
-    const scoped_refptr<base::SingleThreadTaskRunner>& input_task_runner,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner) {
-  return scoped_ptr<UserInputMonitor>();
-}
-
-}  // namespace media
diff --git a/media/media.gyp b/media/media.gyp
index 800126b..92642a2 100644
--- a/media/media.gyp
+++ b/media/media.gyp
@@ -304,11 +304,6 @@
         'base/stream_parser_buffer.cc',
         'base/stream_parser_buffer.h',
         'base/text_track.h',
-        'base/user_input_monitor.cc',
-        'base/user_input_monitor.h',
-        'base/user_input_monitor_linux.cc',
-        'base/user_input_monitor_mac.mm',
-        'base/user_input_monitor_win.cc',
         'base/video_decoder.cc',
         'base/video_decoder.h',
         'base/video_decoder_config.cc',
@@ -546,7 +541,6 @@
             ['include', '^base/media\\.cc$'],
             ['include', '^base/media_stub\\.cc$'],
             ['include', '^base/media_switches\\.'],
-            ['include', '^base/user_input_monitor\\.'],
             ['include', '^base/vector_math\\.'],
           ],
           'link_settings': {
@@ -557,9 +551,6 @@
               '$(SDKROOT)/System/Library/Frameworks/CoreMIDI.framework',
             ],
           },
-          'defines': [
-            'DISABLE_USER_INPUT_MONITOR',
-          ],
         }],
         ['OS=="android"', {
           'link_settings': {
@@ -587,9 +578,6 @@
               ],
             }],
           ],
-          'defines': [
-            'DISABLE_USER_INPUT_MONITOR',
-          ],
         }],
         # A simple WebM encoder for animated avatars on ChromeOS.
         ['chromeos==1', {
@@ -603,15 +591,6 @@
             'webm/chromeos/webm_encoder.cc',
             'webm/chromeos/webm_encoder.h',
           ],
-          'defines': [
-            # TODO(jiayl): figure out why MediaStreamInfoBarTest.
-            # DenyingCameraDoesNotCauseStickyDenyForMics fails on ChromeOS and
-            # remove this.
-            'DISABLE_USER_INPUT_MONITOR',
-          ],
-          'sources!': [
-            'base/user_input_monitor_linux.cc',
-          ],
         }],
         ['use_alsa==1', {
           'link_settings': {
@@ -647,16 +626,8 @@
                   '-lXdamage',
                   '-lXext',
                   '-lXfixes',
-                  '-lXtst',
                 ],
               },
-            }, {  # else: use_x11==0
-              'sources!': [
-                'base/user_input_monitor_linux.cc',
-              ],
-              'defines': [
-                'DISABLE_USER_INPUT_MONITOR',
-              ],
             }],
             ['use_cras==1', {
               'cflags': [