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 mLowmMemoryDevice;

[David Trainor- moved to gerrit, 2017/01/19 22:08:22]

Looks like this is no longer used.

[liberato (no reviews please), 2017/01/20 17:50:46]

Done.

+    private boolean mAlwaysTranslucent;
+    private int mCurrentPixelFormat;
+
+    // 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.
      * @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
+        // 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
+        // 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);
+        // Make sure that the current pixel format does not match what we're requesting, so that we
+        // actually request a surface.
+        mCurrentPixelFormat = PixelFormat.UNKNOWN;
+        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;
+        int newFormat = getSurfacePixelFormat();
+        if (newFormat == mCurrentPixelFormat) {
+            // Don't bother to request a surface, but instead re-use this one.
+            if (mNativeCompositorView != 0) {
+                // Restart the compositor so that it knows about the new format.  Otherwise, nothing
+                // will update the EGL surface.
+                nativeSurfaceDestroyed(mNativeCompositorView);
+                nativeSurfaceCreated(mNativeCompositorView);

[David Trainor- moved to gerrit, 2017/01/19 22:08:22]

Hey sorry, could you clarify what this does for me?  Are we guaranteed to get a
surfaceChanged() call after this?

[liberato (no reviews please), 2017/01/20 17:50:46]

on low memory devices, there's no need to switch the surface format -- it's
always translucent.  this just lets the compositor switch the compositor's EGL
surface between 565 and 8888, based on whatever we provided to
nativeSetOverlayVideoMode.

surfaceChanged: we won't get one.  probably should call nativeSurfaceChanged
here, shouldn't we?

good catch.

+            }
+            return;
+        }
+
+        // We're actually switching formats.
+        mCurrentPixelFormat = newFormat;
+        mCompositorSurfaceManager.requestSurface(newFormat);
+        // 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.
+        // However, they might be elided entirely if we switch fast enough that we never destroy the
+        // first surface before we request the other, then request the first back.  In that case,
+        // the compositor will be back in the right mode too, and it's fine to elide these.  Of
+        // course, we have to work whether it calls us back or not.
+    }
+
+    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();
+        }
+
         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.
+        super.setBackgroundDrawable(background);
+        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);
 }