Add SurfaceTexture::release and call it from AVDA.

SurfaceTexture::release() discards unused buffers and tears down the
SurfaceTexture, leaving only the front buffer if it's bound to a GL
texture.  This CL plumbs that down to native.

This CL also uses it for AVDA, so that back buffers don't take up
memory when the deferred strategy is shut down.

As part of that, it splits strategy cleanup into two parts.  The
first is called before flush, while the latter is called after.
This prevents transitioning the SurfaceTexture into the released
state while the flush is still trying to talk to MediaCodec.  It's
unclear that would be safe.

BUG=619658

Review-Url: https://codereview.chromium.org/2095873005
Cr-Commit-Position: refs/heads/master@{#402187}

media/gpu/android_copying_backing_strategy.cc

@@ -39,7 +39,7 @@ gl::ScopedJavaSurface AndroidCopyingBackingStrategy::Initialize(
   return gl::ScopedJavaSurface(surface_texture_.get());
 }
 
-void AndroidCopyingBackingStrategy::Cleanup(
+void AndroidCopyingBackingStrategy::BeginCleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   DCHECK(state_provider_->ThreadChecker().CalledOnValidThread());
@@ -51,6 +51,8 @@ void AndroidCopyingBackingStrategy::Cleanup(
     glDeleteTextures(1, &surface_texture_id_);
 }
 
+void AndroidCopyingBackingStrategy::EndCleanup() {}
+
 scoped_refptr<gl::SurfaceTexture>
 AndroidCopyingBackingStrategy::GetSurfaceTexture() const {
   return surface_texture_;

media/gpu/android_copying_backing_strategy.h

@@ -35,9 +35,10 @@ class MEDIA_GPU_EXPORT AndroidCopyingBackingStrategy
 
   // AndroidVideoDecodeAccelerator::BackingStrategy
   gl::ScopedJavaSurface Initialize(int surface_view_id) override;
-  void Cleanup(
+  void BeginCleanup(
       bool have_context,
       const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) override;
+  void EndCleanup() override;
   scoped_refptr<gl::SurfaceTexture> GetSurfaceTexture() const override;
   uint32_t GetTextureTarget() const override;
   gfx::Size GetPictureBufferSize() const override;

media/gpu/android_deferred_rendering_backing_strategy.cc

@@ -61,16 +61,28 @@ gl::ScopedJavaSurface AndroidDeferredRenderingBackingStrategy::Initialize(
   return gl::ScopedJavaSurface(surface_texture_.get());
 }
 
-void AndroidDeferredRenderingBackingStrategy::Cleanup(
+void AndroidDeferredRenderingBackingStrategy::BeginCleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // If we failed before Initialize, then do nothing.
   if (!shared_state_)
     return;
 
+  // TODO(liberato): we should release all codec buffers here without rendering.
+  // CodecChanged() will drop them, but is expected to be called after the codec
+  // is no longer accessible.  It's unclear that VP8 flush in AVDA can't hang
+  // waiting for our buffers.
+
   CodecChanged(nullptr);
 }
 
+void AndroidDeferredRenderingBackingStrategy::EndCleanup() {
+  // Release the surface texture and any back buffers.  This will preserve the
+  // front buffer, if any.
+  if (surface_texture_)
+    surface_texture_->ReleaseSurfaceTexture();
+}
+
 scoped_refptr<gl::SurfaceTexture>
 AndroidDeferredRenderingBackingStrategy::GetSurfaceTexture() const {
   return surface_texture_;

media/gpu/android_deferred_rendering_backing_strategy.h

@@ -41,9 +41,10 @@ class MEDIA_GPU_EXPORT AndroidDeferredRenderingBackingStrategy
 
   // AndroidVideoDecodeAccelerator::BackingStrategy
   gl::ScopedJavaSurface Initialize(int surface_view_id) override;
-  void Cleanup(
+  void BeginCleanup(
       bool have_context,
       const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) override;
+  void EndCleanup() override;
   scoped_refptr<gl::SurfaceTexture> GetSurfaceTexture() const override;
   uint32_t GetTextureTarget() const override;
   gfx::Size GetPictureBufferSize() const override;

media/gpu/android_video_decode_accelerator.cc

@@ -1364,7 +1364,7 @@ void AndroidVideoDecodeAccelerator::Destroy() {
     LOG(WARNING) << "Failed make GL context current for Destroy, continuing.";
 
   if (strategy_)
-    strategy_->Cleanup(have_context, output_picture_buffers_);
+    strategy_->BeginCleanup(have_context, output_picture_buffers_);
 
   // If we have an OnFrameAvailable handler, tell it that we're going away.
   if (on_frame_available_handler_) {
@@ -1397,6 +1397,9 @@ void AndroidVideoDecodeAccelerator::ActualDestroy() {
         on_destroying_surface_cb_);
   }
 
+  if (strategy_)
+    strategy_->EndCleanup();
+
   AVDATimerManager* manager = g_avda_timer.Pointer();
 
   // We no longer care about |surface_id|, in case we did before.  It's okay

media/gpu/android_video_decode_accelerator.h

@@ -60,10 +60,14 @@ class MEDIA_GPU_EXPORT AndroidVideoDecodeAccelerator
     // Returns the Java surface to configure MediaCodec with.
     virtual gl::ScopedJavaSurface Initialize(int surface_view_id) = 0;
 
-    // Called before the AVDA does any Destroy() work.  This will be
+    // Called before the AVDA does any Destroy() work.  The strategy should
+    // release any pending codec buffers, for example.
+    virtual void BeginCleanup(bool have_context,
+                              const OutputBufferMap& buffer_map) = 0;
+
+    // Called before the AVDA closes up entirely.  This will be
     // the last call that the BackingStrategy receives.
-    virtual void Cleanup(bool have_context,
-                         const OutputBufferMap& buffer_map) = 0;
+    virtual void EndCleanup() = 0;
 
     // This returns the SurfaceTexture created by Initialize, or nullptr if
     // the strategy was initialized with a SurfaceView.

ui/android/java/src/org/chromium/ui/gl/SurfaceTexturePlatformWrapper.java

@@ -60,4 +60,9 @@ class SurfaceTexturePlatformWrapper {
     private static void detachFromGLContext(SurfaceTexture surfaceTexture) {
         surfaceTexture.detachFromGLContext();
     }
+
+    @CalledByNative
+    private static void release(SurfaceTexture surfaceTexture) {
+        surfaceTexture.release();
+    }
 }

ui/gl/android/surface_texture.cc

@@ -96,6 +96,11 @@ ANativeWindow* SurfaceTexture::CreateSurface() {
   return native_window;
 }
 
+void SurfaceTexture::ReleaseSurfaceTexture() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_SurfaceTexturePlatformWrapper_release(env, j_surface_texture_.obj());
+}
+
 bool SurfaceTexture::RegisterSurfaceTexture(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }

ui/gl/android/surface_texture.h

@@ -57,6 +57,11 @@ class GL_EXPORT SurfaceTexture
   // by calling ANativeWindow_release().
   ANativeWindow* CreateSurface();
 
+  // Release the SurfaceTexture back buffers.  The SurfaceTexture is no longer
+  // usable after calling this.  Note that this is not called 'Release', like
+  // the android API, because scoped_refptr<> calls that quite a bit.
+  void ReleaseSurfaceTexture();
+
   const base::android::JavaRef<jobject>& j_surface_texture() const {
     return j_surface_texture_;
   }