Improved timer implementation in AudioInputController

media/audio/audio_input_controller.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 
 #include <string>
+#include "base/atomicops.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
 
@@ skipping 16 matching lines @@
 //
 // * Initial state
 //
 // State sequences (assuming low-latency):
 //
 //  [Creating Thread]                     [Audio Thread]
 //
 //      User               AudioInputController               EventHandler
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // CrateLowLatency() ==>        DoCreate()
-//                    AudioManager::MakeAudioInputStream()
-//                    AudioInputStream::Open()
-//                                  .- - - - - - - - - - - - ->  OnError()
-//                    DoResetNoDataTimer (posted on creating tread)
+//                   AudioManager::MakeAudioInputStream()
+//                        AudioInputStream::Open()
+//                                  .- - - - - - - - - - - - ->   OnError()
+//                          create the data timer
 //                                  .------------------------->  OnCreated()
 //                               kCreated
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // Record() ==>                 DoRecord()
-//                    AudioInputStream::Start()
+//                      AudioInputStream::Start()
 //                                  .------------------------->  OnRecording()
+//                          start the data timer
 //                              kRecording
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // Close() ==>                  DoClose()
-//                              state_ = kClosed
-//                    AudioInputStream::Stop()
-//                    AudioInputStream::Close()
-//                    SyncWriter::Close()
-// Closure::Run() <--------------.
+//                        delete the data timer
+//                           state_ = kClosed
+//                        AudioInputStream::Stop()
+//                        AudioInputStream::Close()
+//                          SyncWriter::Close()
+// Closure::Run() <-----------------.
 // (closure-task)
 //
 // The audio thread itself is owned by the AudioManager that the
 // AudioInputController holds a reference to.  When performing tasks on the
 // audio thread, the controller must not add or release references to the
 // AudioManager or itself (since it in turn holds a reference to the manager).
 //
 namespace media {
 
 class MEDIA_EXPORT AudioInputController
@@ skipping 118 matching lines @@
 
   // Methods called on the audio thread (owned by the AudioManager).
   void DoCreate(AudioManager* audio_manager, const AudioParameters& params,
                 const std::string& device_id);
   void DoRecord();
   void DoClose();
   void DoReportError(int code);
   void DoSetVolume(double volume);
   void DoSetAutomaticGainControl(bool enabled);
 
-  // Methods which ensures that OnError() is triggered when data recording
-  // times out. Both are called on the creating thread.
-  void DoReportNoDataError();
-  void DoResetNoDataTimer();
+  // Method which ensures that OnError() is triggered when data recording
+  // times out. Called on the audio thread.
+  void DoCheckForNoData();
 
   // Helper method that stops, closes, and NULL:s |*stream_|.
   // Signals event when done if the event is not NULL.
   void DoStopCloseAndClearStream(base::WaitableEvent* done);
 
+  void SetDataIsActive(bool enabled);
+  bool GetDataIsActive();
+
   // Gives access to the message loop of the creating thread.
   scoped_refptr<base::MessageLoopProxy> creator_loop_;
 
   // The message loop of audio-manager thread that this object runs on.
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   // Contains the AudioInputController::EventHandler which receives state
   // notifications from this class.
   EventHandler* handler_;
 
   // Pointer to the audio input stream object.
   AudioInputStream* stream_;
 
-  // |no_data_timer_| is used to call DoReportNoDataError() when we stop
-  // receiving OnData() calls without an OnClose() call. This can occur
+  // |no_data_timer_| is used to call OnError() when we stop receiving
+  // OnData() calls without an OnClose() call. This can occur
   // when an audio input device is unplugged whilst recording on Windows.
   // See http://crbug.com/79936 for details.
-  // This member is only touched by the creating thread.
+  // This member is only touched by the audio thread.
   scoped_ptr<base::DelayTimer<AudioInputController> > no_data_timer_;
 
+  // This flag is used to signal that we are receiving OnData() calls, i.e,
+  // that data is active. It can be touched by the audio thread and by the
+  // low-level audio thread which calls OnData(). E.g. on Windows, the
+  // low-level audio thread is called wasapi_capture_thread.
+  base::subtle::Atomic32 data_is_active_;
+
   // |state_| is written on the audio thread and is read on the hardware audio
   // thread. These operations need to be locked. But lock is not required for
   // reading on the audio input controller thread.
   State state_;
 
   base::Lock lock_;
 
   // SyncWriter is used only in low-latency mode for synchronous writing.
   SyncWriter* sync_writer_;
 
   static Factory* factory_;
 
   double max_volume_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioInputController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_