media: Ensure MediaCodecs are released before attached SurfaceTextures

media/gpu/avda_codec_allocator.cc

 // Copyright 2016 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/avda_codec_allocator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 131 matching lines @@
 bool AVDACodecAllocator::AllocateSurface(AVDACodecAllocatorClient* client,
                                          int surface_id) {
   DVLOG(1) << __func__ << ": " << surface_id;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (surface_id == SurfaceManager::kNoSurfaceID)
     return true;
 
   // If it's not owned or being released, |client| now owns it.
   if (!surface_owners_.count(surface_id) &&
-      !pending_codec_releases_.count(surface_id)) {
+      !surface_view_codec_releases_.count(surface_id)) {
     surface_owners_[surface_id].owner = client;
     return true;
   }
 
   // Otherwise |client| replaces the previous waiter (if any).
   OwnerRecord& record = surface_owners_[surface_id];
   if (record.waiter)
     record.waiter->OnSurfaceAvailable(false);
   record.waiter = client;
   return false;
 }
 
 void AVDACodecAllocator::DeallocateSurface(AVDACodecAllocatorClient* client,
                                            int surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (surface_id == SurfaceManager::kNoSurfaceID ||
       !surface_owners_.count(surface_id)) {
     return;
   }
 
   OwnerRecord& record = surface_owners_[surface_id];
   if (record.owner == client)
     record.owner = nullptr;
   else if (record.waiter == client)
     record.waiter = nullptr;
 
   // Promote the waiter if possible.
   if (record.waiter && !record.owner &&
-      !pending_codec_releases_.count(surface_id)) {
+      !surface_view_codec_releases_.count(surface_id)) {
     record.owner = record.waiter;
     record.waiter = nullptr;
     record.owner->OnSurfaceAvailable(true);
     return;
   }
 
   // Remove the record if it's now unused.
   if (!record.owner && !record.waiter)
     surface_owners_.erase(surface_id);
 }
@@ skipping 22 matching lines @@
     }
 
     if (record.owner)
       record.owner->OnSurfaceDestroyed();
 
     surface_owners_.erase(surface_id);
   }
 
   // The codec might have been released above in OnSurfaceDestroyed(), or was
   // already pending release.
-  if (!pending_codec_releases_.count(surface_id))
+  if (!surface_view_codec_releases_.count(surface_id))
     return;
 
   // The codec is being released so we have to wait for it here. It's a
   // TimedWait() because the MediaCodec release may hang due to framework bugs.
   // And in that case we don't want to hang the browser UI thread. Android ANRs
   // occur when the UI thread is blocked for 5 seconds, so waiting for 2 seconds
   // gives us leeway to avoid an ANR. Verified no ANR on a Nexus 7.
   base::WaitableEvent& released =
-      pending_codec_releases_.find(surface_id)->second;
+      surface_view_codec_releases_.find(surface_id)->second;
   released.TimedWait(base::TimeDelta::FromSeconds(2));
   if (!released.IsSignaled())
     DLOG(WARNING) << __func__ << ": timed out waiting for MediaCodec#release()";
 }
 
 std::unique_ptr<VideoCodecBridge> AVDACodecAllocator::CreateMediaCodecSync(
     scoped_refptr<CodecConfig> codec_config) {
   TRACE_EVENT0("media", "AVDA::CreateMediaCodecSync");
 
   jobject media_crypto =
@@ skipping 18 matching lines @@
   base::PostTaskAndReplyWithResult(
       TaskRunnerFor(codec_config->task_type).get(), FROM_HERE,
       base::Bind(&AVDACodecAllocator::CreateMediaCodecSync,
                  base::Unretained(this), codec_config),
       base::Bind(&AVDACodecAllocatorClient::OnCodecConfigured, client));
 }
 
 void AVDACodecAllocator::ReleaseMediaCodec(
     std::unique_ptr<VideoCodecBridge> media_codec,
     TaskType task_type,
-    int surface_id) {
+    int surface_id,
+    gl::SurfaceTexture* surface_texture) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(media_codec);
+  DCHECK(surface_id != SurfaceManager::kNoSurfaceID || surface_texture);
 
