media: Ensure MediaCodecs are released before attached SurfaceTextures

media/gpu/avda_codec_allocator.h

 // 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.
 
 #ifndef MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_
 #define MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 36 matching lines @@
 class CodecConfig : public base::RefCountedThreadSafe<CodecConfig> {
  public:
   CodecConfig();
 
   VideoCodec codec = kUnknownVideoCodec;
 
   // The surface that MediaCodec is configured to output to.
   gl::ScopedJavaSurface surface;
   int surface_id = SurfaceManager::kNoSurfaceID;
 
+  // The SurfaceTexture attached to |surface|, or nullptr if |surface| is
+  // SurfaceView backed.
+  scoped_refptr<gl::SurfaceTexture> surface_texture;

[liberato (no reviews please), 2017/01/17 18:58:24]

is this used?

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

Yes, I put a comment on its usage. The point of it is to keep a strong ref to
the ST that is independent of anything else using it, so we don't have to worry
about ~ST doing the release before we release the codec, and we don't have to
give PBM a weird guarantee about how long it holds onto the ST.

+
   // The MediaCrypto that MediaCodec is configured with for an encrypted stream.
   MediaDrmBridgeCdmContext::JavaObjectPtr media_crypto;
 
   // Whether the encryption scheme requires us to use a protected surface.
   bool needs_protected_surface = false;
 
   // The initial coded size. The actual size might change at any time, so this
   // is only a hint.
   gfx::Size initial_expected_coded_size;
 
@@ skipping 86 matching lines @@
   // detector will see no pending jobs in that case, so it's automatic.
   bool IsThreadLikelyHung(TaskType task_type);
 
   // Return true if and only if there is any AVDA registered.
   bool IsAnyRegisteredAVDA();
 
   // Return the task type to use for a new codec allocation, or nullopt if
   // both threads are hung.
   base::Optional<TaskType> TaskTypeForAllocation();
 
+  // Return the task runner for tasks of type |type|.
+  scoped_refptr<base::SingleThreadTaskRunner> TaskRunnerFor(TaskType task_type);
+
   // Return a reference to the thread for unit tests.
   base::Thread& GetThreadForTesting(TaskType task_type);
 
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDACodecAllocator>;
   friend class AVDACodecAllocatorTest;
 
   struct OwnerRecord {
     AVDACodecAllocatorClient* owner = nullptr;
     AVDACodecAllocatorClient* waiter = nullptr;
@@ skipping 23 matching lines @@
         : thread(name), hang_detector(tick_clock) {}
     base::Thread thread;
     HangDetector hang_detector;
   };
 
   // |tick_clock| and |stop_event| are for tests only.
   AVDACodecAllocator(base::TickClock* tick_clock = nullptr,
                      base::WaitableEvent* stop_event = nullptr);
   ~AVDACodecAllocator();
 
-  // Return the task runner for tasks of type |type|.
-  scoped_refptr<base::SingleThreadTaskRunner> TaskRunnerFor(TaskType task_type);
-
   void OnMediaCodecAndSurfaceReleased(int surface_id);
 
   // Stop the thread indicated by |index|. This signals stop_event_for_testing_
   // after both threads are stopped.
   void StopThreadTask(size_t index);
 
   // All registered AVDAs.
   std::set<AVDACodecAllocatorClient*> clients_;
 
   // Indexed by surface id.
@@ skipping 13 matching lines @@
 
   // For canceling pending StopThreadTask()s.
   base::WeakPtrFactory<AVDACodecAllocator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDACodecAllocator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_AVDA_CODEC_ALLOCATOR_H_