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 10 matching lines @@
 #include "base/time/tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/android/media_drm_bridge_cdm_context.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/media.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_codecs.h"
 #include "media/gpu/media_gpu_export.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/android/scoped_java_surface.h"
+#include "ui/gl/android/surface_texture.h"
 
 namespace media {
 
 // For TaskRunnerFor. These are used as vector indices, so please update
 // AVDACodecAllocator's constructor if you add / change them.
 enum TaskType {
   // Task for an autodetected MediaCodec instance.
   AUTO_CODEC = 0,
 
   // Task for a software-codec-required MediaCodec.
@@ skipping 92 matching lines @@
 
   // Create and configure a MediaCodec synchronously.
   std::unique_ptr<VideoCodecBridge> CreateMediaCodecSync(
       scoped_refptr<CodecConfig> codec_config);
 
   // Create and configure a MediaCodec asynchronously. The result is delivered
   // via OnCodecConfigured().
   void CreateMediaCodecAsync(base::WeakPtr<AVDACodecAllocatorClient> client,
                              scoped_refptr<CodecConfig> codec_config);
 
-  // Asynchronously release |media_codec| with the attached surface.
+  // Asynchronously release |media_codec| with the attached surface. If a
+  // SurfaceView is attached to the codec, the release is tracked so that
+  // OnSurfaceDestroyed() can wait on it to complete. If a SurfaceTexture
+  // is attached to the codec, the release is tracked so that
+  // ReleaseSurfaceTexture() can arrange for the SurfaceTexture to be released
+  // after the codec.

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

that it's a raw ptr is a little subtle.  might deserve a comment that (a) it's
not referenced, and (b) it's guaranteed not to outlive the surface texture as
long as the client uses ReleaseSurfaceTexture rather than just dropping its
reference.

without (b) in particular, the raw ptr might become aliased to some future
surface texture instance.

   // TODO(watk): Bundle the MediaCodec and surface together so you can't get
   // this pairing wrong.
   void ReleaseMediaCodec(std::unique_ptr<VideoCodecBridge> media_codec,
                          TaskType task_type,
-                         int surface_id);
+                         int surface_id,
+                         gl::SurfaceTexture* surface_texture);
+
+  // Call |surface_texture|->ReleaseSurfaceTexture() after the MediaCodec it's
+  // attached to is released. This should always be called after
+  // ReleaseMediaCodec().
+  void ReleaseSurfaceTexture(scoped_refptr<gl::SurfaceTexture> surface_texture);
 
   // 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 IsThreadLikelyHung(TaskType task_type);
 
   // Return true if and only if there is any AVDA registered.
   bool IsAnyRegisteredAVDA();
 
@@ skipping 40 matching lines @@
   };
 
   // |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);
+  void OnMediaCodecReleased(int surface_id,
+                            gl::SurfaceTexture* surface_texture);
 
   // 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.
   std::map<int32_t, OwnerRecord> surface_owners_;
 
-  // Waitable events for ongoing release tasks indexed by surface id so we can
-  // wait on the codec release if the surface attached to it is being destroyed.
-  std::map<int32_t, base::WaitableEvent> pending_codec_releases_;
+  // Waitable events for ongoing releases of codecs with attached SurfaceViews,
+  // indexed by surface id. For waiting on the codec release if the surface is
+  // being destroyed.
+  std::map<int32_t, base::WaitableEvent> surface_view_codec_releases_;
+
+  // TaskTypes of ongoing releases of codecs with attached SurfaceTextures, For
+  // deferring SurfaceTexture release until after the codec release.
+  std::map<gl::SurfaceTexture*, TaskType> surface_texture_codec_releases_;
 
   // Threads for each of TaskType.  They are started / stopped as avda instances
   // show and and request them.  The vector indicies must match TaskType.
   std::vector<ThreadAndHangDetector*> threads_;
 
   base::ThreadChecker thread_checker_;
 
   base::WaitableEvent* stop_event_for_testing_;
 
   // 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_