Improve transition between opaque and translucent compositor views.

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

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// 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.
 
 package org.chromium.chrome.browser.compositor;
 
 import android.app.Activity;
 import android.content.Context;
 import android.graphics.Color;
 import android.graphics.PixelFormat;
 import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.view.Display;
 import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
 import android.view.WindowManager;
+import android.widget.FrameLayout;
 
 import org.chromium.base.CommandLine;
-import org.chromium.base.Log;
 import org.chromium.base.TraceEvent;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.chrome.browser.compositor.layouts.Layout;
 import org.chromium.chrome.browser.compositor.layouts.LayoutProvider;
 import org.chromium.chrome.browser.compositor.layouts.LayoutRenderHost;
 import org.chromium.chrome.browser.compositor.layouts.content.TabContentManager;
 import org.chromium.chrome.browser.compositor.resources.StaticResourcePreloads;
 import org.chromium.chrome.browser.compositor.scene_layer.SceneLayer;
 import org.chromium.chrome.browser.externalnav.IntentWithGesturesHandler;
 import org.chromium.chrome.browser.multiwindow.MultiWindowUtils;
 import org.chromium.chrome.browser.tabmodel.TabModelImpl;
 import org.chromium.chrome.browser.widget.ClipDrawableProgressBar.DrawingInfo;
 import org.chromium.ui.base.DeviceFormFactor;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.resources.AndroidResourceType;
 import org.chromium.ui.resources.ResourceManager;
 
 /**
  * The is the {@link View} displaying the ui compositor results; including webpages and tabswitcher.
  */
 @JNINamespace("android")
