Add layerTreeBuildHelper to control layer tree in ContentViewRenderView

content/public/android/java/src/org/chromium/content/browser/ContentViewRenderView.java

 // Copyright 2012 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.content.browser;
 
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
@@ skipping 25 matching lines @@
     private long mNativeContentViewRenderView;
     private final SurfaceHolder.Callback mSurfaceCallback;
 
     private final SurfaceView mSurfaceView;
     private final VSyncAdapter mVSyncAdapter;
 
     private int mPendingRenders;
     private int mPendingSwapBuffers;
     private boolean mNeedToRender;
 
-    private ContentView mCurrentContentView;
+    protected ContentView mCurrentContentView;
 
     private final Runnable mRenderRunnable = new Runnable() {
         @Override
         public void run() {
             render();
         }
     };
 
     /**
      * Constructs a new ContentViewRenderView that should be can to a view hierarchy.
      * Native code should add/remove the layers to be rendered through the ContentViewLayerRenderer.
      * @param context The context used to create this.
      */
     public ContentViewRenderView(Context context, WindowAndroid rootWindow) {
         super(context);
         assert rootWindow != null;
-        mNativeContentViewRenderView = nativeInit(rootWindow.getNativePointer());
+        nativeInit(rootWindow.getNativePointer());
         assert mNativeContentViewRenderView != 0;
 
         mSurfaceView = createSurfaceView(getContext());
         mSurfaceView.setZOrderMediaOverlay(true);
         mSurfaceCallback = new SurfaceHolder.Callback() {
             @Override
             public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
                 assert mNativeContentViewRenderView != 0;
                 nativeSurfaceChanged(mNativeContentViewRenderView,
                         format, width, height, holder.getSurface());
                 if (mCurrentContentView != null) {
                     mCurrentContentView.getContentViewCore().onPhysicalBackingSizeChanged(
                             width, height);
                 }
             }
 
             @Override
             public void surfaceCreated(SurfaceHolder holder) {
-                setSurfaceViewBackgroundColor(Color.WHITE);
-
-                assert mNativeContentViewRenderView != 0;
-                nativeSurfaceCreated(mNativeContentViewRenderView);
-
-                mPendingSwapBuffers = 0;
-                mPendingRenders = 0;
-
+                ContentViewRenderView.this.surfaceCreated();
                 onReadyToRender();
             }
 
             @Override
             public void surfaceDestroyed(SurfaceHolder holder) {
                 assert mNativeContentViewRenderView != 0;
                 nativeSurfaceDestroyed(mNativeContentViewRenderView);
             }
         };
         mSurfaceView.getHolder().addCallback(mSurfaceCallback);
 
         mVSyncAdapter = new VSyncAdapter(getContext());
         addView(mSurfaceView,
                 new FrameLayout.LayoutParams(
                         FrameLayout.LayoutParams.MATCH_PARENT,
                         FrameLayout.LayoutParams.MATCH_PARENT));
     }
 
+    @CalledByNative
+    private void clearNativePtr() {
+        assert mNativeContentViewRenderView != 0;
+        mNativeContentViewRenderView = 0;
+    }
+
+    @CalledByNative
+    private void setNativePtr(long nativePtr) {
+        assert mNativeContentViewRenderView == 0;
+        mNativeContentViewRenderView = nativePtr;
+    }
+
     private class VSyncAdapter implements VSyncManager.Provider, VSyncMonitor.Listener {
         private final VSyncMonitor mVSyncMonitor;
         private boolean mVSyncNotificationEnabled;
         private VSyncManager.Listener mVSyncListener;
         private final ObserverList<VSyncManager.Listener> mCurrentVSyncListeners;
         private final RewindableIterator<VSyncManager.Listener> mCurrentVSyncListenersIterator;
 
         // The VSyncMonitor gives the timebase for the actual vsync, but we don't want render until
         // we have had a chance for input events to propagate to the compositor thread. This takes
         // 3 ms typically, so we adjust the vsync timestamps forward by a bit to give input events a
@@ skipping 93 matching lines @@
         mCurrentContentView = contentView;
 
         ContentViewCore contentViewCore =
                 contentView != null ? contentView.getContentViewCore() : null;
 
         nativeSetCurrentContentView(mNativeContentViewRenderView,
                 contentViewCore != null ? contentViewCore.getNativeContentViewCore() : 0);
 
         if (contentViewCore != null) {
             contentViewCore.onPhysicalBackingSizeChanged(getWidth(), getHeight());
-            mVSyncAdapter.setVSyncListener(contentViewCore.getVSyncListener(mVSyncAdapter));
+            setVSyncListener(contentViewCore);
         }
     }
 
     /**
      * This method should be subclassed to provide actions to be performed once the view is ready to
      * render.
      */
     protected void onReadyToRender() {
     }
 
     /**
+     * Gives inheriting classes a way to carry out tasks on the surfaceCreated() call
+     * for mSurfaceCallback.
+     */
+    protected void surfaceCreated() {
+        setSurfaceViewBackgroundColor(Color.WHITE);
+
+        assert mNativeContentViewRenderView != 0;
+        nativeSurfaceCreated(mNativeContentViewRenderView);
+
+        mPendingSwapBuffers = 0;
+        mPendingRenders = 0;
+    }
+
+    /**
      * This method could be subclassed optionally to provide a custom SurfaceView object to
      * this ContentViewRenderView.
      * @param context The context used to create the SurfaceView object.
      * @return The created SurfaceView object.
      */
     protected SurfaceView createSurfaceView(Context context) {
         return new SurfaceView(context) {
             @Override
             public void onDraw(Canvas canvas) {
                 // We only need to draw to software canvases, which are used for taking screenshots.
                 if (canvas.isHardwareAccelerated()) return;
                 Bitmap bitmap = Bitmap.createBitmap(getWidth(), getHeight(),
                         Bitmap.Config.ARGB_8888);
                 if (nativeCompositeToBitmap(mNativeContentViewRenderView, bitmap)) {
                     canvas.drawBitmap(bitmap, 0, 0, null);
                 }
             }
         };
     }
 
     /**
      * @return whether the surface view is initialized and ready to render.
      */
     public boolean isInitialized() {
         return mSurfaceView.getHolder().getSurface() != null;
     }
 
     /**
+     * Sets the VSyncListener to mVSync adapter to the provided listener from the
+     * given ContentViewCore.
+     * @param contentViewCore ContentViewCore instance go get the listener from.
+     */
+    protected void setVSyncListener(ContentViewCore contentViewCore) {
+        mVSyncAdapter.setVSyncListener(contentViewCore.getVSyncListener(mVSyncAdapter));
+    }
+
+    /**
      * Enter or leave overlay video mode.
      * @param enabled Whether overlay mode is enabled.
      */
     public void setOverlayVideoMode(boolean enabled) {
         int format = enabled ? PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE;
         mSurfaceView.getHolder().setFormat(format);
         nativeSetOverlayVideoMode(mNativeContentViewRenderView, enabled);
     }
 
     @CalledByNative
@@ skipping 28 matching lines @@
     }
 
     @CalledByNative
     private void onSwapBuffersCompleted() {
         TraceEvent.instant("onSwapBuffersCompleted");
 
         if (mPendingSwapBuffers == MAX_SWAP_BUFFER_COUNT && mNeedToRender) requestRender();
         if (mPendingSwapBuffers > 0) mPendingSwapBuffers--;
     }
 
-    private void render() {
+    /**
+     * Calls Composite on the native side, finishing the compositing task for current frame.
+     */
+    protected void render() {
         if (mPendingRenders > 0) mPendingRenders--;
 
         // Waiting for the content view contents to be ready avoids compositing
         // when the surface texture is still empty.
         if (mCurrentContentView == null) return;
         ContentViewCore contentViewCore = mCurrentContentView.getContentViewCore();
         if (contentViewCore == null || !contentViewCore.isReady()) {
             return;
         }
 
         boolean didDraw = nativeComposite(mNativeContentViewRenderView);
         if (didDraw) {
             mPendingSwapBuffers++;
             if (mSurfaceView.getBackground() != null) {
                 post(new Runnable() {
                     @Override
                     public void run() {
                         mSurfaceView.setBackgroundResource(0);
                     }
                 });
             }
         }
     }
 
-    private native long nativeInit(long rootWindowNativePointer);
+    private native void nativeInit(long rootWindowNativePointer);
     private native void nativeDestroy(long nativeContentViewRenderView);
     private native void nativeSetCurrentContentView(long nativeContentViewRenderView,
             long nativeContentView);
     private native void nativeSurfaceCreated(long nativeContentViewRenderView);
     private native void nativeSurfaceDestroyed(long nativeContentViewRenderView);
     private native void nativeSurfaceChanged(long nativeContentViewRenderView,
             int format, int width, int height, Surface surface);
     private native boolean nativeComposite(long nativeContentViewRenderView);
     private native boolean nativeCompositeToBitmap(long nativeContentViewRenderView, Bitmap bitmap);
     private native void nativeSetOverlayVideoMode(long nativeContentViewRenderView,
             boolean enabled);
 }