Add _decoder CHECK to VCMGenericDecoder constructor.

webrtc/modules/video_coding/codec_database.cc

 /*
  *  Copyright (c) 2012 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 405 matching lines @@
 bool VCMCodecDataBase::DeregisterExternalDecoder(uint8_t payload_type) {
   ExternalDecoderMap::iterator it = dec_external_map_.find(payload_type);
   if (it == dec_external_map_.end()) {
     // Not found
     return false;
   }
   // We can't use payload_type to check if the decoder is currently in use,
   // because payload type may be out of date (e.g. before we decode the first
   // frame after RegisterReceiveCodec)
   if (ptr_decoder_ != nullptr &&
-      &ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
+      ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
     // Release it if it was registered and in use.
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = nullptr;
   }
   DeregisterReceiveCodec(payload_type);
   delete (*it).second;
   dec_external_map_.erase(it);
   return true;
 }
 
@@ skipping 127 matching lines @@
     LOG(LS_ERROR) << "Can't find a decoder associated with payload type: "
                   << static_cast<int>(payload_type);
     return nullptr;
   }
   VCMGenericDecoder* ptr_decoder = nullptr;
   const VCMExtDecoderMapItem* external_dec_item =
       FindExternalDecoderItem(payload_type);
   if (external_dec_item) {
     // External codec.
     ptr_decoder = new VCMGenericDecoder(
-        *external_dec_item->external_decoder_instance, true);
+        external_dec_item->external_decoder_instance, true);
   } else {
     // Create decoder.
     ptr_decoder = CreateDecoder(decoder_item->settings->codecType);
   }
   if (!ptr_decoder)
     return nullptr;
 
   // Copy over input resolutions to prevent codec reinitialization due to
   // the first frame being of a different resolution than the database values.
   // This is best effort, since there's no guarantee that width/height have been
@@ skipping 15 matching lines @@
 void VCMCodecDataBase::DeleteEncoder() {
   if (!ptr_encoder_)
     return;
   ptr_encoder_->Release();
   ptr_encoder_.reset();
 }
 
 VCMGenericDecoder* VCMCodecDataBase::CreateDecoder(VideoCodecType type) const {
   switch (type) {
     case kVideoCodecVP8:
-      return new VCMGenericDecoder(*(VP8Decoder::Create()));
+      return new VCMGenericDecoder(VP8Decoder::Create(), false);
     case kVideoCodecVP9:
-      return new VCMGenericDecoder(*(VP9Decoder::Create()));
+      return new VCMGenericDecoder(VP9Decoder::Create(), false);
     case kVideoCodecI420:
-      return new VCMGenericDecoder(*(new I420Decoder));
+      return new VCMGenericDecoder(new I420Decoder(), false);
     case kVideoCodecH264:
       if (H264Decoder::IsSupported()) {
-        return new VCMGenericDecoder(*(H264Decoder::Create()));
+        return new VCMGenericDecoder(H264Decoder::Create(), false);
       }
       break;
     default:
       break;
   }
   LOG(LS_WARNING) << "No internal decoder of this type exists.";
   return nullptr;
 }
 
 const VCMDecoderMapItem* VCMCodecDataBase::FindDecoderItem(
     uint8_t payload_type) const {
   DecoderMap::const_iterator it = dec_map_.find(payload_type);
   if (it != dec_map_.end()) {
     return (*it).second;
   }
   return nullptr;
 }
 
 const VCMExtDecoderMapItem* VCMCodecDataBase::FindExternalDecoderItem(
     uint8_t payload_type) const {
   ExternalDecoderMap::const_iterator it = dec_external_map_.find(payload_type);
   if (it != dec_external_map_.end()) {
     return (*it).second;
   }
   return nullptr;
 }
 }  // namespace webrtc