-public class CompositorView
-        extends SurfaceView implements SurfaceHolder.Callback {
+public class CompositorView extends FrameLayout implements SurfaceHolder.Callback {
     private static final String TAG = "CompositorView";
     private static final long NANOSECONDS_PER_MILLISECOND = 1000000;
 
     // Cache objects that should not be created every frame
     private final Rect mCacheAppRect = new Rect();
     private final int[] mCacheViewPosition = new int[2];
 
+    private CompositorSurfaceManager mCompositorSurfaceManager;
+    private boolean mOverlayVideoEnabled;
+    private boolean mAlwaysTranslucent;
+
+    // Are we waiting to hide the outgoing surface until the foreground has something to display?
+    // If == 0, then no.  If > 0, then yes.  We'll hide when it transitions from one to zero.
+    private int mFramesUntilHideBackground;
+
+    // Cache of setWillNotDraw, which we keep up to date if we switch SVs.
+    private boolean mWillNotDraw;
+
     private long mNativeCompositorView;
     private final LayoutRenderHost mRenderHost;
     private boolean mEnableTabletTabStack;
     private int mPreviousWindowTop = -1;
 
     // A conservative estimate of when a frame is guaranteed to be presented after being submitted.
     private long mFramePresentationDelay;
 
     // Resource Management
     private ResourceManager mResourceManager;
 
     // Lazily populated as it is needed.
     private View mRootActivityView;
     private WindowAndroid mWindowAndroid;
     private LayerTitleCache mLayerTitleCache;
     private TabContentManager mTabContentManager;
 
     private View mRootView;
-    private int mSurfaceWidth;
-    private int mSurfaceHeight;
     private boolean mPreloadedResources;
 
-    // The current SurfaceView pixel format. Defaults to OPAQUE.
-    private int mCurrentPixelFormat = PixelFormat.OPAQUE;
-
     /**
-     * Creates a {@link CompositorView}. This can be called only after the native library is
-     * properly loaded.
+     * Creates a {@link CompositorView}. This can be called only after the
+     * native library is properly loaded.

[David Trainor- moved to gerrit, 2017/02/07 19:36:16]

Move back up?  100 columns for Java.

[liberato (no reviews please), 2017/02/14 17:22:24]

Done.

      * @param c        The Context to create this {@link CompositorView} in.
      * @param host     The renderer host owning this view.
      */
     public CompositorView(Context c, LayoutRenderHost host) {
         super(c);
         mRenderHost = host;
         resetFlags();
+
         setVisibility(View.INVISIBLE);
-        setZOrderMediaOverlay(true);
     }
 
     /**
      * @param view The root view of the hierarchy.
      */
     public void setRootView(View view) {
         mRootView = view;
     }
 
     /**
@@ skipping 48 matching lines @@
      * @return The ResourceManager.
      */
     public ResourceManager getResourceManager() {
         return mResourceManager;
     }
 
     /**
      * Should be called for cleanup when the CompositorView instance is no longer used.
      */
     public void shutDown() {
-        getHolder().removeCallback(this);
+        mCompositorSurfaceManager.shutDown();
         if (mNativeCompositorView != 0) nativeDestroy(mNativeCompositorView);
         mNativeCompositorView = 0;
     }
 
     /**
      * Initializes the {@link CompositorView}'s native parts (e.g. the rendering parts).
      * @param lowMemDevice         If this is a low memory device.
      * @param windowAndroid        A {@link WindowAndroid} instance.
      * @param layerTitleCache      A {@link LayerTitleCache} instance.
      * @param tabContentManager    A {@link TabContentManager} instance.
      */
     public void initNativeCompositor(boolean lowMemDevice, WindowAndroid windowAndroid,
             LayerTitleCache layerTitleCache, TabContentManager tabContentManager) {
         mWindowAndroid = windowAndroid;
         mLayerTitleCache = layerTitleCache;
         mTabContentManager = tabContentManager;
 
         mNativeCompositorView = nativeInit(lowMemDevice,
                 windowAndroid.getNativePointer(), layerTitleCache, tabContentManager);
 
-        assert !getHolder().getSurface().isValid()
-            : "Surface created before native library loaded.";
-        getHolder().addCallback(this);
+        // compositor_impl_android.cc will use 565 EGL surfaces if and only if  we're using a low

[David Trainor- moved to gerrit, 2017/02/07 19:36:16]

Remove extra space after "only if"

[liberato (no reviews please), 2017/02/14 17:22:24]

Done.

+        // memory device, and no alpha channel is desired.  Otherwise, it will use 8888.  Since
+        // SurfaceFlinger doesn't need the eOpaque flag to optimize out alpha blending during
+        // composition if the buffer has no alpha channel, we can avoid using the extra background
+        // surface (and the memory it requires) in the low memory case.  The output buffer will
+        // either have an alpha channel or not, depending on whether the compositor needs it.  We
+        // can keep the surface translucent all the times without worrying about the impact on power
+        // usage during SurfaceFlinger composition. We might also want to set |mAlwaysTranslucent|
+        // on non-low memory devices , if we are running on hardware that implements efficient alpha

[David Trainor- moved to gerrit, 2017/02/07 19:36:16]

Remove extra space before ","

[liberato (no reviews please), 2017/02/14 17:22:24]

Done.

+        // blending.
+        mAlwaysTranslucent = lowMemDevice;
+
+        mCompositorSurfaceManager = new CompositorSurfaceManager(this, this);
+        // In case the background drawable was set before now, update it.
+        mCompositorSurfaceManager.setBackgroundDrawable(getBackground());
+        mCompositorSurfaceManager.setWillNotDraw(mWillNotDraw);
+        mCompositorSurfaceManager.requestSurface(getSurfacePixelFormat());
 
         // Cover the black surface before it has valid content.
         setBackgroundColor(Color.WHITE);
         setVisibility(View.VISIBLE);
 
         mFramePresentationDelay = 0;
         if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
             Display display =
                     ((WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE))
                     .getDefaultDisplay();
             long presentationDeadline = display.getPresentationDeadlineNanos()
                     / NANOSECONDS_PER_MILLISECOND;
             long vsyncPeriod = mWindowAndroid.getVsyncPeriodInMillis();
             mFramePresentationDelay = Math.min(3 * vsyncPeriod,
                     ((presentationDeadline + vsyncPeriod - 1) / vsyncPeriod) * vsyncPeriod);
         }
 
         // Grab the Resource Manager
         mResourceManager = nativeGetResourceManager(mNativeCompositorView);
     }
 
     @Override
     public boolean onTouchEvent(MotionEvent e) {
         return super.onTouchEvent(e);
     }
 
     /**
+     * @see SurfaceView#getHolder
+     */
+    SurfaceHolder getHolder() {
+        return mCompositorSurfaceManager.getHolder();
+    }
+
+    /**
      * Enables/disables overlay video mode. Affects alpha blending on this view.
      * @param enabled Whether to enter or leave overlay video mode.
      */
     public void setOverlayVideoMode(boolean enabled) {
-        mCurrentPixelFormat = enabled ? PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE;
-        getHolder().setFormat(mCurrentPixelFormat);
         nativeSetOverlayVideoMode(mNativeCompositorView, enabled);
+
+        mOverlayVideoEnabled = enabled;
+        // Request the new surface, even if it's the same as the old one.  We'll get a synthetic
+        // destroy / create / changed callback in that case, possibly before this returns.
+        mCompositorSurfaceManager.requestSurface(getSurfacePixelFormat());
+        // Note that we don't know if we'll get a surfaceCreated / surfaceDestoyed for this surface.
+        // We do know that if we do get one, then it will be for the surface that we just requested.
+    }
+
+    private int getSurfacePixelFormat() {
+        return (mOverlayVideoEnabled || mAlwaysTranslucent) ? PixelFormat.TRANSLUCENT
+                                                            : PixelFormat.OPAQUE;
     }
 
     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
         if (mNativeCompositorView == 0) return;
+
         nativeSurfaceChanged(mNativeCompositorView, format, width, height, holder.getSurface());
         mRenderHost.onPhysicalBackingSizeChanged(width, height);
-        mSurfaceWidth = width;
-        mSurfaceHeight = height;
     }
 
     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         if (mNativeCompositorView == 0) return;
