Re-hook up surfaceRedrawNeededAsync callback.

chrome/android/java/src/org/chromium/chrome/browser/compositor/CompositorSurfaceManager.java

 // Copyright 2017 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.
 
 package org.chromium.chrome.browser.compositor;
 
 import android.content.Context;
 import android.graphics.PixelFormat;
 import android.graphics.drawable.Drawable;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 
+import org.chromium.base.annotations.UsedByReflection;
+
 /**
  * Manage multiple SurfaceViews for the compositor, so that transitions between
  * surfaces with and without an alpha channel can be visually smooth.
  *
  * This class allows a client to request a 'translucent' or 'opaque' surface, and we will signal via
  * SurfaceHolder.Callback when it's ready.  We guarantee that the client will receive surfaceCreated
  * / surfaceDestroyed only for a surface that represents the most recently requested PixelFormat.
  *
  * Internally, we maintain two SurfaceViews, since calling setFormat() to change the PixelFormat
  * results in a visual glitch as the surface is torn down.  crbug.com/679902
  *
  * The client has the responsibility to call doneWithUnownedSurface() at some point between when we
  * call back its surfaceCreated, when it is safe for us to hide the SurfaceView with the wrong
  * format.  It is okay if it requests multiple surfaces without calling doneWithUnownedSurface.
  *
  * If the client requests the same format more than once in a row, it will still receive destroyed /
  * created / changed messages for it, even though we won't tear it down.
  *
  * The full design doc is at https://goo.gl/aAmQzR .
  */
-class CompositorSurfaceManager implements SurfaceHolder.Callback {
+class CompositorSurfaceManager implements SurfaceHolder.Callback2 {
+    public interface SurfaceHolderCallbackTarget {
+        public void surfaceRedrawNeededAsync(SurfaceHolder holder, Runnable drawingFinished);
+        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height);
+        public void surfaceCreated(SurfaceHolder holder);
+        public void surfaceDestroyed(SurfaceHolder holder);
+    }
+
     private static class SurfaceState {
         public SurfaceView surfaceView;
 
         // Do we expect a surfaceCreated?
         public boolean createPending;
 
         // Have we started destroying |surfaceView|, but haven't received surfaceDestroyed yet?
         public boolean destroyPending;
 
         // Last PixelFormat that we received, or UNKNOWN if we don't know / don't want to cache it.
         public int format;
 
         // Last known width, height for thsi surface.
         public int width;
         public int height;
 
         // Parent ViewGroup, or null.
         private ViewGroup mParent;
 
-        public SurfaceState(Context context, int format, SurfaceHolder.Callback callback) {
+        public SurfaceState(Context context, int format, SurfaceHolder.Callback2 callback) {
             surfaceView = new SurfaceView(context);
             surfaceView.setZOrderMediaOverlay(true);
             surfaceView.setVisibility(View.VISIBLE);
             surfaceHolder().setFormat(format);
             surfaceHolder().addCallback(callback);
 
             // Set this to UNKNOWN until we get a format back.
             this.format = PixelFormat.UNKNOWN;
         }
 
@@ skipping 35 matching lines @@
     // Surface that we last gave to the client with surfaceCreated.  Cleared when we call
     // surfaceDestroyed on |mClient|.  Note that it's not necessary that Android has notified us
     // the surface has been destroyed; we deliberately keep it around until the client tells us that
     // it's okay to get rid of it.
     private SurfaceState mOwnedByClient;
 
     // Surface that was most recently requested by the client.
     private SurfaceState mRequestedByClient;
 
     // Client that we notify about surface change events.
-    private SurfaceHolder.Callback mClient;
+    private SurfaceHolderCallbackTarget mClient;
 
     // View to which we'll attach the SurfaceView.
     private final ViewGroup mParentView;
 
-    public CompositorSurfaceManager(ViewGroup parentView, SurfaceHolder.Callback client) {
+    public CompositorSurfaceManager(ViewGroup parentView, SurfaceHolderCallbackTarget client) {
         mParentView = parentView;
         mClient = client;
 
         mTranslucent = new SurfaceState(parentView.getContext(), PixelFormat.TRANSLUCENT, this);
         mOpaque = new SurfaceState(mParentView.getContext(), PixelFormat.OPAQUE, this);
     }
 
     /**
      * Turn off everything.
      */
@@ skipping 119 matching lines @@
         // client has requested a different surface but hasn't gotten it yet, then skip this.
         if (state == mOwnedByClient && state == mRequestedByClient) {
             state.width = width;
             state.height = height;
             state.format = format;
             mClient.surfaceChanged(holder, format, width, height);
         }
     }
 
     @Override
+    public void surfaceRedrawNeeded(SurfaceHolder holder) {
+        // Intentionally not implemented.
+    }
+
+    // TODO(boliu): Mark this override instead.
+    @UsedByReflection("Android")
+    public void surfaceRedrawNeededAsync(SurfaceHolder holder, Runnable drawingFinished) {
+        mClient.surfaceRedrawNeededAsync(holder, drawingFinished);
+    }
+
+    @Override
     public void surfaceCreated(SurfaceHolder holder) {
         SurfaceState state = getStateForHolder(holder);
         assert state != null;
         // Note that |createPending| might not be set, if Android destroyed and recreated this
         // surface on its own.
 
         if (state != mRequestedByClient) {
             // Surface is created, but it's not the one that's been requested most recently.  Just
             // destroy it again.
             detachSurfaceLater(state);
@@ skipping 184 matching lines @@
 
         state.destroyPending = true;
         mParentView.post(new Runnable() {
             @Override
             public void run() {
                 detachSurfaceNow(state);
             }
         });
     }
 }