Possible solution to synchronization problems in webrtc audio capturer.

content/renderer/media/webrtc_audio_capturer.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 CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_CAPTURER_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_CAPTURER_H_
 
 #include <list>
 #include <string>
 
@@ skipping 118 matching lines @@
   bool is_recording() const { return running_; }
 
   // Returns true if a local renderer has called PrepareLoopback() and it can
   // be utilized to prevent more than one local renderer.
   // Called on the main render thread.
   bool IsInLoopbackMode();
 
   // Audio parameters utilized by the audio capturer. Can be utilized by
   // a local renderer to set up a renderer using identical parameters as the
   // capturer.
-  const media::AudioParameters& audio_parameter() const { return params_; }
+  // TODO(phoglund): This accessor is inherently unsafe since the returned
+  // parameters can become outdated at any time. Think over the implications
+  // of this accessor and if we can remove it.
+  media::AudioParameters audio_parameters() const;
 
   // AudioCapturerSource::CaptureCallback implementation.
   // Called on the AudioInputDevice audio thread.
   virtual void Capture(media::AudioBus* audio_source,
                        int audio_delay_milliseconds,
                        double volume) OVERRIDE;
   virtual void OnCaptureError() OVERRIDE;
 
   // AudioCapturerSource::CaptureEventHandler implementation.
   // Called on the IO thread.
   virtual void OnDeviceStarted(const std::string& device_id) OVERRIDE;
   virtual void OnDeviceStopped() OVERRIDE;
 
   // WebRtcLocalAudioRenderer::LocalRenderCallback implementation.
   // Reads stored captured data from a local FIFO. This method is used in
   // combination with a local sink to render captured audio in loopback.
   // This method is called on the AudioOutputDevice worker thread.
   virtual void ProvideInput(media::AudioBus* dest) OVERRIDE;
 
  protected:
   friend class base::RefCountedThreadSafe<WebRtcAudioCapturer>;
   virtual ~WebRtcAudioCapturer();
 
  private:
   typedef std::list<WebRtcAudioCapturerSink*> SinkList;
 
   WebRtcAudioCapturer();
 
+  // Reconfigures the capturer with a new buffer size and capture parameters.
+  // Must be called without holding the lock. Returns true on success.
+  bool Reconfigure(int sample_rate, media::AudioParameters::Format format,
+                   media::ChannelLayout channel_layout);
+
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
 
   // Protects |source_|, |sinks_|, |running_|, |on_device_stopped_cb_|,
-  // |loopback_fifo_| and |buffering_|.
-  base::Lock lock_;
+  // |loopback_fifo_|, |params_| and |buffering_|.
+  mutable base::Lock lock_;
 
   // A list of sinks that the audio data is fed to.
   SinkList sinks_;
 
   // The audio data source from the browser process.
   scoped_refptr<media::AudioCapturerSource> source_;
 
-  // Cached values of utilized audio parameters. Platform dependent.
-  media::AudioParameters params_;
-
   // Buffers used for temporary storage during capture callbacks.
   // Allocated during initialization.
-  scoped_array<int16> buffer_;
+  class ConfiguredBuffer;
+  scoped_refptr<ConfiguredBuffer> buffer_;
   std::string device_id_;
   bool running_;
 
   // Callback object which is called during OnDeviceStopped().
   // Informs a local sink that it should stop asking for data.
   base::Closure on_device_stopped_cb_;
 
   // Contains copies of captured audio frames. Only utilized in loopback
   // mode when a local sink has been set.
   scoped_ptr<media::AudioFifo> loopback_fifo_;
 
   // True when FIFO is utilized, false otherwise.
   bool buffering_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcAudioCapturer);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_CAPTURER_H_