media: Ensure MediaCodecs are released before attached SurfaceTextures

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 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 "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 219 matching lines @@
       get_gles2_decoder_cb_(get_gles2_decoder_cb),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       picture_buffer_manager_(this),
       media_drm_bridge_cdm_context_(nullptr),
       cdm_registration_id_(0),
       pending_input_buf_index_(-1),
       deferred_initialization_pending_(false),
       codec_needs_reset_(false),
       defer_surface_creation_(false),
+      last_release_task_type_(TaskType::AUTO_CODEC),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_avda_manager.Get().StopTimer(this);
   AVDACodecAllocator::Instance()->StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
@@ skipping 109 matching lines @@
 }
 
 bool AndroidVideoDecodeAccelerator::InitializePictureBufferManager() {
   if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
   codec_config_->surface =
       picture_buffer_manager_.Initialize(config_.surface_id);
+  codec_config_->surface_texture = picture_buffer_manager_.surface_texture();
   if (codec_config_->surface.IsEmpty())
     return false;
 
   if (!AVDACodecAllocator::Instance()->StartThread(this))
     return false;
 
   // If we are encrypted, then we aren't able to create the codec yet.
   if (config_.is_encrypted()) {
     InitializeCdm();
     return true;
@@ skipping 487 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   StartCodecDrain(DRAIN_FOR_FLUSH);
 }
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecAsynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK_NE(state_, WAITING_FOR_CODEC);
   state_ = WAITING_FOR_CODEC;
 
-  if (media_codec_) {
-    AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-        std::move(media_codec_), codec_config_->task_type, config_.surface_id);
-    picture_buffer_manager_.CodecChanged(nullptr);
-  }
+  ReleaseCodec();
 
   base::Optional<TaskType> task_type =
       AVDACodecAllocator::Instance()->TaskTypeForAllocation();
   if (!task_type) {
     // If there is no free thread, then just fail.
     OnCodecConfigured(nullptr);
     return;
   }
 
   // If autodetection is disallowed, fall back to Chrome's software decoders
@@ skipping 244 matching lines @@
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note that async codec construction might still be in progress.  In that
   // case, the codec will be deleted when it completes once we invalidate all
   // our weak refs.
   weak_this_factory_.InvalidateWeakPtrs();
   g_avda_manager.Get().StopTimer(this);
-  if (media_codec_) {
-    AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-        std::move(media_codec_), codec_config_->task_type, config_.surface_id);
-  }
+  ReleaseCodec();
 
   // We no longer care about |surface_id|, in case we did before.  It's okay
   // if we have no surface and/or weren't the owner or a waiter.
   AVDACodecAllocator::Instance()->DeallocateSurface(this, config_.surface_id);
 
+  // Hop the SurfaceTexture release call through the task runner used last time
+  // we released a codec. This ensures that we release the surface texture after
+  // the codec it's attached to (if any) is released. It's not sufficient to use
+  // |codec_config_->task_type| because that might have changed since we
+  // released the codec this surface was attached to.
+  if (codec_config_->surface_texture) {

[watk, 2017/01/17 19:02:48]

This is where surface_texture is used. We store a strong ref to it in the codec
config so that it lives independently of the picture buffer manager, the codec,
and the glimages.

+    AVDACodecAllocator::Instance()
+        ->TaskRunnerFor(last_release_task_type_)
+        ->PostTaskAndReply(
+            FROM_HERE, base::Bind(&base::DoNothing),
+            base::Bind(&gl::SurfaceTexture::ReleaseSurfaceTexture,
+                       codec_config_->surface_texture));
+  }
+
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 const gfx::Size& AndroidVideoDecodeAccelerator::GetSize() const {
@@ skipping 27 matching lines @@
 
     pending_surface_id_ = SurfaceManager::kNoSurfaceID;
     UpdateSurface();
     return;
   }
 
   // If we're currently asynchronously configuring a codec, it will be destroyed
   // when configuration completes and it notices that |state_| has changed to
   // SURFACE_DESTROYED.
   state_ = SURFACE_DESTROYED;
-  if (media_codec_) {
-    AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-        std::move(media_codec_), codec_config_->task_type, config_.surface_id);
-    picture_buffer_manager_.CodecChanged(nullptr);
-  }
+  ReleaseCodec();
 
   // If we're draining, signal completion now because the drain can no longer
   // proceed.
   if (drain_type_)
     OnDrainCompleted();
 }
 
 void AndroidVideoDecodeAccelerator::InitializeCdm() {
   DVLOG(2) << __func__ << ": " << config_.cdm_id;
 
@@ skipping 243 matching lines @@
 
   // Ensure the current context is active when switching surfaces; we may need
   // to create a new texture.
   if (success && !make_context_current_cb_.Run()) {
     NOTIFY_ERROR(PLATFORM_FAILURE,
                  "Failed to make this decoder's GL context current when "
                  "switching surfaces.");
     success = false;
   }
 
+  gl::ScopedJavaSurface new_surface;
   if (success) {
-    codec_config_->surface = picture_buffer_manager_.Initialize(new_surface_id);
-    if (codec_config_->surface.IsEmpty()) {
+    new_surface = picture_buffer_manager_.Initialize(new_surface_id);
+    if (new_surface.IsEmpty()) {
       NOTIFY_ERROR(PLATFORM_FAILURE, "Failed to switch surfaces.");
       success = false;
     }
   }
 
   if (success && media_codec_ &&
-      !media_codec_->SetSurface(codec_config_->surface.j_surface().obj())) {
+      !media_codec_->SetSurface(new_surface.j_surface().obj())) {
     NOTIFY_ERROR(PLATFORM_FAILURE, "MediaCodec failed to switch surfaces.");
     success = false;
   }
 
   if (success) {
     config_.surface_id = new_surface_id;
+    codec_config_->surface = std::move(new_surface);
+    codec_config_->surface_texture = picture_buffer_manager_.surface_texture();
   } else {
     // This might be called from OnSurfaceDestroyed(), so we have to release the
     // MediaCodec if we failed to switch the surface.
-    if (media_codec_) {
-      AVDACodecAllocator::Instance()->ReleaseMediaCodec(
-          std::move(media_codec_), codec_config_->task_type,
-          previous_surface_id);
-      picture_buffer_manager_.CodecChanged(nullptr);
-    }
+    ReleaseCodec();
     AVDACodecAllocator::Instance()->DeallocateSurface(this, new_surface_id);
   }
 
   // Regardless of whether we succeeded, we no longer own the previous surface.
   AVDACodecAllocator::Instance()->DeallocateSurface(this, previous_surface_id);
 
   return success;
 }
 
+void AndroidVideoDecodeAccelerator::ReleaseCodec() {
+  if (!media_codec_)
+    return;
+
+  picture_buffer_manager_.CodecChanged(nullptr);
+  AVDACodecAllocator::Instance()->ReleaseMediaCodec(
+      std::move(media_codec_), codec_config_->task_type, config_.surface_id);
+  last_release_task_type_ = codec_config_->task_type;
+}
+
 }  // namespace media