VTVDA: Verify |picture_id| in ResusePictureBuffer().

media/gpu/vt_video_decode_accelerator_mac.cc

 // Copyright 2014 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 "media/gpu/vt_video_decode_accelerator_mac.h"
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
@@ skipping 848 matching lines @@
   // Pictures are not marked as uncleared until after this method returns, and
   // they will be broken if they are used before that happens. So, schedule
   // future work after that happens.
   gpu_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VTVideoDecodeAccelerator::ProcessWorkQueues, weak_this_));
 }
 
 void VTVideoDecodeAccelerator::ReusePictureBuffer(int32_t picture_id) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
-  DCHECK(picture_info_map_.count(picture_id));
-  PictureInfo* picture_info = picture_info_map_.find(picture_id)->second.get();
-  picture_info->cv_image.reset();
-  picture_info->gl_image->Destroy(false);

[sandersd (OOO until July 31), 2016/08/12 22:03:19]

ccameron@: Are we relying on this to always happen? My change may remove this
for already-discarded picture buffers. If it does need to run in that case, do
we also need a Destroy()-time loop to do this to the rest?

[sandersd (OOO until July 31), 2016/08/12 22:56:39]

I realized there was a better factoring without this difference, should be
behaviorally identical now.

-  picture_info->gl_image = nullptr;
 
   if (assigned_picture_ids_.count(picture_id) != 0) {
+    auto it = picture_info_map_.find(picture_id);
+    DCHECK_NE(it, picture_info_map_.end());
+    PictureInfo* picture_info = it->second.get();
+    picture_info->cv_image.reset();
+    picture_info->gl_image->Destroy(false);
+    picture_info->gl_image = nullptr;
+
     available_picture_ids_.push_back(picture_id);
     ProcessWorkQueues();
   } else {
     client_->DismissPictureBuffer(picture_id);
   }
 }
 
 void VTVideoDecodeAccelerator::ProcessWorkQueues() {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   switch (state_) {
@@ skipping 131 matching lines @@
 }
 
 bool VTVideoDecodeAccelerator::SendFrame(const Frame& frame) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_DECODING);
 
   if (available_picture_ids_.empty())
     return false;
 
   int32_t picture_id = available_picture_ids_.back();
-  DCHECK(picture_info_map_.count(picture_id));
-  PictureInfo* picture_info = picture_info_map_.find(picture_id)->second.get();
+  auto it = picture_info_map_.find(picture_id);
+  DCHECK_NE(it, picture_info_map_.end());
+  PictureInfo* picture_info = it->second.get();
   DCHECK(!picture_info->cv_image);
   DCHECK(!picture_info->gl_image);
 
   if (!make_context_current_cb_.Run()) {
     DLOG(ERROR) << "Failed to make GL context current";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
   scoped_refptr<gl::GLImageIOSurface> gl_image(
@@ skipping 100 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace media