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

talk/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 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 604 matching lines @@
   return true;
 }
 
 WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
     const VideoOptions& options,
     VoiceMediaChannel* voice_channel) {
   DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel: "
                << (voice_channel != NULL ? "With" : "Without")
                << " voice channel. Options: " << options.ToString();
-  WebRtcVideoChannel2* channel =
-      new WebRtcVideoChannel2(call_factory_, voice_engine_,
-          static_cast<WebRtcVoiceMediaChannel*>(voice_channel), options,
-          external_encoder_factory_, external_decoder_factory_);
-  if (!channel->Init()) {
-    delete channel;
-    return NULL;
-  }
-  channel->SetRecvCodecs(video_codecs_);
-  return channel;
+  return new WebRtcVideoChannel2(call_factory_, voice_engine_,
+      static_cast<WebRtcVoiceMediaChannel*>(voice_channel), options,
+      video_codecs_, external_encoder_factory_, external_decoder_factory_);
 }
 
 const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
   return video_codecs_;
 }
 
 const std::vector<RtpHeaderExtension>&
 WebRtcVideoEngine2::rtp_header_extensions() const {
   return rtp_header_extensions_;
 }
@@ skipping 140 matching lines @@
     supported_codecs.push_back(codec);
   }
   return supported_codecs;
 }
 
 WebRtcVideoChannel2::WebRtcVideoChannel2(
     WebRtcCallFactory* call_factory,
     WebRtcVoiceEngine* voice_engine,
     WebRtcVoiceMediaChannel* voice_channel,
     const VideoOptions& options,
+    const std::vector<VideoCodec>& recv_codecs,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       voice_channel_(voice_channel),
       voice_channel_id_(voice_channel ? voice_channel->voe_channel() : -1),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetDefaultOptions();
   options_.SetAll(options);
   options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
   webrtc::Call::Config config;
   if (voice_engine != NULL) {
     config.voice_engine = voice_engine->voe()->engine();
   }
   config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
   config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
   config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
   call_.reset(call_factory->CreateCall(config));
   if (voice_channel_) {
     voice_channel_->SetCall(call_.get());
   }
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
+  SetRecvCodecs(recv_codecs);

[pthatcher1, 2015/09/14 19:42:02]

What if SetRecvCodecs fails?

 }
 
 void WebRtcVideoChannel2::SetDefaultOptions() {
   options_.cpu_overuse_detection.Set(true);
   options_.dscp.Set(false);
   options_.suspend_below_min_bitrate.Set(false);
   options_.video_noise_reduction.Set(true);
   options_.screencast_min_bitrate.Set(0);
 }
 
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
   DetachVoiceChannel();
   for (auto& kv : send_streams_)
     delete kv.second;
   for (auto& kv : receive_streams_)
     delete kv.second;
 }
 
-bool WebRtcVideoChannel2::Init() { return true; }
-
 void WebRtcVideoChannel2::DetachVoiceChannel() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (voice_channel_) {
     voice_channel_->SetCall(nullptr);
     voice_channel_ = nullptr;
   }
 }
 
 bool WebRtcVideoChannel2::CodecIsExternallySupported(
     const std::string& name) const {
@@ skipping 85 matching lines @@
       out << ", ";
     }
   }
   out << '}';
   return out.str();
 }
 
 bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
   LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
+  if (codecs.empty()) {
+    return true;
+  }

[pthatcher1, 2015/09/14 19:42:02]

I think this should be handled by the caller of SetRecvCodecs, not inside of
SetRecvCodecs.  Same with SetSendCodecs.

[the sun, 2015/09/14 19:58:00]

I was wondering about wether it should be at all legal to give an empty list of
codecs to Set[Send|Recv]Parameters(). Before this CL, none of the other state
will be changed if setting codecs fail, which it will in case of an empty list.

This was only changed once tests relied on it (the ones that do nothing but
SetOptions, etc). Another option would be to always set up a default codec in
the tests.

WDYT?

[pthatcher1, 2015/09/16 03:45:30]

I think leaving this here as-is just for unit tests is too risky.  I think we
have two options:

A.  The new contract is "you have to provide everything at once, including at
least one codec", then tests need to provide at least one codec.  

B.  The new contract is "you have to provide everything at once, but if there
are no codecs, we won't send anything".  

I could see a case for either.  I'm guessing it's easiest right now to do A and
update the tests to have at least one codec.

   if (!ValidateCodecFormats(codecs)) {
     return false;
   }
 
   const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
   if (mapped_codecs.empty()) {
     LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
     return false;
   }
 
@@ skipping 24 matching lines @@
        ++it) {
     it->second->SetRecvCodecs(recv_codecs_);
   }
 
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendCodecs");
   LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
+  if (codecs.empty()) {
+    return true;
+  }
   if (!ValidateCodecFormats(codecs)) {
     return false;
   }
 
   const std::vector<VideoCodecSettings> supported_codecs =
       FilterSupportedCodecs(MapCodecs(codecs));
 
   if (supported_codecs.empty()) {
     LOG(LS_ERROR) << "No video codecs supported.";
     return false;
@@ skipping 1789 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO