Remove wrapping in AllocatedDecoder struct

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 56 matching lines @@
       const VideoCodec& codec,
       bool is_conference_mode_screenshare) const = 0;
 
   virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
 
   virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0;
 };
 
 class DecoderFactoryAdapter {
  public:
-  struct AllocatedDecoder {
-    AllocatedDecoder() = default;
-    AllocatedDecoder(std::unique_ptr<webrtc::VideoDecoder> decoder,
-                     bool is_hardware_accelerated);
-
-    std::unique_ptr<webrtc::VideoDecoder> decoder;
-    bool is_hardware_accelerated;
-  };
-
   virtual ~DecoderFactoryAdapter() {}
 
-  virtual AllocatedDecoder CreateVideoDecoder(
+  virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       webrtc::VideoCodecType type,
       const VideoDecoderParams& decoder_params) const = 0;
 
   virtual std::unique_ptr<DecoderFactoryAdapter> clone() const = 0;
 };
 
 namespace {
 
 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
 // interface.
@@ skipping 31 matching lines @@
   explicit CricketDecoderFactoryAdapter(
       WebRtcVideoDecoderFactory* external_decoder_factory)
       : internal_decoder_factory_(new InternalDecoderFactory()),
         external_decoder_factory_(external_decoder_factory) {}
 
  private:
   explicit CricketDecoderFactoryAdapter(
       const CricketDecoderFactoryAdapter& other)
       : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {}
 
-  AllocatedDecoder CreateVideoDecoder(
+  std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
       webrtc::VideoCodecType type,
       const VideoDecoderParams& decoder_params) const override;
 
   std::unique_ptr<DecoderFactoryAdapter> clone() const override {
     return std::unique_ptr<DecoderFactoryAdapter>(
         new CricketDecoderFactoryAdapter(*this));
   }
 
   const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
@@ skipping 1977 matching lines @@
   config_.renderer = this;
   std::map<webrtc::VideoCodecType, std::unique_ptr<webrtc::VideoDecoder>>
       old_decoders;
   ConfigureCodecs(recv_codecs, &old_decoders);
   ConfigureFlexfecCodec(flexfec_config.payload_type);
   MaybeRecreateWebRtcFlexfecStream();
   RecreateWebRtcVideoStream();
   RTC_DCHECK(old_decoders.empty());
 }
 
-DecoderFactoryAdapter::AllocatedDecoder::AllocatedDecoder(
-    std::unique_ptr<webrtc::VideoDecoder> decoder,
-    bool is_hardware_accelerated)
-    : decoder(std::move(decoder)),
-      is_hardware_accelerated(is_hardware_accelerated) {}
-
 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
   if (flexfec_stream_) {
     MaybeDissociateFlexfecFromVideo();
     call_->DestroyFlexfecReceiveStream(flexfec_stream_);
   }
   call_->DestroyVideoReceiveStream(stream_);
   allocated_decoders_.clear();
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const {
   return stream_params_.ssrcs;
 }
 
 rtc::Optional<uint32_t>
 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const {
   std::vector<uint32_t> primary_ssrcs;
   stream_params_.GetPrimarySsrcs(&primary_ssrcs);
 
   if (primary_ssrcs.empty()) {
     LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional";
     return rtc::Optional<uint32_t>();
   } else {
     return rtc::Optional<uint32_t>(primary_ssrcs[0]);
   }
 }
 
-DecoderFactoryAdapter::AllocatedDecoder
+std::unique_ptr<webrtc::VideoDecoder>
 CricketDecoderFactoryAdapter::CreateVideoDecoder(
     webrtc::VideoCodecType type,
     const VideoDecoderParams& decoder_params) const {
   if (external_decoder_factory_ != nullptr) {
     std::unique_ptr<webrtc::VideoDecoder> external_decoder =
         CreateScopedVideoDecoder(external_decoder_factory_, type,
                                  decoder_params);
     if (external_decoder) {
       std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
           new webrtc::VideoDecoderSoftwareFallbackWrapper(
               type, std::move(external_decoder)));
-      return AllocatedDecoder(std::move(internal_decoder),
-                              true /* is_hardware_accelerated */);
+      return internal_decoder;
     }
   }
 
   std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
       internal_decoder_factory_->CreateVideoDecoderWithParams(type,
                                                               decoder_params));
-  return AllocatedDecoder(std::move(internal_decoder),
-                          false /* is_hardware_accelerated */);
+  return internal_decoder;
 }
 
 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
     const std::vector<VideoCodecSettings>& recv_codecs,
     std::map<webrtc::VideoCodecType, std::unique_ptr<webrtc::VideoDecoder>>*
         old_decoders) {
   *old_decoders = std::move(allocated_decoders_);
   allocated_decoders_.clear();
   config_.decoders.clear();
   for (size_t i = 0; i < recv_codecs.size(); ++i) {
     webrtc::VideoCodecType type =
         webrtc::PayloadStringToCodecType(recv_codecs[i].codec.name);
     std::unique_ptr<webrtc::VideoDecoder> new_decoder;
 
     auto it = old_decoders->find(type);
     if (it != old_decoders->end()) {
       new_decoder = std::move(it->second);
       old_decoders->erase(it);
     }
 
     if (!new_decoder) {
-      DecoderFactoryAdapter::AllocatedDecoder new_allocated_decoder =
+      new_decoder =
           decoder_factory_->CreateVideoDecoder(type, {stream_params_.id});
-      new_decoder = std::unique_ptr<webrtc::VideoDecoder>(
-          std::move(new_allocated_decoder.decoder));
-      // TODO(andersc): are we using the is_hardware_accelerated field for
-      // anything?
     }
 
     webrtc::VideoReceiveStream::Decoder decoder;
     decoder.decoder = new_decoder.get();
     decoder.payload_type = recv_codecs[i].codec.id;
     decoder.payload_name = recv_codecs[i].codec.name;
     decoder.codec_params = recv_codecs[i].codec.params;
     config_.decoders.push_back(decoder);
 
     allocated_decoders_.insert(std::make_pair(type, std::move(new_decoder)));
@@ skipping 417 matching lines @@
     stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -
                                                 1);
   }
 
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 }  // namespace cricket