Full impl of NnChannel::SetSendParameters and NnChannel::SetRecvParameters

talk/media/base/rtpdataengine_unittest.cc

 /*
  * libjingle
  * Copyright 2012 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 158 matching lines @@
 TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::DataCodec known_codec;
   known_codec.id = 103;
   known_codec.name = "google-data";
   cricket::DataCodec unknown_codec;
   unknown_codec.id = 104;
   unknown_codec.name = "unknown-data";
 
-  std::vector<cricket::DataCodec> known_codecs;
-  known_codecs.push_back(known_codec);
+  cricket::DataSendParameters send_parameters_known;
+  send_parameters_known.codecs.push_back(known_codec);
+  cricket::DataRecvParameters recv_parameters_known;
+  recv_parameters_known.codecs.push_back(known_codec);
 
-  std::vector<cricket::DataCodec> unknown_codecs;
-  unknown_codecs.push_back(unknown_codec);
+  cricket::DataSendParameters send_parameters_unknown;
+  send_parameters_unknown.codecs.push_back(unknown_codec);
+  cricket::DataRecvParameters recv_parameters_unknown;
+  recv_parameters_unknown.codecs.push_back(unknown_codec);
 
-  std::vector<cricket::DataCodec> mixed_codecs;
-  mixed_codecs.push_back(known_codec);
-  mixed_codecs.push_back(unknown_codec);
+  cricket::DataSendParameters send_parameters_mixed;
+  send_parameters_mixed.codecs.push_back(known_codec);
+  send_parameters_mixed.codecs.push_back(unknown_codec);
+  cricket::DataRecvParameters recv_parameters_mixed;
+  recv_parameters_mixed.codecs.push_back(known_codec);
+  recv_parameters_mixed.codecs.push_back(unknown_codec);
 
-  EXPECT_TRUE(dmc->SetSendCodecs(known_codecs));
-  EXPECT_FALSE(dmc->SetSendCodecs(unknown_codecs));
-  EXPECT_TRUE(dmc->SetSendCodecs(mixed_codecs));
-  EXPECT_TRUE(dmc->SetRecvCodecs(known_codecs));
-  EXPECT_FALSE(dmc->SetRecvCodecs(unknown_codecs));
-  EXPECT_FALSE(dmc->SetRecvCodecs(mixed_codecs));
+  EXPECT_TRUE(dmc->SetSendParameters(send_parameters_known));
+  EXPECT_FALSE(dmc->SetSendParameters(send_parameters_unknown));
+  EXPECT_TRUE(dmc->SetSendParameters(send_parameters_mixed));
+  EXPECT_TRUE(dmc->SetRecvParameters(recv_parameters_known));
+  EXPECT_FALSE(dmc->SetRecvParameters(recv_parameters_unknown));
+  EXPECT_FALSE(dmc->SetRecvParameters(recv_parameters_mixed));
 }
 
 TEST_F(RtpDataMediaChannelTest, AddRemoveSendStream) {
   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
   EXPECT_TRUE(dmc->AddSendStream(stream1));
   cricket::StreamParams stream2;
   stream2.add_ssrc(42);
@@ skipping 48 matching lines @@
   ASSERT_TRUE(dmc->AddSendStream(stream));
 
   // Unknown codec;
   EXPECT_FALSE(dmc->SendData(params, payload, &result));
   EXPECT_EQ(cricket::SDR_ERROR, result);
   EXPECT_FALSE(HasSentData(0));
 
   cricket::DataCodec codec;
   codec.id = 103;
   codec.name = cricket::kGoogleRtpDataCodecName;
-  std::vector<cricket::DataCodec> codecs;
-  codecs.push_back(codec);
-  ASSERT_TRUE(dmc->SetSendCodecs(codecs));
+  cricket::DataSendParameters parameters;
+  parameters.codecs.push_back(codec);
+  ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
   // Length too large;
   std::string x10000(10000, 'x');
   EXPECT_FALSE(dmc->SendData(
       params, rtc::Buffer(x10000.data(), x10000.length()), &result));
   EXPECT_EQ(cricket::SDR_ERROR, result);
   EXPECT_FALSE(HasSentData(0));
 
   // Finally works!
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
@@ skipping 41 matching lines @@
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
   ASSERT_TRUE(dmc1->AddSendStream(stream1));
   cricket::StreamParams stream2;
   stream2.add_ssrc(42);
   ASSERT_TRUE(dmc2->AddSendStream(stream2));
 
   cricket::DataCodec codec;
   codec.id = 103;
   codec.name = cricket::kGoogleRtpDataCodecName;
-  std::vector<cricket::DataCodec> codecs;
-  codecs.push_back(codec);
-  ASSERT_TRUE(dmc1->SetSendCodecs(codecs));
-  ASSERT_TRUE(dmc2->SetSendCodecs(codecs));
+  cricket::DataSendParameters parameters;
+  parameters.codecs.push_back(codec);
+  ASSERT_TRUE(dmc1->SetSendParameters(parameters));
+  ASSERT_TRUE(dmc2->SetSendParameters(parameters));
 
   cricket::SendDataParams params1;
   params1.ssrc = 41;
   cricket::SendDataParams params2;
   params2.ssrc = 42;
 
   unsigned char data[] = "foo";
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
 
@@ skipping 23 matching lines @@
 }
 
 TEST_F(RtpDataMediaChannelTest, SendDataRate) {
   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   ASSERT_TRUE(dmc->SetSend(true));
 
   cricket::DataCodec codec;
   codec.id = 103;
   codec.name = cricket::kGoogleRtpDataCodecName;
-  std::vector<cricket::DataCodec> codecs;
-  codecs.push_back(codec);
-  ASSERT_TRUE(dmc->SetSendCodecs(codecs));
+  cricket::DataSendParameters parameters;
+  parameters.codecs.push_back(codec);
+  ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
   cricket::StreamParams stream;
   stream.add_ssrc(42);
   ASSERT_TRUE(dmc->AddSendStream(stream));
 
   cricket::SendDataParams params;
   params.ssrc = 42;
   unsigned char data[] = "food";
   rtc::Buffer payload(data, 4);
   cricket::SendDataResult result;
 
   // With rtp overhead of 32 bytes, each one of our packets is 36
   // bytes, or 288 bits.  So, a limit of 872bps will allow 3 packets,
   // but not four.
-  dmc->SetMaxSendBandwidth(872);
+  parameters.max_bandwidth_bps = 872;
+  ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
   EXPECT_FALSE(dmc->SendData(params, payload, &result));
   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 
   SetNow(0.9);
   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 
@@ skipping 27 matching lines @@
 
   dmc->SetReceive(true);
 
   // Unknown payload id
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   cricket::DataCodec codec;
   codec.id = 103;
   codec.name = cricket::kGoogleRtpDataCodecName;
-  std::vector<cricket::DataCodec> codecs;
-  codecs.push_back(codec);
-  ASSERT_TRUE(dmc->SetRecvCodecs(codecs));
+  cricket::DataRecvParameters parameters;
+  parameters.codecs.push_back(codec);
+  ASSERT_TRUE(dmc->SetRecvParameters(parameters));
 
   // Unknown stream
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   cricket::StreamParams stream;
   stream.add_ssrc(42);
   ASSERT_TRUE(dmc->AddRecvStream(stream));
 
   // Finally works!
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_TRUE(HasReceivedData());
   EXPECT_EQ("abcde", GetReceivedData());
   EXPECT_EQ(5U, GetReceivedDataLen());
 }
 
 TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
   unsigned char data[] = {
     0x80, 0x65, 0x00, 0x02
   };
   rtc::Buffer packet(data, sizeof(data));
 
   rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // Too short
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 }