Split out AVDA cleanups from SetSurface() change.

media/gpu/avda_shared_state.cc

 // Copyright 2015 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_shared_state.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "media/gpu/avda_codec_image.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace media {
 
+// Handle OnFrameAvailable callbacks safely.  Since they occur asynchronously,
+// we take care that the object that wants them still exists.  WeakPtrs cannot
+// be used because OnFrameAvailable callbacks can occur on any thread. We also
+// can't guarantee when the SurfaceTexture will quit sending callbacks to
+// coordinate with the destruction of the AVDA and PictureBufferManager, so we
+// have a separate object that the callback can own.
+class AVDASharedState::OnFrameAvailableHandler
+    : public base::RefCountedThreadSafe<OnFrameAvailableHandler> {
+ public:
+  // We do not retain ownership of |listener|.  It must remain valid until after
+  // ClearListener() is called.  This will register with |surface_texture| to
+  // receive OnFrameAvailable callbacks.
+  OnFrameAvailableHandler(AVDASharedState* listener,
+                          gl::SurfaceTexture* surface_texture)
+      : listener_(listener) {
+    surface_texture->SetFrameAvailableCallbackOnAnyThread(
+        base::Bind(&OnFrameAvailableHandler::OnFrameAvailable,
+                   scoped_refptr<OnFrameAvailableHandler>(this)));
+  }
+
+  // Forget about |listener_|, which is required before one deletes it.
+  // No further callbacks will happen once this completes.
+  void ClearListener() {
+    base::AutoLock lock(lock_);
+    listener_ = nullptr;
+  }
+
+  // Notify the listener if there is one.
+  void OnFrameAvailable() {
+    base::AutoLock auto_lock(lock_);
+    if (listener_)
+      listener_->SignalFrameAvailable();
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<OnFrameAvailableHandler>;
+
+  ~OnFrameAvailableHandler() { DCHECK(!listener_); }
+
+  // Protects changes to listener_.
+  base::Lock lock_;
+
+  // The AVDASharedState that wants the OnFrameAvailable callback.
+  AVDASharedState* listener_;
+
+  DISALLOW_COPY_AND_ASSIGN(OnFrameAvailableHandler);
+};
+
 AVDASharedState::AVDASharedState()
     : surface_texture_service_id_(0),
       frame_available_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                              base::WaitableEvent::InitialState::NOT_SIGNALED),
 
       gl_matrix_{
           1, 0, 0, 0,  // Default to a sane guess just in case we can't get the
           0, 1, 0, 0,  // matrix on the first call. Will be Y-flipped later.
           0, 0, 1, 0,  //
           0, 0, 0, 1,  // Comment preserves 4x4 formatting.
       } {}
 
 AVDASharedState::~AVDASharedState() {
   if (!surface_texture_service_id_)
     return;
 
+  on_frame_available_handler_->ClearListener();

[liberato (no reviews please), 2016/11/04 18:02:14]

might want to if(on_frame_...) { clearlistener } before the early return at line
77, just in case this gets out of sync somehow with
|surface_texture_service_id_|.

[DaleCurtis, 2016/11/04 19:42:42]

Should be impossible since SetSurfaceTexture can only be called once. Generally
we want to avoid introducing checks for somehow :)

   ui::ScopedMakeCurrent scoped_make_current(context_.get(), surface_.get());
   if (scoped_make_current.Succeeded()) {
     glDeleteTextures(1, &surface_texture_service_id_);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   }
 }
 
 void AVDASharedState::SignalFrameAvailable() {
   frame_available_event_.Signal();
 }
@@ skipping 30 matching lines @@
 
 void AVDASharedState::SetSurfaceTexture(
     scoped_refptr<gl::SurfaceTexture> surface_texture,
     GLuint attached_service_id) {
   surface_texture_ = surface_texture;
   surface_texture_service_id_ = attached_service_id;
   context_ = gl::GLContext::GetCurrent();
   surface_ = gl::GLSurface::GetCurrent();
   DCHECK(context_);
   DCHECK(surface_);
-}
-
-void AVDASharedState::CodecChanged(MediaCodecBridge* codec) {
-  for (auto& image_kv : codec_images_)
-    image_kv.second->CodecChanged(codec);
-  release_time_ = base::TimeTicks();
-}
-
-void AVDASharedState::SetImageForPicture(int picture_buffer_id,
-                                         AVDACodecImage* image) {
-  if (!image) {
-    DCHECK(codec_images_.find(picture_buffer_id) != codec_images_.end());
-    codec_images_.erase(picture_buffer_id);
-    return;
-  }
-
-  DCHECK(codec_images_.find(picture_buffer_id) == codec_images_.end());
-  codec_images_[picture_buffer_id] = image;
-}
-
-AVDACodecImage* AVDASharedState::GetImageForPicture(
-    int picture_buffer_id) const {
-  auto it = codec_images_.find(picture_buffer_id);
-  return it == codec_images_.end() ? nullptr : it->second;
+  on_frame_available_handler_ =
+      new OnFrameAvailableHandler(this, surface_texture_.get());
 }
 
 void AVDASharedState::RenderCodecBufferToSurfaceTexture(
     MediaCodecBridge* codec,
     int codec_buffer_index) {
   if (!release_time_.is_null())
     WaitForFrameAvailable();
   codec->ReleaseOutputBuffer(codec_buffer_index, true);
   release_time_ = base::TimeTicks::Now();
 }
 
 void AVDASharedState::UpdateTexImage() {
   surface_texture_->UpdateTexImage();
   // Helpfully, this is already column major.
   surface_texture_->GetTransformMatrix(gl_matrix_);
 }
 
 void AVDASharedState::GetTransformMatrix(float matrix[16]) const {
   memcpy(matrix, gl_matrix_, sizeof(gl_matrix_));
 }
 
 }  // namespace media