Mac h264: Work around CGLContext+VTDecompresionSession deadlock

ui/gl/gl_image_io_surface.mm

 // 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 "ui/gl/gl_image_io_surface.h"
 
 #include <map>
 
+#include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
+#include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_helper.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 203 matching lines @@
 }
 
 void GLImageIOSurface::Destroy(bool have_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (have_context && framebuffer_) {
     glDeleteProgram(program_);
     glDeleteShader(vertex_shader_);
     glDeleteShader(fragment_shader_);
     glDeleteBuffersARB(1, &vertex_buffer_);
     glDeleteFramebuffersEXT(1, &framebuffer_);
-    glDeleteTextures(2, yuv_textures_);
   }
   io_surface_.reset();
 }
 
 gfx::Size GLImageIOSurface::GetSize() {
   return size_;
 }
 
 unsigned GLImageIOSurface::GetInternalFormat() {
   return internalformat_;
@@ skipping 34 matching lines @@
 bool GLImageIOSurface::CopyTexImage(unsigned target) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (format_ != BufferFormat::YUV_420_BIPLANAR)
     return false;
   if (target != GL_TEXTURE_RECTANGLE_ARB) {
     LOG(ERROR) << "YUV_420_BIPLANAR requires GL_TEXTURE_RECTANGLE_ARB target";
     return false;
   }
 
+  // Ensure that all textures bound to IOSurfaces be destroyed before the
+  // function exits. If they are not destroyed they may cause deadlocks between
+  // VTDecompressionSession at CGLContextDestroy.
+  // https://crbug.com/598388
+  unsigned y_texture = 0;
+  glGenTextures(1, &y_texture);
+  unsigned uv_texture = 0;
+  glGenTextures(1, &uv_texture);
+  base::ScopedClosureRunner destroy_resources_runner(base::BindBlock(^{
+    glDeleteTextures(1, &y_texture);
+    glDeleteTextures(1, &uv_texture);
+  }));
+
   if (!framebuffer_) {
     glGenFramebuffersEXT(1, &framebuffer_);
     vertex_buffer_ = gfx::GLHelper::SetupQuadVertexBuffer();
     vertex_shader_ = gfx::GLHelper::LoadShader(
         GL_VERTEX_SHADER,
         base::StringPrintf("%s\n%s", kGLSLVersion, kVertexShader).c_str());
     fragment_shader_ = gfx::GLHelper::LoadShader(
         GL_FRAGMENT_SHADER,
         base::StringPrintf("%s\n%s\n%s", kGLSLVersion,
                            kTextureRectangleRequired, kFragmentShader)
             .c_str());
     program_ = gfx::GLHelper::SetupProgram(vertex_shader_, fragment_shader_);
     gfx::ScopedUseProgram use_program(program_);
 
     size_location_ = glGetUniformLocation(program_, "a_texScale");
     DCHECK_NE(-1, size_location_);
     int y_sampler_location = glGetUniformLocation(program_, "a_y_texture");
     DCHECK_NE(-1, y_sampler_location);
     int uv_sampler_location = glGetUniformLocation(program_, "a_uv_texture");
     DCHECK_NE(-1, uv_sampler_location);
 
     glUniform1i(y_sampler_location, 0);
     glUniform1i(uv_sampler_location, 1);
-
-    glGenTextures(2, yuv_textures_);
-    DCHECK(yuv_textures_[0]);
-    DCHECK(yuv_textures_[1]);
   }
 
   CGLContextObj cgl_context =
       static_cast<CGLContextObj>(gfx::GLContext::GetCurrent()->GetHandle());
 
   GLint target_texture = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &target_texture);
   DCHECK(target_texture);
   glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, size_.width(),
                size_.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr);
 
   CGLError cgl_error = kCGLNoError;
   {
     DCHECK(io_surface_);
 
     gfx::ScopedActiveTexture active_texture0(GL_TEXTURE0);
     gfx::ScopedTextureBinder texture_y_binder(GL_TEXTURE_RECTANGLE_ARB,
-                                              yuv_textures_[0]);
+                                              y_texture);
     cgl_error = CGLTexImageIOSurface2D(
         cgl_context, GL_TEXTURE_RECTANGLE_ARB, GL_RED, size_.width(),
         size_.height(), GL_RED, GL_UNSIGNED_BYTE, io_surface_.get(), 0);
     if (cgl_error != kCGLNoError) {
       LOG(ERROR) << "Error in CGLTexImageIOSurface2D for the Y plane. "
                  << cgl_error;
       return false;
     }
     {
       gfx::ScopedActiveTexture active_texture1(GL_TEXTURE1);
       gfx::ScopedTextureBinder texture_uv_binder(GL_TEXTURE_RECTANGLE_ARB,
-                                                 yuv_textures_[1]);
+                                                 uv_texture);
       cgl_error = CGLTexImageIOSurface2D(
           cgl_context, GL_TEXTURE_RECTANGLE_ARB, GL_RG, size_.width() / 2,
           size_.height() / 2, GL_RG, GL_UNSIGNED_BYTE, io_surface_.get(), 1);
       if (cgl_error != kCGLNoError) {
         LOG(ERROR) << "Error in CGLTexImageIOSurface2D for the UV plane. "
                    << cgl_error;
         return false;
       }
 
       gfx::ScopedFrameBufferBinder framebuffer_binder(framebuffer_);
@@ skipping 63 matching lines @@
     g_widget_to_layer_map.Pointer()->erase(widget);
 }
 
 // static
 unsigned GLImageIOSurface::GetInternalFormatForTesting(
     gfx::BufferFormat format) {
   DCHECK(ValidFormat(format));
   return TextureFormat(format);
 }
 }  // namespace gl