Group AVDA output surface into AVDASurfaceBundle.

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 23 matching lines @@
     base::TimeDelta::FromMilliseconds(800);
 
 // Delete |codec| and signal |done_event| if it's not null.
 void DeleteMediaCodecAndSignal(std::unique_ptr<VideoCodecBridge> codec,
                                base::WaitableEvent* done_event) {
   codec.reset();
   if (done_event)
     done_event->Signal();
 }
 
+void DropReferenceToSurfaceBundle(
+    scoped_refptr<AVDASurfaceBundle> surface_bundle) {
+  // Do nothing.  Let |surface_bundle| go out of scope.
+}
+
 }  // namespace
 
 CodecConfig::CodecConfig() {}
 CodecConfig::~CodecConfig() {}
 
 AVDACodecAllocator::HangDetector::HangDetector(base::TickClock* tick_clock)
     : tick_clock_(tick_clock) {}
 
 void AVDACodecAllocator::HangDetector::WillProcessTask(
     const base::PendingTask& pending_task) {
@@ skipping 187 matching lines @@
   jobject media_crypto =
       codec_config->media_crypto ? codec_config->media_crypto->obj() : nullptr;
 
   // |needs_protected_surface| implies encrypted stream.
   DCHECK(!codec_config->needs_protected_surface || media_crypto);
 
   const bool require_software_codec = codec_config->task_type == SW_CODEC;
   std::unique_ptr<VideoCodecBridge> codec(VideoCodecBridge::CreateDecoder(
       codec_config->codec, codec_config->needs_protected_surface,
       codec_config->initial_expected_coded_size,
-      codec_config->surface.j_surface().obj(), media_crypto, codec_config->csd0,
-      codec_config->csd1, true, require_software_codec));
+      codec_config->surface_bundle->surface.j_surface().obj(), media_crypto,
+      codec_config->csd0, codec_config->csd1, true, require_software_codec));
 
   return codec;
 }
 
 void AVDACodecAllocator::CreateMediaCodecAsync(
     base::WeakPtr<AVDACodecAllocatorClient> client,
     scoped_refptr<CodecConfig> codec_config) {
+  // Allocate the codec on the appropriate thread, and reply to this one with
+  // the result.  If |client| is gone by then, we handle cleanup.
   base::PostTaskAndReplyWithResult(
       TaskRunnerFor(codec_config->task_type).get(), FROM_HERE,
       base::Bind(&AVDACodecAllocator::CreateMediaCodecSync,
                  base::Unretained(this), codec_config),
-      base::Bind(&AVDACodecAllocatorClient::OnCodecConfigured, client));
+      base::Bind(&AVDACodecAllocator::ForwardOrDropCodec,
+                 base::Unretained(this), client, codec_config->task_type,
+                 codec_config->surface_bundle));
+}
+
+void AVDACodecAllocator::ForwardOrDropCodec(
+    base::WeakPtr<AVDACodecAllocatorClient> client,
+    TaskType task_type,
+    scoped_refptr<AVDASurfaceBundle> surface_bundle,
+    std::unique_ptr<VideoCodecBridge> media_codec) {
+  if (!client) {
+    // |client| has been destroyed.  Free |media_codec| on the right thread.
+    // Note that this also preserves |surface_bundle| until |media_codec| has
+    // been released, in case our ref to it is the last one.
+    ReleaseMediaCodec(std::move(media_codec), task_type, surface_bundle);
+    return;
+  }
+
+  client->OnCodecConfigured(std::move(media_codec));
 }
 
 void AVDACodecAllocator::ReleaseMediaCodec(
     std::unique_ptr<VideoCodecBridge> media_codec,
     TaskType task_type,
-    int surface_id) {
+    const scoped_refptr<AVDASurfaceBundle>& surface_bundle) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(media_codec);
 
-  // No need to track the release if it's a SurfaceTexture.
-  if (surface_id == SurfaceManager::kNoSurfaceID) {
-    TaskRunnerFor(task_type)->PostTask(
+  // No need to track the release if it's a SurfaceTexture.  We still forward
+  // the reference to |surface_bundle|, though, so that the SurfaceTexture
+  // lasts at least as long as the codec.
+  if (surface_bundle->surface_id == SurfaceManager::kNoSurfaceID) {
+    TaskRunnerFor(task_type)->PostTaskAndReply(
         FROM_HERE, base::Bind(&DeleteMediaCodecAndSignal,
-                              base::Passed(std::move(media_codec)), nullptr));
+                              base::Passed(std::move(media_codec)), nullptr),
+        base::Bind(&DropReferenceToSurfaceBundle, surface_bundle));
     return;
   }
 
+  DCHECK(!surface_bundle->surface_texture);
   pending_codec_releases_.emplace(
-      std::piecewise_construct, std::forward_as_tuple(surface_id),
+      std::piecewise_construct,
+      std::forward_as_tuple(surface_bundle->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;
+      &pending_codec_releases_.find(surface_bundle->surface_id)->second;
 
+  // Note that we forward |surface_bundle|, too, so that the surface outlasts
+  // the codec.  This doesn't matter so much for CVV surfaces, since they don't
+  // auto-release when they're dropped.  However, for surface owners, this will
+  // become important, so we still handle it.  Plus, it makes sense.
   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));
+      base::Bind(&AVDACodecAllocator::OnMediaCodecReleased,
+                 base::Unretained(this), surface_bundle));
 }
 
-void AVDACodecAllocator::OnMediaCodecAndSurfaceReleased(int surface_id) {
+void AVDACodecAllocator::OnMediaCodecReleased(
+    scoped_refptr<AVDASurfaceBundle> surface_bundle) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  pending_codec_releases_.erase(surface_id);
-  if (!surface_owners_.count(surface_id))
+  pending_codec_releases_.erase(surface_bundle->surface_id);
+  if (!surface_owners_.count(surface_bundle->surface_id))
     return;
 
-  OwnerRecord& record = surface_owners_[surface_id];
+  OwnerRecord& record = surface_owners_[surface_bundle->surface_id];
   if (!record.owner && record.waiter) {
     record.owner = record.waiter;
     record.waiter = nullptr;
     record.owner->OnSurfaceAvailable(true);
   }
+
+  // Also note that |surface_bundle| lasted at least as long as the codec.
 }
 
 // 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