Clean up ownership of webrtc::VideoEncoder

webrtc/media/engine/simulcast_encoder_adapter.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.
  */
 
 #include "webrtc/media/engine/simulcast_encoder_adapter.h"
 
 #include <algorithm>
 
 // NOTE(ajm): Path provided by gyp.
 #include "libyuv/scale.h"  // NOLINT
 
 #include "webrtc/api/video/i420_buffer.h"
+#include "webrtc/media/engine/scopedvideoencoder.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace {
 
 const unsigned int kDefaultMinQp = 2;
 const unsigned int kDefaultMaxQp = 56;
 // Max qp for lowest spatial resolution when doing simulcast.
@@ skipping 112 matching lines @@
 
 SimulcastEncoderAdapter::~SimulcastEncoderAdapter() {
   RTC_DCHECK(!Initialized());
   DestroyStoredEncoders();
 }
 
 int SimulcastEncoderAdapter::Release() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
 
   while (!streaminfos_.empty()) {
-    VideoEncoder* encoder = streaminfos_.back().encoder;
+    std::unique_ptr<VideoEncoder> encoder =
+        std::move(streaminfos_.back().encoder);
     encoder->Release();
     // Even though it seems very unlikely, there are no guarantees that the
     // encoder will not call back after being Release()'d. Therefore, we disable
     // the callbacks here.
     encoder->RegisterEncodeCompleteCallback(nullptr);
     streaminfos_.pop_back();  // Deletes callback adapter.
-    stored_encoders_.push(encoder);
+    stored_encoders_.push(std::move(encoder));
   }
 
   // It's legal to move the encoder to another queue now.
   encoder_queue_.Detach();
 
   rtc::AtomicOps::ReleaseStore(&inited_, 0);
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
@@ skipping 56 matching lines @@
     stream_codec.VP8()->tl_factory = &tl_factory_adapter;
 
     // TODO(ronghuawu): Remove once this is handled in VP8EncoderImpl.
     if (stream_codec.qpMax < kDefaultMinQp) {
       stream_codec.qpMax = kDefaultMaxQp;
     }
 
     // If an existing encoder instance exists, reuse it.
     // TODO(brandtr): Set initial RTP state (e.g., picture_id/tl0_pic_idx) here,
     // when we start storing that state outside the encoder wrappers.
-    VideoEncoder* encoder;
+    std::unique_ptr<VideoEncoder> encoder;
     if (!stored_encoders_.empty()) {
-      encoder = stored_encoders_.top();
+      encoder = std::move(stored_encoders_.top());
       stored_encoders_.pop();
     } else {
-      encoder = factory_->CreateVideoEncoder(cricket::VideoCodec("VP8"));
+      encoder = CreateScopedVideoEncoder(factory_, cricket::VideoCodec("VP8"));
     }
 
     ret = encoder->InitEncode(&stream_codec, number_of_cores, max_payload_size);
     if (ret < 0) {
       // Explicitly destroy the current encoder; because we haven't registered a
       // StreamInfo for it yet, Release won't do anything about it.
-      factory_->DestroyVideoEncoder(encoder);
+      encoder.reset();
       Release();
       return ret;
     }
     std::unique_ptr<EncodedImageCallback> callback(
         new AdapterEncodedImageCallback(this, i));
     encoder->RegisterEncodeCompleteCallback(callback.get());
-    streaminfos_.emplace_back(encoder, std::move(callback), stream_codec.width,
-                              stream_codec.height, start_bitrate_kbps > 0);
+    streaminfos_.emplace_back(std::move(encoder), std::move(callback),
+                              stream_codec.width, stream_codec.height,
+                              start_bitrate_kbps > 0);
 
     if (i != 0) {
       implementation_name += ", ";
     }
     implementation_name += streaminfos_[i].encoder->ImplementationName();
   }
 
   if (doing_simulcast) {
     implementation_name_ =
         "SimulcastEncoderAdapter (" + implementation_name + ")";
@@ skipping 227 matching lines @@
 
   stream_codec->startBitrate = start_bitrate_kbps;
 }
 
 bool SimulcastEncoderAdapter::Initialized() const {
   return rtc::AtomicOps::AcquireLoad(&inited_) == 1;
 }
 
 void SimulcastEncoderAdapter::DestroyStoredEncoders() {
   while (!stored_encoders_.empty()) {
-    VideoEncoder* encoder = stored_encoders_.top();
-    factory_->DestroyVideoEncoder(encoder);
     stored_encoders_.pop();
   }
 }
 
 bool SimulcastEncoderAdapter::SupportsNativeHandle() const {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
   // We should not be calling this method before streaminfos_ are configured.
   RTC_DCHECK(!streaminfos_.empty());
   for (const auto& streaminfo : streaminfos_) {
     if (!streaminfo.encoder->SupportsNativeHandle()) {
@@ skipping 13 matching lines @@
   }
   return streaminfos_[0].encoder->GetScalingSettings();
 }
 
 const char* SimulcastEncoderAdapter::ImplementationName() const {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
   return implementation_name_.c_str();
 }
 
 }  // namespace webrtc