Remove WVoE::SetAudioDeviceModule() - it is now set in ctor.

webrtc/media/engine/webrtcvoiceengine.h

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_MEDIA_ENGINE_WEBRTCVOICEENGINE_H_
 #define WEBRTC_MEDIA_ENGINE_WEBRTCVOICEENGINE_H_
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/audio_state.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/networkroute.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/call.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/engine/webrtccommon.h"
 #include "webrtc/media/engine/webrtcvoe.h"
 #include "webrtc/pc/channel.h"
 
 namespace cricket {
 
 class AudioDeviceModule;
 class AudioSource;
 class VoEWrapper;
 class WebRtcVoiceMediaChannel;
 
 // WebRtcVoiceEngine is a class to be used with CompositeMediaEngine.
 // It uses the WebRtc VoiceEngine library for audio handling.
 class WebRtcVoiceEngine final : public webrtc::TraceCallback  {
   friend class WebRtcVoiceMediaChannel;
  public:
   // Exposed for the WVoE/MC unit test.
   static bool ToCodecInst(const AudioCodec& in, webrtc::CodecInst* out);
 
-  WebRtcVoiceEngine();
+  explicit WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm);
   // Dependency injection for testing.
-  explicit WebRtcVoiceEngine(VoEWrapper* voe_wrapper);
-  ~WebRtcVoiceEngine();
-  bool Init(rtc::Thread* worker_thread);
-  void Terminate();
+  WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm, VoEWrapper* voe_wrapper);
+  ~WebRtcVoiceEngine() override;
 
   rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const;
   VoiceMediaChannel* CreateChannel(webrtc::Call* call,
                                    const MediaConfig& config,
                                    const AudioOptions& options);
 
   bool GetOutputVolume(int* level);
   bool SetOutputVolume(int level);
   int GetInputLevel();
 
   const std::vector<AudioCodec>& codecs();
   RtpCapabilities GetCapabilities() const;
 
   // For tracking WebRtc channels. Needed because we have to pause them
   // all when switching devices.
   // May only be called by WebRtcVoiceMediaChannel.
   void RegisterChannel(WebRtcVoiceMediaChannel* channel);
   void UnregisterChannel(WebRtcVoiceMediaChannel* channel);
 
   // Called by WebRtcVoiceMediaChannel to set a gain offset from
   // the default AGC target level.
   bool AdjustAgcLevel(int delta);
 
   VoEWrapper* voe() { return voe_wrapper_.get(); }
   int GetLastEngineError();
 
-  // Set the external ADM. This can only be called before Init.
-  bool SetAudioDeviceModule(webrtc::AudioDeviceModule* adm);
-
   // Starts AEC dump using an existing file. A maximum file size in bytes can be
   // specified. When the maximum file size is reached, logging is stopped and
   // the file is closed. If max_size_bytes is set to <= 0, no limit will be
   // used.
   bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes);
 
   // Stops AEC dump.
   void StopAecDump();
 
   // Starts recording an RtcEventLog using an existing file until 10 minutes
   // pass or the StopRtcEventLog function is called.
   bool StartRtcEventLog(rtc::PlatformFile file);
 
   // Stops recording the RtcEventLog.
   void StopRtcEventLog();
 
  private:
-  void Construct();
-  bool InitInternal();
   // Every option that is "set" will be applied. Every option not "set" will be
   // ignored. This allows us to selectively turn on and off different options
   // easily at any time.
   bool ApplyOptions(const AudioOptions& options);
   void SetDefaultDevices();
 
   // webrtc::TraceCallback:
   void Print(webrtc::TraceLevel level, const char* trace, int length) override;
 
   void StartAecDump(const std::string& filename);
   int CreateVoEChannel();
 
   rtc::ThreadChecker signal_thread_checker_;
   rtc::ThreadChecker worker_thread_checker_;
 
+  // The audio device manager.
+  rtc::scoped_refptr<webrtc::AudioDeviceModule> adm_;
   // The primary instance of WebRtc VoiceEngine.
   std::unique_ptr<VoEWrapper> voe_wrapper_;
   rtc::scoped_refptr<webrtc::AudioState> audio_state_;
-  // The external audio device manager
-  webrtc::AudioDeviceModule* adm_ = nullptr;
   std::vector<AudioCodec> codecs_;
   std::vector<WebRtcVoiceMediaChannel*> channels_;
   webrtc::Config voe_config_;
-  bool initialized_ = false;
   bool is_dumping_aec_ = false;
 
   webrtc::AgcConfig default_agc_config_;
   // Cache received extended_filter_aec, delay_agnostic_aec and experimental_ns
   // values, and apply them in case they are missing in the audio options. We
   // need to do this because SetExtraOptions() will revert to defaults for
   // options which are not provided.
   rtc::Optional<bool> extended_filter_aec_;
   rtc::Optional<bool> delay_agnostic_aec_;
   rtc::Optional<bool> experimental_ns_;
 
-  RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcVoiceEngine);
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcVoiceEngine);
 };
 
 // WebRtcVoiceMediaChannel is an implementation of VoiceMediaChannel that uses
 // WebRtc Voice Engine.
 class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
                                       public webrtc::Transport {
  public:
   WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
                           const MediaConfig& config,
                           const AudioOptions& options,
                           webrtc::Call* call);
   ~WebRtcVoiceMediaChannel() override;
 
   const AudioOptions& options() const { return options_; }
 
   rtc::DiffServCodePoint PreferredDscp() const override;
 
   bool SetSendParameters(const AudioSendParameters& params) override;
   bool SetRecvParameters(const AudioRecvParameters& params) override;
   bool SetPlayout(bool playout) override;
   bool PausePlayout();
   bool ResumePlayout();
   void SetSend(bool send) override;
-  bool PauseSend();
-  bool ResumeSend();
   bool SetAudioSend(uint32_t ssrc,
                     bool enable,
                     const AudioOptions* options,
                     AudioSource* source) override;
   bool AddSendStream(const StreamParams& sp) override;
   bool RemoveSendStream(uint32_t ssrc) override;
   bool AddRecvStream(const StreamParams& sp) override;
   bool RemoveRecvStream(uint32_t ssrc) override;
   bool GetActiveStreams(AudioInfo::StreamList* actives) override;
   int GetOutputLevel() override;
@@ skipping 113 matching lines @@
     int cng_payload_type = -1;
     int cng_plfreq = -1;
     webrtc::CodecInst codec_inst;
   } send_codec_spec_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcVoiceMediaChannel);
 };
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVOICEENGINE_H_