Let VideoEncoderSoftwareFallbackWrapper own the wrapped encoder

webrtc/media/engine/webrtcvideoengine.cc

 /*
  *  Copyright (c) 2014 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 1397 matching lines @@
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings)
     : config(std::move(config)),
       options(options),
       max_bitrate_bps(max_bitrate_bps),
       conference_mode(false),
       codec_settings(codec_settings) {}
 
 WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
     std::unique_ptr<webrtc::VideoEncoder> encoder,
-    std::unique_ptr<webrtc::VideoEncoder> external_encoder,
+    bool is_external,
     const cricket::VideoCodec& codec,
     bool has_internal_source)
     : encoder_(std::move(encoder)),
-      external_encoder_(std::move(external_encoder)),
+      is_external_(is_external),
       codec_(codec),
       has_internal_source_(has_internal_source) {}
 
 void WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::Reset() {
-  external_encoder_.reset();
   encoder_.reset();
   codec_ = cricket::VideoCodec();
 }
 
 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoSendStream::Config config,
     const VideoOptions& options,
     WebRtcVideoEncoderFactory* external_encoder_factory,
@@ skipping 157 matching lines @@
       // If it's a codec type we can simulcast, create a wrapped encoder.
       external_encoder = std::unique_ptr<webrtc::VideoEncoder>(
           new webrtc::SimulcastEncoderAdapter(external_encoder_factory_));
     } else {
       external_encoder =
           CreateScopedVideoEncoder(external_encoder_factory_, codec);
     }
     if (external_encoder) {
       std::unique_ptr<webrtc::VideoEncoder> internal_encoder(
           new webrtc::VideoEncoderSoftwareFallbackWrapper(
-              codec, external_encoder.get()));
+              codec, std::move(external_encoder)));

[andersc, 2017/08/29 07:27:33]

Is it normal to call std::move both here and in the initializer list in
videoencodersoftwarefallbackwrapper.cc? If there is no harm I think it makes it
more readable, but I don't understand exactly what std::move does.

[magjed_webrtc, 2017/08/29 07:56:48]

Yes, it won't compile otherwise. Every time you create std::unique_ptr a from
another std::unique_ptr you need to call std::move, (it makes it a
std::unique_ptr&&). I move it twice actually, once here when moving it into the
argument of the VideoEncoderSoftwareFallbackWrapper ctor, and once when the ctor
moves it into its member variable.

       const webrtc::VideoCodecType codec_type =
           webrtc::PayloadStringToCodecType(codec.name);
       const bool has_internal_source =
           external_encoder_factory_->EncoderTypeHasInternalSource(codec_type);
       return AllocatedEncoder(std::move(internal_encoder),
-                              std::move(external_encoder), codec,
+                              true /* is_external */, codec,
                               has_internal_source);
     }
   }
 
   // Try creating internal encoder.
   std::unique_ptr<webrtc::VideoEncoder> internal_encoder;
   if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) {
     if (CodecNamesEq(codec.name.c_str(), kVp8CodecName) &&
         parameters_.encoder_config.content_type ==
             webrtc::VideoEncoderConfig::ContentType::kScreen &&
         parameters_.conference_mode && UseSimulcastScreenshare()) {
       // TODO(sprang): Remove this adapter once libvpx supports simulcast with
       // same-resolution substreams.
       internal_encoder = std::unique_ptr<webrtc::VideoEncoder>(
           new webrtc::SimulcastEncoderAdapter(internal_encoder_factory_.get()));
     } else {
       internal_encoder = std::unique_ptr<webrtc::VideoEncoder>(
           internal_encoder_factory_->CreateVideoEncoder(codec));
     }
     return AllocatedEncoder(std::move(internal_encoder),
-                            nullptr /* external_encoder */, codec,
+                            false /* is_external */, codec,
                             false /* has_internal_source */);
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
   RTC_NOTREACHED();
   return AllocatedEncoder();
 }
 
 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
@@ skipping 930 matching lines @@
     stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -
                                                 1);
   }
 
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 }  // namespace cricket