Fix bug when unplugging an audio input device whilst using speech input.

media/audio/audio_input_controller.cc

 // Copyright (c) 2011 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/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 static const int kMaxInputChannels = 2;
+const int kDataCountCheckInterval = 1000; // One second.
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
 AudioInputController::AudioInputController(EventHandler* handler,
                                            SyncWriter* sync_writer)
     : handler_(handler),
       stream_(NULL),
+      on_data_call_count_(1),
+      previous_on_data_count_(0),
       state_(kEmpty),
       thread_("AudioInputControllerThread"),
       sync_writer_(sync_writer) {
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
@@ skipping 85 matching lines @@
   }
 
   if (stream_ && !stream_->Open()) {
     stream_->Close();
     stream_ = NULL;
     // TODO(satish): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
+  ScheduleDataCountCheck();
+
   state_ = kCreated;
   handler_->OnCreated(this);
 }
 
 void AudioInputController::DoRecord() {
   DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
 
   if (state_ != kCreated)
     return;
 
@@ skipping 25 matching lines @@
   // Since the stream is closed at this point there's no other threads reading
   // |state_| so we don't need to lock.
   state_ = kClosed;
 }
 
 void AudioInputController::DoReportError(int code) {
   DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
   handler_->OnError(this, code);
 }
 
+void AudioInputController::DoDataCountCheck() {
+  DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
+
+  if (previous_on_data_count_ < on_data_call_count_) {
+    // More data has arrived since last check.
+    previous_on_data_count_ = on_data_call_count_;
+    ScheduleDataCountCheck();
+    return;
+  }
+
+  // Have not received new data since last check so report an error.

[Satish, 2011/06/14 14:28:04]

It would be useful to explain this more and even add http://crbug.com/79936 so
it is clear that this was to fix a real world problem and not a theoretical one.

[allanwoj, 2011/06/14 15:03:12]

Done.

+  handler_->OnError(this, 0);
+}
+
+void AudioInputController::ScheduleDataCountCheck() {

[scherkus (not reviewing), 2011/06/13 19:04:56]

consider using DelayTimer from base/timer.h

[allanwoj, 2011/06/14 15:03:12]

Decided to keep it the way it is, this way it makes it easy to see which thread
we should be on.

[scherkus (not reviewing), 2011/06/14 21:22:02]

Not sure I agree... right now I find it more confusing as you're reading/writing
on different threads:
  1) OnData increments on_data_call_count_ on audio callback thread
  2) DoDataCountCheck reads on_data_call_count_ on thread_.message_loop()

Furthermore it's likely that another chromium developer will see DelayTimer and
understand what's happening, as opposed to having to interpret the
data_call_count stuff.

What about posting a task from OnData to thread_ (similar to OnError) to call
DelayTimer::Reset()? That way DelayTimer is only accessed on a single thread and
it takes care of task cancellation, etc...

[allanwoj, 2011/06/15 10:11:40]

Oh right, I see what you mean. I've gone ahead and done that. Thanks!

+  thread_.message_loop()->PostDelayedTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &AudioInputController::DoDataCountCheck),
+      kDataCountCheckInterval);
+}
+
 void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
                                   uint32 size) {
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
   }
 
+  ++on_data_call_count_;
+
   // Use SyncSocket if we are in a low-latency mode.
   if (LowLatencyMode()) {
     sync_writer_->Write(data, size);
     sync_writer_->UpdateRecordedBytes(size);
     return;
   }
 
   handler_->OnData(this, data, size);
 }
 
 void AudioInputController::OnClose(AudioInputStream* stream) {
   // 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, int code) {
   // Handle error on the audio controller thread.
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioInputController::DoReportError, code));
 }
 
 }  // namespace media