Add ContentVideoViewOverlay to AVDA.

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 119 matching lines @@
   }
 }
 
 // Return the task runner for tasks of type |type|.
 scoped_refptr<base::SingleThreadTaskRunner> AVDACodecAllocator::TaskRunnerFor(
     TaskType task_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return threads_[task_type]->thread.task_runner();
 }
 
-bool AVDACodecAllocator::AllocateSurface(AVDACodecAllocatorClient* client,
+bool AVDACodecAllocator::AllocateSurface(AVDASurfaceAllocatorClient* 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_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,
+void AVDACodecAllocator::DeallocateSurface(AVDASurfaceAllocatorClient* 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;
@@ skipping 67 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->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) {
+  // We pass |codec_config| back to OnCodecConfigured in case it's the last
+  // reference to it.  It might have an overlay that must be dropped on the
+  // right thread.
   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(&AVDACodecAllocatorClient::OnCodecConfigured, client,
+                 codec_config));
 }
 
 void AVDACodecAllocator::ReleaseMediaCodec(
     std::unique_ptr<VideoCodecBridge> media_codec,
     TaskType task_type,
     int surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(media_codec);
 
   // No need to track the release if it's a SurfaceTexture.
@@ skipping 83 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