MediaStream audio sourcing: Bypass audio processing for non-WebRTC cases.

content/renderer/media/webrtc_audio_device_impl.h

 // 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 CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_DEVICE_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_DEVICE_IMPL_H_
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "content/common/content_export.h"
-#include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_device_not_impl.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/base/audio_capturer_source.h"
 #include "media/base/audio_renderer_sink.h"
 
 // A WebRtcAudioDeviceImpl instance implements the abstract interface
 // webrtc::AudioDeviceModule which makes it possible for a user (e.g. webrtc::
 // VoiceEngine) to register this class as an external AudioDeviceModule (ADM).
 // Then WebRtcAudioDeviceImpl::SetSessionId() needs to be called to set the
 // session id that tells which device to use. The user can then call
@@ skipping 144 matching lines @@
 //  - AGC is only supported in combination with the WASAPI-based audio layer
 //    on Windows, i.e., it is not supported on Windows XP.
 //  - All volume levels required for the AGC scheme are transfered in a
 //    normalized range [0.0, 1.0]. Scaling takes place in both endpoints
 //    (WebRTC client a media layer). This approach ensures that we can avoid
 //    transferring maximum levels between the renderer and the browser.
 //
 
 namespace content {
 
-class WebRtcAudioCapturer;
+class ProcessedLocalAudioSource;
 class WebRtcAudioRenderer;
 
 // TODO(xians): Move the following two interfaces to webrtc so that
 // libjingle can own references to the renderer and capturer.
 class WebRtcAudioRendererSource {
  public:
   // Callback to get the rendered data.
   virtual void RenderData(media::AudioBus* audio_bus,
                           int sample_rate,
                           int audio_delay_milliseconds,
@@ skipping 102 matching lines @@
   int32_t PlayoutDelay(uint16_t* delay_ms) const override;
   int32_t RecordingDelay(uint16_t* delay_ms) const override;
   int32_t RecordingSampleRate(uint32_t* sample_rate) const override;
   int32_t PlayoutSampleRate(uint32_t* sample_rate) const override;
 
  public:
   // Sets the |renderer_|, returns false if |renderer_| already exists.
   // Called on the main renderer thread.
   bool SetAudioRenderer(WebRtcAudioRenderer* renderer);
 
-  // Adds/Removes the capturer to the ADM.
+  // Adds/Removes the |capturer| to the ADM.  Does NOT take ownership.
   // TODO(xians): Remove these two methods once the ADM does not need to pass
   // hardware information up to WebRtc.
-  void AddAudioCapturer(const scoped_refptr<WebRtcAudioCapturer>& capturer);
-  void RemoveAudioCapturer(const scoped_refptr<WebRtcAudioCapturer>& capturer);
-
-  // Gets the default capturer, which is the last capturer in |capturers_|.
-  // The method can be called by both Libjingle thread and main render thread.
-  scoped_refptr<WebRtcAudioCapturer> GetDefaultCapturer() const;
+  void AddAudioCapturer(ProcessedLocalAudioSource* capturer);
+  void RemoveAudioCapturer(ProcessedLocalAudioSource* capturer);
 
   // Gets paired device information of the capture device for the audio
   // renderer. This is used to pass on a session id, sample rate and buffer
   // size to a webrtc audio renderer (either local or remote), so that audio
   // will be rendered to a matching output device.
   // Returns true if the capture device has a paired output device, otherwise
   // false. Note that if there are more than one open capture device the
   // function will not be able to pick an appropriate device and return false.
   bool GetAuthorizedDeviceInfoForAudioRenderer(
       int* session_id, int* output_sample_rate, int* output_buffer_size);
 
   const scoped_refptr<WebRtcAudioRenderer>& renderer() const {
     return renderer_;
   }
 
  private:
-  typedef std::list<scoped_refptr<WebRtcAudioCapturer> > CapturerList;
+  typedef std::list<ProcessedLocalAudioSource*> CapturerList;
   typedef std::list<WebRtcPlayoutDataSource::Sink*> PlayoutDataSinkList;
   class RenderBuffer;
 
   // Make destructor private to ensure that we can only be deleted by Release().
   ~WebRtcAudioDeviceImpl() override;
 
   // WebRtcAudioRendererSource implementation.
 
   // Called on the AudioOutputDevice worker thread.
   void RenderData(media::AudioBus* audio_bus,
@@ skipping 60 matching lines @@
   // Buffer used for temporary storage during render callback.
   // It is only accessed by the audio render thread.
   std::vector<int16_t> render_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcAudioDeviceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_AUDIO_DEVICE_IMPL_H_