+
         nativeSurfaceCreated(mNativeCompositorView);
+        mFramesUntilHideBackground = 2;
         mRenderHost.onSurfaceCreated();
     }
 
     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         if (mNativeCompositorView == 0) return;
+
         nativeSurfaceDestroyed(mNativeCompositorView);
     }
 
     @Override
     public void onWindowVisibilityChanged(int visibility) {
         super.onWindowVisibilityChanged(visibility);
         if (mWindowAndroid == null) return;
         if (visibility == View.GONE) {
             mWindowAndroid.onVisibilityChanged(false);
         } else if (visibility == View.VISIBLE) {
             mWindowAndroid.onVisibilityChanged(true);
         }
         IntentWithGesturesHandler.getInstance().clear();
     }
 
     @CalledByNative
     private void onCompositorLayout() {
         mRenderHost.onCompositorLayout();
     }
 
     /*
      * On JellyBean there is a known bug where a crashed producer process
      * (i.e. GPU process) does not properly disconnect from the BufferQueue,
      * which means we won't be able to reconnect to it ever again.
      * This workaround forces the creation of a new Surface.
      */
     @CalledByNative
     private void onJellyBeanSurfaceDisconnectWorkaround(boolean inOverlayMode) {
-        // There is a bug in JellyBean because of which we will not be able to
-        // reconnect to the existing Surface after we launch a new GPU process.
-        // We simply trick the JB Android code to allocate a new Surface.
-        // It does a strict comparison between the current format and the requested
-        // one, even if they are the same in practice. Furthermore, the format
-        // does not matter here since the producer-side EGL config overwrites it
-        // (but transparency might matter).
-        switch (mCurrentPixelFormat) {
-            case PixelFormat.OPAQUE:
-                mCurrentPixelFormat = PixelFormat.RGBA_8888;
-                break;
-            case PixelFormat.RGBA_8888:
-                mCurrentPixelFormat = inOverlayMode
-                        ? PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE;
-                break;
-            case PixelFormat.TRANSLUCENT:
-                mCurrentPixelFormat = PixelFormat.RGBA_8888;
-                break;
-            default:
-                assert false;
-                Log.e(TAG, "Unknown current pixel format.");
-        }
-        getHolder().setFormat(mCurrentPixelFormat);
+        mCompositorSurfaceManager.recreateSurfaceForJellyBean();
     }
 
     /**
      * Request compositor view to render a frame.
      */
     public void requestRender() {
         if (mNativeCompositorView != 0) nativeSetNeedsComposite(mNativeCompositorView);
     }
 
     @CalledByNative
     private void onSwapBuffersCompleted(int pendingSwapBuffersCount) {
         // Clear the color used to cover the uninitialized surface.
         if (getBackground() != null) {
             postDelayed(new Runnable() {
                 @Override
                 public void run() {
                     setBackgroundResource(0);
                 }
             }, mFramePresentationDelay);
         }
 
+        // If we're in the middle of a surface swap, then see if we've received a new frame yet for
+        // the new surface before hiding the outgoing surface.
+        if (mFramesUntilHideBackground > 1) {
+            // We need at least one more frame before we hide the outgoing surface.  Make sure that
+            // there will be a frame.
+            mFramesUntilHideBackground--;
+            requestRender();
+        } else if (mFramesUntilHideBackground == 1) {
+            // We can hide the outgoing surface, since the incoming one has a frame.  It's okay if
+            // we've don't have an unowned surface.
+            mFramesUntilHideBackground = 0;
+            mCompositorSurfaceManager.doneWithUnownedSurface();

[Ted C, 2017/02/06 18:44:17]

Looking at the code in doneWithUnownedSurface, it looks like we do work even if
there isn't really an unowned surface.  If android destroys our surface but we
don't change our pixel format, will this do everything as expected?

Looking at the code, it looks like it might just do unneeded work, but one final
thing I wanted to clarify.

[liberato (no reviews please), 2017/02/14 17:22:24]

it will doneWithUnowned -> detachSurfaceLater a few frames after android
re-creates the surface, but that will early-out without posting.  the unowned
surface isn't attached.

+        }
+
         mRenderHost.onSwapBuffersCompleted(pendingSwapBuffersCount);
     }
 
     /**
      * Converts the layout into compositor layers. This is to be called on every frame the layout
      * is changing.
      * @param provider               Provides the layout to be rendered.
      * @param forRotation            Whether or not this is a special draw during a rotation.
      */
     public void finalizeLayers(final LayoutProvider provider, boolean forRotation,
@@ skipping 23 matching lines @@
                 provider.getUpdatedActiveSceneLayer(mLayerTitleCache, mTabContentManager,
                 mResourceManager, provider.getFullscreenManager());
 
         nativeSetSceneLayer(mNativeCompositorView, sceneLayer);
 
         TabModelImpl.flushActualTabSwitchLatencyMetric();
         nativeFinalizeLayers(mNativeCompositorView);
         TraceEvent.end("CompositorView:finalizeLayers");
     }
 