-  // No need to track the release if it's a SurfaceTexture.
-  if (surface_id == SurfaceManager::kNoSurfaceID) {
-    TaskRunnerFor(task_type)->PostTask(
-        FROM_HERE, base::Bind(&DeleteMediaCodecAndSignal,
-                              base::Passed(std::move(media_codec)), nullptr));
+  base::WaitableEvent* released_event = nullptr;
+  if (surface_texture) {
+    surface_texture_codec_releases_[surface_texture] = task_type;
+  } else {
+    surface_view_codec_releases_.emplace(
+        std::piecewise_construct, std::forward_as_tuple(surface_id),
+        std::forward_as_tuple(base::WaitableEvent::ResetPolicy::MANUAL,
+                              base::WaitableEvent::InitialState::NOT_SIGNALED));
+    released_event = &surface_view_codec_releases_.find(surface_id)->second;
+  }
+
+  TaskRunnerFor(task_type)->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&DeleteMediaCodecAndSignal,
+                 base::Passed(std::move(media_codec)), released_event),
+      base::Bind(&AVDACodecAllocator::OnMediaCodecReleased,
+                 base::Unretained(this), surface_id,
+                 base::Unretained(surface_texture)));
+}
+
+void AVDACodecAllocator::OnMediaCodecReleased(
+    int surface_id,
+    gl::SurfaceTexture* surface_texture) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (surface_texture) {
+    surface_texture_codec_releases_.erase(surface_texture);
+  } else {
+    surface_view_codec_releases_.erase(surface_id);
+    if (!surface_owners_.count(surface_id))

[liberato (no reviews please), 2017/01/13 17:22:04]

might want to use find rather than count + [] later to save the lookup.

+      return;
+
+    OwnerRecord& record = surface_owners_[surface_id];
+    if (!record.owner && record.waiter) {
+      record.owner = record.waiter;
+      record.waiter = nullptr;
+      record.owner->OnSurfaceAvailable(true);
+    }
+  }
+}
+
+void AVDACodecAllocator::ReleaseSurfaceTexture(
+    scoped_refptr<gl::SurfaceTexture> surface_texture) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If this SurfaceTexture is attached to a codec that's currently being
+  // released, defer the surface release until after the codec is released.
+  if (surface_texture_codec_releases_.count(surface_texture.get())) {

[liberato (no reviews please), 2017/01/13 17:22:04]

ditto find().

also might want to invert this to if(iter == end) { l#334, 335 return}
just to save the indentation.

+    TaskType task_type = surface_texture_codec_releases_[surface_texture.get()];
+    TaskRunnerFor(task_type)->PostTaskAndReply(
+        FROM_HERE, base::Bind(&base::DoNothing),
+        base::Bind(&gl::SurfaceTexture::ReleaseSurfaceTexture,
+                   surface_texture));
     return;
   }
 
-  pending_codec_releases_.emplace(
-      std::piecewise_construct, std::forward_as_tuple(surface_id),
-      std::forward_as_tuple(base::WaitableEvent::ResetPolicy::MANUAL,
-                            base::WaitableEvent::InitialState::NOT_SIGNALED));
-  base::WaitableEvent* released =
-      &pending_codec_releases_.find(surface_id)->second;
-
-  TaskRunnerFor(task_type)->PostTaskAndReply(
-      FROM_HERE, base::Bind(&DeleteMediaCodecAndSignal,
-                            base::Passed(std::move(media_codec)), released),
-      base::Bind(&AVDACodecAllocator::OnMediaCodecAndSurfaceReleased,
-                 base::Unretained(this), surface_id));
-}
-
-void AVDACodecAllocator::OnMediaCodecAndSurfaceReleased(int surface_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  pending_codec_releases_.erase(surface_id);
-  if (!surface_owners_.count(surface_id))
-    return;
-
-  OwnerRecord& record = surface_owners_[surface_id];
-  if (!record.owner && record.waiter) {
-    record.owner = record.waiter;
-    record.waiter = nullptr;
-    record.owner->OnSurfaceAvailable(true);
-  }
+  // Otherwise we can release immediately.
+  surface_texture->ReleaseSurfaceTexture();
 }
 
 // Returns a hint about whether the construction thread has hung for
 // |task_type|.  Note that if a thread isn't started, then we'll just return
 // "not hung", since it'll run on the current thread anyway.  The hang
 // detector will see no pending jobs in that case, so it's automatic.
 bool AVDACodecAllocator::IsThreadLikelyHung(TaskType task_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return threads_[task_type]->hang_detector.IsThreadLikelyHung();
 }
@@ skipping 39 matching lines @@
 void AVDACodecAllocator::StopThreadTask(size_t index) {
   threads_[index]->thread.Stop();
   // Signal the stop event after both threads are stopped.
   if (stop_event_for_testing_ && !threads_[AUTO_CODEC]->thread.IsRunning() &&
       !threads_[SW_CODEC]->thread.IsRunning()) {
     stop_event_for_testing_->Signal();
   }
 }
 
 }  // namespace media