WebRtcVoiceMediaChannel::AddRecvStream: Don't call SetRecPayloadType

webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #include "webrtc/voice_engine/test/auto_test/fakes/conference_transport.h"
 
 #include <string>
 
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/system_wrappers/include/sleep.h"
+#include "webrtc/voice_engine/channel_proxy.h"
+#include "webrtc/voice_engine/voice_engine_impl.h"
 
 namespace {
   static const unsigned int kReflectorSsrc = 0x0000;
   static const unsigned int kLocalSsrc = 0x0001;
   static const unsigned int kFirstRemoteSsrc = 0x0002;
   static const webrtc::CodecInst kCodecInst =
       {120, "opus", 48000, 960, 2, 64000};
   static const int kAudioLevelHeaderId = 1;
 
   static unsigned int ParseRtcpSsrc(const void* data, size_t len) {
@@ skipping 27 matching lines @@
   // here, we use two engines to make it more like reality.
   remote_voe_ = webrtc::VoiceEngine::Create();
   remote_base_ = webrtc::VoEBase::GetInterface(remote_voe_);
   remote_codec_ = webrtc::VoECodec::GetInterface(remote_voe_);
   remote_network_ = webrtc::VoENetwork::GetInterface(remote_voe_);
   remote_rtp_rtcp_ = webrtc::VoERTP_RTCP::GetInterface(remote_voe_);
   remote_file_ = webrtc::VoEFile::GetInterface(remote_voe_);
 
   EXPECT_EQ(0, local_base_->Init());
   local_sender_ = local_base_->CreateChannel();
+  static_cast<webrtc::VoiceEngineImpl*>(local_voe_)
+      ->GetChannelProxy(local_sender_)
+      ->RegisterLegacyCodecs();
   EXPECT_EQ(0, local_network_->RegisterExternalTransport(local_sender_, *this));
   EXPECT_EQ(0, local_rtp_rtcp_->SetLocalSSRC(local_sender_, kLocalSsrc));
   EXPECT_EQ(0, local_rtp_rtcp_->
       SetSendAudioLevelIndicationStatus(local_sender_, true,
                                         kAudioLevelHeaderId));
 
   EXPECT_EQ(0, local_base_->StartSend(local_sender_));
 
   EXPECT_EQ(0, remote_base_->Init());
   reflector_ = remote_base_->CreateChannel();
+  static_cast<webrtc::VoiceEngineImpl*>(remote_voe_)
+      ->GetChannelProxy(reflector_)
+      ->RegisterLegacyCodecs();
   EXPECT_EQ(0, remote_network_->RegisterExternalTransport(reflector_, *this));
   EXPECT_EQ(0, remote_rtp_rtcp_->SetLocalSSRC(reflector_, kReflectorSsrc));
 
   thread_.Start();
   thread_.SetPriority(rtc::kHighPriority);
 }
 
 ConferenceTransport::~ConferenceTransport() {
   // Must stop sending, otherwise DispatchPackets() cannot quit.
   EXPECT_EQ(0, remote_network_->DeRegisterExternalTransport(reflector_));
@@ skipping 130 matching lines @@
   return true;
 }
 
 void ConferenceTransport::SetRtt(unsigned int rtt_ms) {
   rtt_ms_ = rtt_ms;
 }
 
 unsigned int ConferenceTransport::AddStream(std::string file_name,
                                             webrtc::FileFormats format) {
   const int new_sender = remote_base_->CreateChannel();
+  static_cast<webrtc::VoiceEngineImpl*>(remote_voe_)
+      ->GetChannelProxy(new_sender)
+      ->RegisterLegacyCodecs();
   EXPECT_EQ(0, remote_network_->RegisterExternalTransport(new_sender, *this));
 
   const unsigned int remote_ssrc = kFirstRemoteSsrc + stream_count_++;
   EXPECT_EQ(0, remote_rtp_rtcp_->SetLocalSSRC(new_sender, remote_ssrc));
   EXPECT_EQ(0, remote_rtp_rtcp_->
       SetSendAudioLevelIndicationStatus(new_sender, true, kAudioLevelHeaderId));
 
   EXPECT_EQ(0, remote_codec_->SetSendCodec(new_sender, kCodecInst));
   EXPECT_EQ(0, remote_base_->StartSend(new_sender));
   EXPECT_EQ(0, remote_file_->StartPlayingFileAsMicrophone(
       new_sender, file_name.c_str(), true, false, format, 1.0));
 
   const int new_receiver = local_base_->CreateChannel();
+  static_cast<webrtc::VoiceEngineImpl*>(local_voe_)
+      ->GetChannelProxy(new_receiver)
+      ->RegisterLegacyCodecs();
   EXPECT_EQ(0, local_base_->AssociateSendChannel(new_receiver, local_sender_));
 
   EXPECT_EQ(0, local_network_->RegisterExternalTransport(new_receiver, *this));
   // Receive channels have to have the same SSRC in order to send receiver
   // reports with this SSRC.
   EXPECT_EQ(0, local_rtp_rtcp_->SetLocalSSRC(new_receiver, kLocalSsrc));
 
   {
     rtc::CritScope lock(&stream_crit_);
     streams_[remote_ssrc] = std::make_pair(new_sender, new_receiver);
@@ skipping 29 matching lines @@
 bool ConferenceTransport::GetReceiverStatistics(unsigned int id,
                                                 webrtc::CallStatistics* stats) {
   int dst = GetReceiverChannelForSsrc(id);
   if (dst == -1) {
     return false;
   }
   EXPECT_EQ(0, local_rtp_rtcp_->GetRTCPStatistics(dst, *stats));
   return true;
 }
 }  // namespace voetest