Fix Android black frames from MSE config changes.

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 <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 
 #include "base/bind.h"
@@ skipping 85 matching lines @@
 
 scoped_refptr<gfx::SurfaceTexture>
 AndroidDeferredRenderingBackingStrategy::GetSurfaceTexture() const {
   return surface_texture_;
 }
 
 uint32_t AndroidDeferredRenderingBackingStrategy::GetTextureTarget() const {
   return GL_TEXTURE_EXTERNAL_OES;
 }
 
-gpu::gles2::TextureRef*
-AndroidDeferredRenderingBackingStrategy::GetTextureForPicture(
-    const media::PictureBuffer& picture_buffer) {
-  RETURN_NULL_IF_NULL(state_provider_->GetGlDecoder());
-  gpu::gles2::TextureManager* texture_manager =
-      state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
-  RETURN_NULL_IF_NULL(texture_manager);
-  gpu::gles2::TextureRef* texture_ref =
-      texture_manager->GetTexture(picture_buffer.internal_texture_id());
-  RETURN_NULL_IF_NULL(texture_ref);
-
-  return texture_ref;
-}
-
 AVDACodecImage* AndroidDeferredRenderingBackingStrategy::GetImageForPicture(
     const media::PictureBuffer& picture_buffer) {
-  gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
+  gpu::gles2::TextureRef* texture_ref =
+      state_provider_->GetTextureForPicture(picture_buffer);
   RETURN_NULL_IF_NULL(texture_ref);
   gl::GLImage* image =
       texture_ref->texture()->GetLevelImage(GetTextureTarget(), 0);
   return static_cast<AVDACodecImage*>(image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
     const media::PictureBuffer& picture_buffer,
     const scoped_refptr<gpu::gles2::GLStreamTextureImage>& image) {
-  gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
+  gpu::gles2::TextureRef* texture_ref =
+      state_provider_->GetTextureForPicture(picture_buffer);
   RETURN_IF_NULL(texture_ref);
 
   gpu::gles2::TextureManager* texture_manager =
       state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
   RETURN_IF_NULL(texture_manager);
 
   if (image) {
     // Also set the parameters for the level if we're not clearing
     // the image.
     const gfx::Size size = state_provider_->GetSize();
@@ skipping 107 matching lines @@
 void AndroidDeferredRenderingBackingStrategy::OnFrameAvailable() {
   shared_state_->SignalFrameAvailable();
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ArePicturesOverlayable() {
   // SurfaceView frames are always overlayable because that's the only way to
   // display them.
   return !surface_texture_;
 }
 
+void AndroidDeferredRenderingBackingStrategy::UpdatePictureBufferSize(
+    media::PictureBuffer* picture_buffer,
+    const gfx::Size& new_size) {
+  // This strategy uses OES textures which do not have a notion of size. We

[liberato (no reviews please), 2016/03/07 16:39:17]

s/OES/external .  OES is just a prefix that describes who wrote the extension
(khronos group, in this case).

maybe something more like this: "This strategy uses EGL images, so those manage
the texture size for us.  We simply update..."

[chcunningham, 2016/03/08 03:19:36]

Done.

+  // simply update the PictureBuffer meta-data and leave the texture as-is.
+  picture_buffer->set_size(new_size);
+}
+
 void AndroidDeferredRenderingBackingStrategy::CopySurfaceTextureToPictures(
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   DVLOG(3) << __FUNCTION__;
 
   // Don't try to copy if the SurfaceTexture was never attached because that
   // means it was never updated.
   if (!shared_state_->surface_texture_is_attached())
     return;
 
   gpu::gles2::GLES2Decoder* gl_decoder = state_provider_->GetGlDecoder().get();
@@ skipping 37 matching lines @@
 
   glDeleteTextures(1, &tmp_texture_id);
   DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 
   if (egl_image == EGL_NO_IMAGE_KHR) {
     DLOG(ERROR) << "Failed creating EGLImage: " << ui::GetLastEGLErrorString();
     return;
   }
 
   for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
-    gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(entry.second);
+    gpu::gles2::TextureRef* texture_ref =
+        state_provider_->GetTextureForPicture(entry.second);
     gfx::ScopedTextureBinder texture_binder(
         GL_TEXTURE_EXTERNAL_OES, texture_ref->texture()->service_id());
     glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   }
 
   EGLBoolean result =
       eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), egl_image);
   if (result == EGL_FALSE) {
     DLOG(ERROR) << "Error destroying EGLImage: "
                 << ui::GetLastEGLErrorString();
   }
 }
 
 }  // namespace content