Delay actual flush and reset in AVDA

content/common/gpu/media/android_deferred_rendering_backing_strategy.cc

 // Copyright 2015 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/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
@@ skipping 61 matching lines @@
 
 void AndroidDeferredRenderingBackingStrategy::Cleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // If we failed before Initialize, then do nothing.
   if (!shared_state_)
     return;
 
   // Make sure that no PictureBuffer textures refer to the SurfaceTexture or to
   // the service_id that we created for it.
-  for (const std::pair<int, media::PictureBuffer>& entry : buffers)
+  for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
+    ReleaseCodecBufferForPicture(entry.second);
     SetImageForPicture(entry.second, nullptr);
+  }
 
   // If we're rendering to a SurfaceTexture we can make a copy of the current
   // front buffer so that the PictureBuffer textures are still valid.
   if (surface_texture_ && have_context && ShouldCopyPictures())
     CopySurfaceTextureToPictures(buffers);
 
   // Now that no AVDACodecImages refer to the SurfaceTexture's texture, delete
   // the texture name.
   GLuint service_id = shared_state_->surface_texture_service_id();
   if (service_id > 0 && have_context)
@@ skipping 123 matching lines @@
     glBindTexture(GL_TEXTURE_2D, picture_buffer.texture_ids()[0]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, rgba);
   }
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBufferForPicture(
     const media::PictureBuffer& picture_buffer) {
   AVDACodecImage* avda_image = GetImageForPicture(picture_buffer);
 
+  if (!avda_image)
+    return;
+
   // See if there is a media codec buffer still attached to this image.
   const int32_t codec_buffer = avda_image->GetMediaCodecBufferIndex();
 
   if (codec_buffer >= 0) {
     // PictureBuffer wasn't displayed, so release the buffer.
     media_codec_->ReleaseOutputBuffer(codec_buffer, false);
     avda_image->SetMediaCodecBufferIndex(-1);
   }
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReuseOnePictureBuffer(
     const media::PictureBuffer& picture_buffer) {
   // At this point, the CC must be done with the picture.  We can't really
   // check for that here directly.  it's guaranteed in gpu_video_decoder.cc,
   // when it waits on the sync point before releasing the mailbox.  That sync
   // point is inserted by destroying the resource in VideoLayerImpl::DidDraw.
   ReleaseCodecBufferForPicture(picture_buffer);
 }
 
+void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBuffers(
+    const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
+  for (const std::pair<int, media::PictureBuffer>& entry : buffers)
+    ReleaseCodecBufferForPicture(entry.second);
+}
+
 void AndroidDeferredRenderingBackingStrategy::CodecChanged(
     media::VideoCodecBridge* codec,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // Clear any outstanding codec buffer indices, since the new codec (if any)
   // doesn't know about them.
   media_codec_ = codec;
   for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
     AVDACodecImage* avda_image = GetImageForPicture(entry.second);
     avda_image->SetMediaCodec(codec);
     avda_image->SetMediaCodecBufferIndex(-1);
@@ skipping 141 matching lines @@
           return !feature_info->workarounds().avda_dont_copy_pictures;
       }
     }
   }
 
   // Assume so.
   return true;
 }
 
 }  // namespace content