[Android WebView] Add tests to check whether the hole punching works.

android_webview/java/src/org/chromium/android_webview/ExternalVideoSurfaceContainer.java

 // Copyright 2014 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.android_webview;
 
 import android.content.Context;
 import android.graphics.Canvas;
 import android.view.Surface;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.ViewGroup;
 
+import com.google.common.annotations.VisibleForTesting;
+
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.content.browser.ContentViewCore;
 import org.chromium.content.browser.RenderCoordinates;
 
 import java.lang.ref.WeakReference;
 
 /**
  * This is a container for external video surfaces.
  * The object is owned by the native peer and it is owned by WebContents.
  *
  * The expected behavior of the media player on the video hole punching is as follows.
  * 1) If it requests the surface, it will call requestExternalVideoSurface().
  *    When the resolution of the video is changed, it'll call requestExternalVideoSurface().
  * 2) Whenever the size or the position of the video element is changed, it'll notify through
  *    onExternalVideoSurfacePositionChanged().
  * 3) Whenever the page that contains the video element is scrolled or zoomed,
  *    onFrameInfoUpdated() will be called.
  * 4) Usually steps 1) ~ 3) are repeated during the playback.
  * 5) If the player no longer needs the surface any more, it'll call
  *    releaseExternalVideoSurface().
  *
  * Please contact ycheo@chromium.org or wonsik@chromium.org if you have any
  * questions or issues for this class.
  */
 @JNINamespace("android_webview")
 public class ExternalVideoSurfaceContainer implements SurfaceHolder.Callback {
-    private static final int INVALID_PLAYER_ID = -1;
+    protected static final int INVALID_PLAYER_ID = -1;
 
     // Because WebView does hole-punching by itself, instead, the hole-punching logic
     // in SurfaceView can clear out some web elements like media control or subtitle.
     // So we need to disable its hole-punching logic.
     private static class NoPunchingSurfaceView extends SurfaceView {
         public NoPunchingSurfaceView(Context context) {
             super(context);
         }
         // SurfaceView.dispatchDraw implementation punches a hole in the view hierarchy.
         // Disable this by making this a no-op.
@@ skipping 19 matching lines @@
     private float mTop;
     private float mRight;
     private float mBottom;
 
     // The physical location/size of the external video surface in pixels.
     private int mX;
     private int mY;
     private int mWidth;
     private int mHeight;
 
+    /**
+     * Factory class to facilitate dependency injection.
+     */
+    public static class Factory {
+        public ExternalVideoSurfaceContainer create(
+                int nativeExternalVideoSurfaceContainer, ContentViewCore contentViewCore) {
+            return new ExternalVideoSurfaceContainer(
+                    nativeExternalVideoSurfaceContainer, contentViewCore);
+        }
+    }
+    private static Factory sFactory = new Factory();
+
+    @VisibleForTesting
+    public static void setFactory(Factory factory) {
+        sFactory = factory;
+    }
+
     @CalledByNative
     private static ExternalVideoSurfaceContainer create(
             int nativeExternalVideoSurfaceContainer, ContentViewCore contentViewCore) {
-        return new ExternalVideoSurfaceContainer(
-                nativeExternalVideoSurfaceContainer, contentViewCore);
+        return sFactory.create(nativeExternalVideoSurfaceContainer, contentViewCore);
     }
 
-    private ExternalVideoSurfaceContainer(
+    protected ExternalVideoSurfaceContainer(
             int nativeExternalVideoSurfaceContainer, ContentViewCore contentViewCore) {
         assert contentViewCore != null;
         mNativeExternalVideoSurfaceContainer = nativeExternalVideoSurfaceContainer;
         mContentViewCore = contentViewCore;
         initializeCurrentPositionOfSurfaceView();
     }
 
     /**
      * Called when a media player wants to request an external video surface.
      * @param playerId The ID of the media player.
      */
     @CalledByNative
-    private void requestExternalVideoSurface(int playerId) {
+    protected void requestExternalVideoSurface(int playerId) {
         if (mPlayerId == playerId) return;
 
         if (mPlayerId == INVALID_PLAYER_ID) {
             setActiveContainer(this);
         }
 
         mPlayerId = playerId;
         initializeCurrentPositionOfSurfaceView();
 
         createSurfaceView();
     }
 
     /**
      * Called when a media player wants to release an external video surface.
      * @param playerId The ID of the media player.
      */
     @CalledByNative
-    private void releaseExternalVideoSurface(int playerId) {
+    protected void releaseExternalVideoSurface(int playerId) {
         if (mPlayerId != playerId) return;
 
         releaseIfActiveContainer(this);
 
         mPlayerId = INVALID_PLAYER_ID;
     }
 
     @CalledByNative
-    private void destroy() {
+    protected void destroy() {
         releaseExternalVideoSurface(mPlayerId);
     }
 
     private void initializeCurrentPositionOfSurfaceView() {
         mX = Integer.MIN_VALUE;
         mY = Integer.MIN_VALUE;
         mWidth = 0;
         mHeight = 0;
     }
 
@@ skipping 30 matching lines @@
     /**
      * Called when the position of the video element which uses the external
      * video surface is changed.
      * @param playerId The ID of the media player.
      * @param left The absolute CSS X coordinate of the left side of the video element.
      * @param top The absolute CSS Y coordinate of the top side of the video element.
      * @param right The absolute CSS X coordinate of the right side of the video element.
      * @param bottom The absolute CSS Y coordinate of the bottom side of the video element.
      */
     @CalledByNative
-    private void onExternalVideoSurfacePositionChanged(
+    protected void onExternalVideoSurfacePositionChanged(
             int playerId, float left, float top, float right, float bottom) {
         if (mPlayerId != playerId) return;
 
         mLeft = left;
         mTop = top;
         mRight = right;
         mBottom = bottom;
 
         layOutSurfaceView();
     }
 
     /**
      * Called when the page that contains the video element is scrolled or zoomed.
      */
     @CalledByNative
-    private void onFrameInfoUpdated() {
+    protected void onFrameInfoUpdated() {
         if (mPlayerId == INVALID_PLAYER_ID) return;
 
         layOutSurfaceView();
     }
 
     private void layOutSurfaceView() {
         RenderCoordinates renderCoordinates = mContentViewCore.getRenderCoordinates();
         RenderCoordinates.NormalizedPoint topLeft = renderCoordinates.createNormalizedPoint();
         RenderCoordinates.NormalizedPoint bottomRight = renderCoordinates.createNormalizedPoint();
         topLeft.setAbsoluteCss(mLeft, mTop);
@@ skipping 44 matching lines @@
         }
     }
 
     private native void nativeSurfaceCreated(
             long nativeExternalVideoSurfaceContainerImpl, int playerId, Surface surface);
 
     private native void nativeSurfaceDestroyed(
             long nativeExternalVideoSurfaceContainerImpl, int playerId);
 }