+    @Override
+    public void setWillNotDraw(boolean willNotDraw) {
+        mWillNotDraw = willNotDraw;
+        if (mCompositorSurfaceManager != null) {
+            mCompositorSurfaceManager.setWillNotDraw(mWillNotDraw);
+        }
+    }
+
+    @Override
+    public void setBackgroundDrawable(Drawable background) {
+        // We override setBackgroundDrawable since that's the common entry point from all the
+        // setBackground* calls in View.  We still call to setBackground on the SurfaceView because
+        // SetBackgroundDrawable is depricated, and the semantics are the same I think.

[Ted C, 2017/02/06 18:44:17]

depr[e]cated

[liberato (no reviews please), 2017/02/14 17:22:24]

Done.

+        super.setBackgroundDrawable(background);

[Ted C, 2017/02/06 18:44:17]

should we actually set the drawable in both places?  That would result in double
drawing.  Here, I "don't" think we should actually call into super.  Maybe just
super.setBackgroundDrawable(null) or something?

[liberato (no reviews please), 2017/02/14 17:22:24]

i think that we should.  i tried with / without both of these, along with some
other variations (setting compositor to 0 all the time, etc.), and we get
visible artifacts on startup.

the background drawable is set to 0 once we get some compositor frames anyway. 
so, i think that if there is double drawing, it's only for a frame or two during
startup.

so, if it's okay with you, i think that we should keep it.

+        if (mCompositorSurfaceManager != null) {
+            mCompositorSurfaceManager.setBackgroundDrawable(background);
+        }
+    }
+
     // Implemented in native
     private native long nativeInit(boolean lowMemDevice, long nativeWindowAndroid,
             LayerTitleCache layerTitleCache, TabContentManager tabContentManager);
     private native void nativeDestroy(long nativeCompositorView);
     private native ResourceManager nativeGetResourceManager(long nativeCompositorView);
     private native void nativeSurfaceCreated(long nativeCompositorView);
     private native void nativeSurfaceDestroyed(long nativeCompositorView);
     private native void nativeSurfaceChanged(
             long nativeCompositorView, int format, int width, int height, Surface surface);
     private native void nativeFinalizeLayers(long nativeCompositorView);
     private native void nativeSetNeedsComposite(long nativeCompositorView);
     private native void nativeSetLayoutBounds(long nativeCompositorView);
     private native void nativeSetOverlayVideoMode(long nativeCompositorView, boolean enabled);
     private native void nativeSetSceneLayer(long nativeCompositorView, SceneLayer sceneLayer);
 }