Remove the [Un]RegisterVoiceProcessor() API.

talk/media/webrtc/fakewebrtcvoiceengine.h

 /*
  * libjingle
  * Copyright 2010 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 16 matching lines @@
 
 #ifndef TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_
 #define TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_
 
 #include <list>
 #include <map>
 #include <vector>
 
 #include "talk/media/base/codec.h"
 #include "talk/media/base/rtputils.h"
-#include "talk/media/base/voiceprocessor.h"
 #include "talk/media/webrtc/fakewebrtccommon.h"
 #include "talk/media/webrtc/webrtcvoe.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 
 namespace cricket {
@@ skipping 132 matching lines @@
     return experimental_ns_enabled_;
   }
 
  private:
   bool experimental_ns_enabled_;
 };
 
 class FakeWebRtcVoiceEngine
     : public webrtc::VoEAudioProcessing,
       public webrtc::VoEBase, public webrtc::VoECodec, public webrtc::VoEDtmf,
-      public webrtc::VoEHardware,
-      public webrtc::VoEExternalMedia, public webrtc::VoENetEqStats,
+      public webrtc::VoEHardware, public webrtc::VoENetEqStats,
       public webrtc::VoENetwork, public webrtc::VoERTP_RTCP,
       public webrtc::VoEVideoSync, public webrtc::VoEVolumeControl {
  public:
   struct DtmfInfo {
     DtmfInfo()
       : dtmf_event_code(-1),
         dtmf_out_of_band(false),
         dtmf_length_ms(-1) {}
     int dtmf_event_code;
     bool dtmf_out_of_band;
     int dtmf_length_ms;
   };
   struct Channel {
     explicit Channel()
         : external_transport(false),
           send(false),
           playout(false),
           volume_scale(1.0),
           volume_pan_left(1.0),
           volume_pan_right(1.0),
           vad(false),
           codec_fec(false),
           max_encoding_bandwidth(0),
           opus_dtx(false),
           red(false),
           nack(false),
-          media_processor_registered(false),
           rx_agc_enabled(false),
           rx_agc_mode(webrtc::kAgcDefault),
           cn8_type(13),
           cn16_type(105),
           dtmf_type(106),
           red_type(117),
           nack_max_packets(0),
           send_ssrc(0),
           send_audio_level_ext_(-1),
           receive_audio_level_ext_(-1),
@@ skipping 10 matching lines @@
     bool playout;
     float volume_scale;
     float volume_pan_left;
     float volume_pan_right;
     bool vad;
     bool codec_fec;
     int max_encoding_bandwidth;
     bool opus_dtx;
     bool red;
     bool nack;
-    bool media_processor_registered;
     bool rx_agc_enabled;
     webrtc::AgcModes rx_agc_mode;
     webrtc::AgcConfig rx_agc_config;
     int cn8_type;
     int cn16_type;
     int dtmf_type;
     int red_type;
     int nack_max_packets;
     uint32 send_ssrc;
     int send_audio_level_ext_;
@@ skipping 27 matching lines @@
         stereo_swapping_enabled_(false),
         typing_detection_enabled_(false),
         ec_mode_(webrtc::kEcDefault),
         aecm_mode_(webrtc::kAecmSpeakerphone),
         ns_mode_(webrtc::kNsDefault),
         agc_mode_(webrtc::kAgcDefault),
         observer_(NULL),
         playout_fail_channel_(-1),
         send_fail_channel_(-1),
         recording_sample_rate_(-1),
-        playout_sample_rate_(-1),
-        media_processor_(NULL) {
+        playout_sample_rate_(-1) {
     memset(&agc_config_, 0, sizeof(agc_config_));
   }
   ~FakeWebRtcVoiceEngine() {
     // Ought to have all been deleted by the WebRtcVoiceMediaChannel
     // destructors, but just in case ...
     for (std::map<int, Channel*>::const_iterator i = channels_.begin();
          i != channels_.end(); ++i) {
       delete i->second;
     }
   }
 
-  bool IsExternalMediaProcessorRegistered() const {
-    return media_processor_ != NULL;
-  }
   bool IsInited() const { return inited_; }
   int GetLastChannel() const { return last_channel_; }
   int GetChannelFromLocalSsrc(uint32 local_ssrc) const {
     for (std::map<int, Channel*>::const_iterator iter = channels_.begin();
          iter != channels_.end(); ++iter) {
       if (local_ssrc == iter->second->send_ssrc)
         return iter->first;
     }
     return -1;
   }
@@ skipping 58 matching lines @@
   }
   void set_playout_fail_channel(int channel) {
     playout_fail_channel_ = channel;
   }
   void set_send_fail_channel(int channel) {
     send_fail_channel_ = channel;
   }
   void set_fail_create_channel(bool fail_create_channel) {
     fail_create_channel_ = fail_create_channel;
   }
-  void TriggerProcessPacket(MediaProcessorDirection direction) {
-    webrtc::ProcessingTypes pt =
-        (direction == cricket::MPD_TX) ?
-            webrtc::kRecordingPerChannel : webrtc::kPlaybackAllChannelsMixed;
-    if (media_processor_ != NULL) {
-      media_processor_->Process(0,
-                                pt,
-                                NULL,
-                                0,
-                                0,
-                                true);
-    }
-  }
   int AddChannel(const webrtc::Config& config) {
     if (fail_create_channel_) {
       return -1;
     }
     Channel* ch = new Channel();
     for (int i = 0; i < NumOfCodecs(); ++i) {
       webrtc::CodecInst codec;
       GetCodec(i, codec);
       ch->recv_codecs.push_back(codec);
     }
@@ skipping 680 matching lines @@
   }
   bool WasSendTelephoneEventCalled(int channel, int event_code, int length_ms) {
     return (channels_[channel]->dtmf_info.dtmf_event_code == event_code &&
             channels_[channel]->dtmf_info.dtmf_out_of_band == true &&
             channels_[channel]->dtmf_info.dtmf_length_ms == length_ms);
   }
   bool WasPlayDtmfToneCalled(int event_code, int length_ms) {
     return (dtmf_info_.dtmf_event_code == event_code &&
             dtmf_info_.dtmf_length_ms == length_ms);
   }
-  // webrtc::VoEExternalMedia
-  WEBRTC_FUNC(RegisterExternalMediaProcessing,
-              (int channel, webrtc::ProcessingTypes type,
-               webrtc::VoEMediaProcess& processObject)) {
-    WEBRTC_CHECK_CHANNEL(channel);
-    if (channels_[channel]->media_processor_registered) {
-      return -1;
-    }
-    channels_[channel]->media_processor_registered = true;
-    media_processor_ = &processObject;
-    return 0;
-  }
-  WEBRTC_FUNC(DeRegisterExternalMediaProcessing,
-              (int channel, webrtc::ProcessingTypes type)) {
-    WEBRTC_CHECK_CHANNEL(channel);
-    if (!channels_[channel]->media_processor_registered) {
-      return -1;
-    }
-    channels_[channel]->media_processor_registered = false;
-    media_processor_ = NULL;
-    return 0;
-  }
-  WEBRTC_STUB(GetAudioFrame, (int channel, int desired_sample_rate_hz,
-                              webrtc::AudioFrame* frame));
-  WEBRTC_STUB(SetExternalMixing, (int channel, bool enable));
   int GetNetEqCapacity() const {
     auto ch = channels_.find(last_channel_);
     ASSERT(ch != channels_.end());
     return ch->second->neteq_capacity;
   }
   bool GetNetEqFastAccelerate() const {
     auto ch = channels_.find(last_channel_);
     ASSERT(ch != channels_.end());
     return ch->second->neteq_fast_accelerate;
   }
@@ skipping 53 matching lines @@
   webrtc::AecmModes aecm_mode_;
   webrtc::NsModes ns_mode_;
   webrtc::AgcModes agc_mode_;
   webrtc::AgcConfig agc_config_;
   webrtc::VoiceEngineObserver* observer_;
   int playout_fail_channel_;
   int send_fail_channel_;
   int recording_sample_rate_;
   int playout_sample_rate_;
   DtmfInfo dtmf_info_;
-  webrtc::VoEMediaProcess* media_processor_;
   FakeAudioProcessing audio_processing_;
 };
 
 #undef WEBRTC_CHECK_HEADER_EXTENSION_ID
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_