Support for two audio codec lists down into WebRtcVoiceEngine.

webrtc/pc/mediasession_unittest.cc

 /*
  *  Copyright 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.
  */
 
@@ skipping 456 matching lines @@
       f1_.CreateOffer(MediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc == NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
-  EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+  EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
 }
 
 // Create a typical video offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
   MediaSessionOptions opts;
   opts.recv_video = true;
   f1_.set_secure(SEC_ENABLED);
   std::unique_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
   const ContentInfo* vc = offer->GetContentByName("video");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), vc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
-  EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+  EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
   EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
   EXPECT_NE(0U, vcd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, vcd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(vcd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(vcd, 1U, CS_AES_CM_128_HMAC_SHA1_80);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), vcd->protocol());
 }
 
 // Test creating an offer with bundle where the Codecs have the same dynamic
 // RTP playlod type. The test verifies that the offer don't contain the
 // duplicate RTP payload types.
 TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
   const VideoCodec& offered_video_codec = f2_.video_codecs()[0];
-  const AudioCodec& offered_audio_codec = f2_.audio_codecs()[0];
+  const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
   const DataCodec& offered_data_codec = f2_.data_codecs()[0];
   ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
   ASSERT_EQ(offered_video_codec.id, offered_data_codec.id);
 
   MediaSessionOptions opts;
   opts.recv_audio = true;
   opts.recv_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
   opts.bundle_enabled = true;
   std::unique_ptr<SessionDescription> offer(f2_.CreateOffer(opts, NULL));
@@ skipping 66 matching lines @@
   const ContentInfo* dc = offer->GetContentByName("data");
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(dc != NULL);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), ac->type);
   EXPECT_EQ(std::string(NS_JINGLE_RTP), dc->type);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
-  EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+  EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
   EXPECT_NE(0U, acd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(kAutoBandwidth, acd->bandwidth());  // default bandwidth (auto)
   EXPECT_TRUE(acd->rtcp_mux());                 // rtcp-mux defaults on
   ASSERT_CRYPTO(acd, 2U, CS_AES_CM_128_HMAC_SHA1_32);
   EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf), acd->protocol());
   EXPECT_EQ(MEDIA_TYPE_DATA, dcd->type());
   EXPECT_EQ(f1_.data_codecs(), dcd->codecs());
   EXPECT_NE(0U, dcd->first_ssrc());             // a random nonzero ssrc
   EXPECT_EQ(cricket::kDataMaxBandwidth,
             dcd->bandwidth());                  // default bandwidth (auto)
@@ skipping 594 matching lines @@
   ASSERT_TRUE(ac != NULL);
   ASSERT_TRUE(vc != NULL);
   ASSERT_TRUE(dc != NULL);
   const AudioContentDescription* acd =
       static_cast<const AudioContentDescription*>(ac->description);
   const VideoContentDescription* vcd =
       static_cast<const VideoContentDescription*>(vc->description);
   const DataContentDescription* dcd =
       static_cast<const DataContentDescription*>(dc->description);
   EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
-  EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
+  EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
 
   const StreamParamsVec& audio_streams = acd->streams();
   ASSERT_EQ(2U, audio_streams.size());
   EXPECT_EQ(audio_streams[0].cname , audio_streams[1].cname);
   EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
   ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
   EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
   EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
   ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
   EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
@@ skipping 1247 matching lines @@
   send_codecs[1].channels = 0;
 
   // Alther iLBC receive codec to be lowercase, to test that case conversions
   // are handled properly.
   recv_codecs[2].name = "ilbc";
 
   // Test proper merge
   sf.set_audio_codecs(send_codecs, recv_codecs);
   EXPECT_TRUE(sf.audio_send_codecs() == send_codecs);
   EXPECT_TRUE(sf.audio_recv_codecs() == recv_codecs);
-  EXPECT_TRUE(sf.audio_codecs() == sendrecv_codecs);
+  EXPECT_TRUE(sf.audio_sendrecv_codecs() == sendrecv_codecs);
 
   // Test empty send codecs list
   sf.set_audio_codecs(no_codecs, recv_codecs);
   EXPECT_TRUE(sf.audio_send_codecs() == no_codecs);
   EXPECT_TRUE(sf.audio_recv_codecs() == recv_codecs);
-  EXPECT_TRUE(sf.audio_codecs() == no_codecs);
+  EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
 
   // Test empty recv codecs list
   sf.set_audio_codecs(send_codecs, no_codecs);
   EXPECT_TRUE(sf.audio_send_codecs() == send_codecs);
   EXPECT_TRUE(sf.audio_recv_codecs() == no_codecs);
-  EXPECT_TRUE(sf.audio_codecs() == no_codecs);
+  EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
 
   // Test all empty codec lists
   sf.set_audio_codecs(no_codecs, no_codecs);
   EXPECT_TRUE(sf.audio_send_codecs() == no_codecs);
   EXPECT_TRUE(sf.audio_recv_codecs() == no_codecs);
-  EXPECT_TRUE(sf.audio_codecs() == no_codecs);
+  EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
 }
 
 namespace {
 void TestAudioCodecsOffer(MediaContentDirection direction,
                           bool add_legacy_stream) {
   TransportDescriptionFactory tdf;
   MediaSessionDescriptionFactory sf(&tdf);
   const std::vector<AudioCodec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
   const std::vector<AudioCodec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
   const std::vector<AudioCodec> sendrecv_codecs =
@@ skipping 230 matching lines @@
                         ::testing::Combine(
                              ::testing::Values(cricket::MD_SENDONLY,
                                                cricket::MD_RECVONLY,
                                                cricket::MD_SENDRECV,
                                                cricket::MD_INACTIVE),
                              ::testing::Values(cricket::MD_SENDONLY,
                                                cricket::MD_RECVONLY,
                                                cricket::MD_SENDRECV,
                                                cricket::MD_INACTIVE),
                              ::testing::Bool()));