Verify returned frames from media::VideoFrame::Wrap*() methods

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
@@ skipping 352 matching lines @@
   const media::PictureBuffer& pb = it->second;
   if (visible_rect.IsEmpty() || !gfx::Rect(pb.size()).Contains(visible_rect)) {
     LOG(ERROR) << "Invalid picture size: " << visible_rect.ToString()
                << " should fit in " << pb.size().ToString();
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 
   scoped_refptr<media::VideoFrame> frame =
       CreateVideoFrame(picture, pb, timestamp, visible_rect);
+  if (!frame) {
+    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
   bool inserted =
       picture_buffers_at_display_.insert(std::make_pair(
                                              picture.picture_buffer_id(),
                                              pb.texture_id())).second;
   DCHECK(inserted);
 
   // Create a WebRTC video frame.
   webrtc::VideoFrame decoded_image(
       new rtc::RefCountedObject<WebRtcVideoFrameAdapter>(frame), timestamp, 0,
       webrtc::kVideoRotation_0);
@@ skipping 15 matching lines @@
     uint32_t timestamp,
     const gfx::Rect& visible_rect) {
   DCHECK(decoder_texture_target_);
   // Convert timestamp from 90KHz to ms.
   base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
       base::checked_cast<uint64_t>(timestamp) * 1000 / 90);
   // TODO(mcasas): The incoming data is actually a YUV format, but is labelled
   // as ARGB. This prevents the compositor from messing with it, since the
   // underlying platform can handle the former format natively. Make sure the
   // correct format is used and everyone down the line understands it.
-  scoped_refptr<media::VideoFrame> frame(media::VideoFrame::WrapNativeTexture(
+  scoped_refptr<media::VideoFrame> frame = media::VideoFrame::WrapNativeTexture(
       media::PIXEL_FORMAT_ARGB,
       gpu::MailboxHolder(pb.texture_mailbox(), gpu::SyncToken(),
                          decoder_texture_target_),
       media::BindToCurrentLoop(base::Bind(
           &RTCVideoDecoder::ReleaseMailbox, weak_factory_.GetWeakPtr(),
           factories_, picture.picture_buffer_id(), pb.texture_id())),
-      pb.size(), visible_rect, visible_rect.size(), timestamp_ms));
-  if (picture.allow_overlay()) {
+      pb.size(), visible_rect, visible_rect.size(), timestamp_ms);
+  if (frame && picture.allow_overlay()) {
     frame->metadata()->SetBoolean(media::VideoFrameMetadata::ALLOW_OVERLAY,
                                   true);
   }
   return frame;
 }
 
 void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
@@ skipping 378 matching lines @@
 }
 
 void RTCVideoDecoder::ClearPendingBuffers() {
   // Delete WebRTC input buffers.
   for (const auto& pending_buffer : pending_buffers_)
     delete[] pending_buffer.first._buffer;
   pending_buffers_.clear();
 }
 
 }  // namespace content