Remove the [Un]RegisterVoiceProcessor() API.

talk/media/webrtc/webrtcvoiceengine.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 35 matching lines @@
 #include "webrtc/call.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
 
 namespace cricket {
 
 class AudioDeviceModule;
 class AudioRenderer;
 class VoETraceWrapper;
 class VoEWrapper;
-class VoiceProcessor;
 class WebRtcVoiceMediaChannel;
 
 // WebRtcVoiceEngine is a class to be used with CompositeMediaEngine.
 // It uses the WebRtc VoiceEngine library for audio handling.
 class WebRtcVoiceEngine
     : public webrtc::VoiceEngineObserver,
-      public webrtc::TraceCallback,
-      public webrtc::VoEMediaProcess  {
+      public webrtc::TraceCallback  {
   friend class WebRtcVoiceMediaChannel;
 
  public:
   WebRtcVoiceEngine();
   // Dependency injection for testing.
   WebRtcVoiceEngine(VoEWrapper* voe_wrapper, VoETraceWrapper* tracing);
   ~WebRtcVoiceEngine();
   bool Init(rtc::Thread* worker_thread);
   void Terminate();
 
@@ skipping 11 matching lines @@
   int GetInputLevel();
 
   const std::vector<AudioCodec>& codecs();
   bool FindCodec(const AudioCodec& codec);
   bool FindWebRtcCodec(const AudioCodec& codec, webrtc::CodecInst* gcodec);
 
   const std::vector<RtpHeaderExtension>& rtp_header_extensions() const;
 
   void SetLogging(int min_sev, const char* filter);
 
-  bool RegisterProcessor(uint32 ssrc,
-                         VoiceProcessor* voice_processor,
-                         MediaProcessorDirection direction);
-  bool UnregisterProcessor(uint32 ssrc,
-                           VoiceProcessor* voice_processor,
-                           MediaProcessorDirection direction);
-
-  // Method from webrtc::VoEMediaProcess
-  void Process(int channel,
-               webrtc::ProcessingTypes type,
-               int16_t audio10ms[],
-               size_t length,
-               int sampling_freq,
-               bool is_stereo) override;
-
   // 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 existing file.
   bool StartAecDump(rtc::PlatformFile file);
 
   // Check whether the supplied trace should be ignored.
   bool ShouldIgnoreTrace(const std::string& trace);
 
   // Create a VoiceEngine Channel.
   int CreateMediaVoiceChannel();
 
  private:
   typedef std::vector<WebRtcVoiceMediaChannel*> ChannelList;
-  typedef sigslot::
-      signal3<uint32, MediaProcessorDirection, AudioFrame*> FrameSignal;
 
   void Construct();
   void ConstructCodecs();
   bool GetVoeCodec(int index, webrtc::CodecInst* codec);
   bool InitInternal();
   void SetTraceFilter(int filter);
   void SetTraceOptions(const std::string& options);
   // Applies either options or overrides.  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
@@ skipping 19 matching lines @@
   // webrtc::VoiceEngineObserver:
   void CallbackOnError(int channel, int errCode) override;
 
   // Given the device type, name, and id, find device id. Return true and
   // set the output parameter rtc_id if successful.
   bool FindWebRtcAudioDeviceId(
       bool is_input, const std::string& dev_name, int dev_id, int* rtc_id);
   bool FindChannelAndSsrc(int channel_num,
                           WebRtcVoiceMediaChannel** channel,
                           uint32* ssrc) const;
-  bool FindChannelNumFromSsrc(uint32 ssrc,
-                              MediaProcessorDirection direction,
-                              int* channel_num);
-
-  bool UnregisterProcessorChannel(MediaProcessorDirection channel_direction,
-                                  uint32 ssrc,
-                                  VoiceProcessor* voice_processor,
-                                  MediaProcessorDirection processor_direction);
 
   void StartAecDump(const std::string& filename);
   void StopAecDump();
   int CreateVoiceChannel(VoEWrapper* voe);
 
-  // When a voice processor registers with the engine, it is connected
-  // to either the Rx or Tx signals, based on the direction parameter.
-  // SignalXXMediaFrame will be invoked for every audio packet.
-  FrameSignal SignalRxMediaFrame;
-  FrameSignal SignalTxMediaFrame;
-
   static const int kDefaultLogSeverity = rtc::LS_WARNING;
 
   // The primary instance of WebRtc VoiceEngine.
   rtc::scoped_ptr<VoEWrapper> voe_wrapper_;
   rtc::scoped_ptr<VoETraceWrapper> tracing_;
   // The external audio device manager
   webrtc::AudioDeviceModule* adm_;
   int log_filter_;
   std::string log_options_;
   bool is_dumping_aec_;
@@ skipping 10 matching lines @@
   bool initialized_;
   // See SetOptions and SetOptionOverrides for a description of the
   // difference between options and overrides.
   // options_ are the base options, which combined with the
   // option_overrides_, create the current options being used.
   // options_ is stored so that when option_overrides_ is cleared, we
   // can restore the options_ without the option_overrides.
   AudioOptions options_;
   AudioOptions option_overrides_;
 
-  // When the media processor registers with the engine, the ssrc is cached
-  // here so that a look up need not be made when the callback is invoked.
-  // This is necessary because the lookup results in mux_channels_cs lock being
-  // held and if a remote participant leaves the hangout at the same time
-  // we hit a deadlock.
-  uint32 tx_processor_ssrc_;
-  uint32 rx_processor_ssrc_;
-
-  rtc::CriticalSection signal_media_critical_;
-
   // 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.
   Settable<bool> extended_filter_aec_;
   Settable<bool> delay_agnostic_aec_;
   Settable<bool> experimental_ns_;
 };
 
 // WebRtcVoiceMediaChannel is an implementation of VoiceMediaChannel that uses
@@ skipping 172 matching lines @@
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
 
   // Do not lock this on the VoE media processor thread; potential for deadlock
   // exists.
   mutable rtc::CriticalSection receive_channels_cs_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_WEBRTCVOICEENGINE_H_