Clean up ownership of webrtc::VideoEncoder

webrtc/media/engine/webrtcvideoengine.h

 /*
  *  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 104 matching lines @@
   // not take the ownership of |encoder_factory|. The caller needs to make sure
   // that |encoder_factory| outlives the video engine.
   virtual void SetExternalEncoderFactory(
       WebRtcVideoEncoderFactory* encoder_factory);
 
  private:
   bool initialized_;
 
   WebRtcVideoDecoderFactory* external_decoder_factory_;
   WebRtcVideoEncoderFactory* external_encoder_factory_;
-  std::unique_ptr<WebRtcVideoEncoderFactory> simulcast_encoder_factory_;
 };
 
 class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
  public:
   WebRtcVideoChannel(webrtc::Call* call,
                      const MediaConfig& config,
                      const VideoOptions& options,
                      WebRtcVideoEncoderFactory* external_encoder_factory,
                      WebRtcVideoDecoderFactory* external_decoder_factory);
   ~WebRtcVideoChannel() override;
@@ skipping 168 matching lines @@
       VideoOptions options;
       int max_bitrate_bps;
       bool conference_mode;
       rtc::Optional<VideoCodecSettings> codec_settings;
       // Sent resolutions + bitrates etc. by the underlying VideoSendStream,
       // typically changes when setting a new resolution or reconfiguring
       // bitrates.
       webrtc::VideoEncoderConfig encoder_config;
     };
 
-    struct AllocatedEncoder {
-      AllocatedEncoder(webrtc::VideoEncoder* encoder,
+    class AllocatedEncoder {
+     public:
+      AllocatedEncoder() = default;
+      AllocatedEncoder(AllocatedEncoder&&) = default;
+      AllocatedEncoder& operator=(AllocatedEncoder&&) = default;
+
+      AllocatedEncoder(std::unique_ptr<webrtc::VideoEncoder> encoder,
+                       std::unique_ptr<webrtc::VideoEncoder> external_encoder,
                        const cricket::VideoCodec& codec,
-                       bool external);
-      webrtc::VideoEncoder* encoder;
-      webrtc::VideoEncoder* external_encoder;
-      cricket::VideoCodec codec;
-      bool external;
+                       bool has_internal_source);
+
+      // Returns a raw pointer to the allocated encoder. This object still has
+      // ownership of the encoder and is responsible for deleting it.
+      webrtc::VideoEncoder* encoder() { return encoder_.get(); }
+
+      // Returns true if the encoder is external.
+      bool IsExternal() { return static_cast<bool>(external_encoder_); }
+
+      cricket::VideoCodec codec() { return codec_; }
+
+      bool HasInternalSource() { return has_internal_source_; }
+
+      // Release the encoders this object manages.
+      void Reset();
+
+     private:
+      std::unique_ptr<webrtc::VideoEncoder> encoder_;
+      // TODO(magjed): |external_encoder_| is not used except for managing
+      // the lifetime when we use VideoEncoderSoftwareFallbackWrapper. Let
+      // VideoEncoderSoftwareFallbackWrapper own the external encoder instead
+      // and remove this member variable.
+      std::unique_ptr<webrtc::VideoEncoder> external_encoder_;
+      cricket::VideoCodec codec_;
+      bool has_internal_source_;
     };
 
     rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
     ConfigureVideoEncoderSettings(const VideoCodec& codec);
-    // If force_encoder_allocation is true, a new AllocatedEncoder is always
-    // created. If false, the allocated encoder may be reused, if the type
-    // matches.
-    AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec,
-                                        bool force_encoder_allocation);
-    void DestroyVideoEncoder(AllocatedEncoder* encoder);
+    // Creates and returns a new AllocatedEncoder of the specified codec type.
+    AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec);
     void SetCodec(const VideoCodecSettings& codec,
                   bool force_encoder_allocation);
     void RecreateWebRtcStream();
     webrtc::VideoEncoderConfig CreateVideoEncoderConfig(
         const VideoCodec& codec) const;
     void ReconfigureEncoder();
     bool ValidateRtpParameters(const webrtc::RtpParameters& parameters);
 
     // Calls Start or Stop according to whether or not |sending_| is true,
     // and whether or not the encoding in |rtp_parameters_| is active.
@@ skipping 204 matching lines @@
   const std::string codec_name_;
   const int max_qp_;
   const int max_framerate_;
   const bool is_screencast_;
   const bool conference_mode_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE_H_