AVDACodecImages keep a reference to the SurfaceTexture backing them

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_surface_lookup.h"
 #include "content/common/gpu/media/avda_codec_image.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
 #include "content/common/gpu/media/avda_shared_state.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace content {
 
 AndroidDeferredRenderingBackingStrategy::
     AndroidDeferredRenderingBackingStrategy(AVDAStateProvider* state_provider)
-    : state_provider_(state_provider), media_codec_(nullptr) {}
+    : shared_state_(new AVDASharedState),
+      state_provider_(state_provider),
+      media_codec_(nullptr) {}
 
 AndroidDeferredRenderingBackingStrategy::
     ~AndroidDeferredRenderingBackingStrategy() {}
 
 gfx::ScopedJavaSurface AndroidDeferredRenderingBackingStrategy::Initialize(
     int surface_view_id) {
-  shared_state_ = new AVDASharedState();
-
   gfx::ScopedJavaSurface surface;
   if (surface_view_id != media::VideoDecodeAccelerator::Config::kNoSurfaceID) {
     surface =
         GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(surface_view_id);
   } else {
     // Create a detached SurfaceTexture. Detaching it will silently fail to
     // delete texture 0.
     surface_texture_ = gfx::SurfaceTexture::Create(0);
     surface_texture_->DetachFromGLContext();
     surface = gfx::ScopedJavaSurface(surface_texture_.get());
+    shared_state_->set_surface_texture(surface_texture_);
   }
 
   // Create a texture for the SurfaceTexture to use.  We don't attach it here
   // so that it gets attached in the compositor gl context in the common case.
   GLuint service_id = 0;
   glGenTextures(1, &service_id);
   DCHECK(service_id);
   shared_state_->set_surface_texture_service_id(service_id);
 
   return surface;
 }
 
 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)
-    SetImageForPicture(entry.second, nullptr);

[liberato (no reviews please), 2016/02/10 06:39:12]

it's late, and i might very well be missing it, but i don't see how this happens
in this CL.  it has to happen before the glDeleteTextures for the surface
texture service_id.

otherwise, there could be Texture objects that still refer to that service id
after it's deleted.  removing the codec image itself isn't needed, but calling
SetUnownedServiceId(0) on all the picture buffer textures is.

-
-  // 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)
-    glDeleteTextures(1, &service_id);
+  CodecChanged(nullptr, buffers);
 }
 
 scoped_refptr<gfx::SurfaceTexture>
 AndroidDeferredRenderingBackingStrategy::GetSurfaceTexture() const {
   return surface_texture_;
 }
 
 uint32_t AndroidDeferredRenderingBackingStrategy::GetTextureTarget() const {
   return GL_TEXTURE_EXTERNAL_OES;
 }
@@ skipping 146 matching lines @@
   shared_state_->SignalFrameAvailable();
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ArePicturesOverlayable() {
   // SurfaceView frames are always overlayable because that's the only way to
   // display them.
   return !surface_texture_;
 }
 
 }  // namespace content