Fix CompositorSurfaceManager synthetic surfaceCreated arg order.

chrome/android/junit/src/org/chromium/chrome/browser/compositor/CompositorSurfaceManagerTest.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.app.Activity;
 import android.graphics.PixelFormat;
 import android.view.Surface;
 import android.view.SurfaceHolder;
@@ skipping 35 matching lines @@
 @RunWith(LocalRobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class CompositorSurfaceManagerTest {
     @Mock
     private CompositorSurfaceManager.SurfaceHolderCallbackTarget mCallback;
 
     private CompositorSurfaceManager mManager;
 
     private FrameLayout mLayout;
 
+    // surfaceChanged parameters chosen by most recent sendSurfaceChanged.
+    private int mActualFormat;
+    private int mWidth;
+    private int mHeight;
+
     /**
      * Implementation of a SurfaceView shadow that provides additional functionality for controlling
      * the state of the underlying (fake) Surface.
      */
     @Implements(SurfaceView.class)
     public static class MyShadowSurfaceView extends ShadowSurfaceView {
         private final MyFakeSurfaceHolder mHolder = new MyFakeSurfaceHolder();
 
         /**
          * Robolectric's FakeSurfaceHolder doesn't keep track of the format, etc.
@@ skipping 113 matching lines @@
     }
 
     /**
      * Request format |format|, and send created / changed callbacks to |mManager| as if Android
      * had provided the underlying Surface.
      */
     private SurfaceView requestThenCreateSurface(int format) {
         SurfaceView view = requestSurface(format);
         setSurfaceValid(view, true);
         callbackFor(view).surfaceCreated(view.getHolder());
-        final int actualFormat =
-                (format == PixelFormat.OPAQUE) ? PixelFormat.RGB_565 : PixelFormat.RGBA_8888;
-        final int width = 320;
-        final int height = 240;
-        callbackFor(view).surfaceChanged(view.getHolder(), actualFormat, width, height);
+        sendSurfaceChanged(view, format, 320, 240);
 
         return view;
     }
 
+    /**
+     * Send a surfaceChanged event with the given parameters.
+     */
+    private void sendSurfaceChanged(SurfaceView view, int format, int width, int height) {
+        mActualFormat =
+                (format == PixelFormat.OPAQUE) ? PixelFormat.RGB_565 : PixelFormat.RGBA_8888;
+        mWidth = width;
+        mHeight = height;
+        callbackFor(view).surfaceChanged(view.getHolder(), mActualFormat, mWidth, mHeight);
+    }
+
     @Test
     @Feature("Compositor")
     @Config(shadows = {MyShadowSurfaceView.class})
     public void testRequestOpaqueSurface() {
         // Request a SurfaceView, and test in detail that it worked.
         SurfaceView opaque = requestSurface(PixelFormat.OPAQUE);
         verify(mCallback, times(0)).surfaceCreated(ArgumentMatchers.<SurfaceHolder>any());
         verify(mCallback, times(0))
                 .surfaceChanged(
                         ArgumentMatchers.<SurfaceHolder>any(), anyInt(), anyInt(), anyInt());
         verify(mCallback, times(0)).surfaceDestroyed(ArgumentMatchers.<SurfaceHolder>any());
 
         // Check that there's an opaque SurfaceView .
         assertEquals(1, mLayout.getChildCount());
         assertTrue(fakeHolderFor(opaque).getFormat() == PixelFormat.OPAQUE);
 
         // Verify that we are notified when the surface is created.
         callbackFor(opaque).surfaceCreated(opaque.getHolder());
-        verify(mCallback, times(1)).surfaceCreated(opaque.getHolder());
+        verify(mCallback, times(1)).surfaceCreated(eq(opaque.getHolder()));
         verify(mCallback, times(0)).surfaceDestroyed(ArgumentMatchers.<SurfaceHolder>any());
 
         // Verify that we are notified when the surface is changed.
-        final int format = PixelFormat.RGB_565;
-        final int width = 320;
-        final int height = 240;
-        callbackFor(opaque).surfaceChanged(opaque.getHolder(), format, width, height);
-        verify(mCallback, times(1)).surfaceCreated(opaque.getHolder());
-        verify(mCallback, times(1)).surfaceChanged(opaque.getHolder(), format, width, height);
+        sendSurfaceChanged(opaque, PixelFormat.OPAQUE, 320, 240);
+        verify(mCallback, times(1)).surfaceCreated(eq(opaque.getHolder()));
+        verify(mCallback, times(1))
+                .surfaceChanged(eq(opaque.getHolder()), eq(mActualFormat), eq(mWidth), eq(mHeight));
         verify(mCallback, times(0)).surfaceDestroyed(ArgumentMatchers.<SurfaceHolder>any());
 
         // Verify that we are notified when the surface is destroyed.
         callbackFor(opaque).surfaceDestroyed(opaque.getHolder());
-        verify(mCallback, times(1)).surfaceCreated(opaque.getHolder());
-        verify(mCallback, times(1)).surfaceChanged(opaque.getHolder(), format, width, height);
-        verify(mCallback, times(1)).surfaceDestroyed(opaque.getHolder());
+        verify(mCallback, times(1)).surfaceCreated(eq(opaque.getHolder()));
+        verify(mCallback, times(1))
+                .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
+        verify(mCallback, times(1)).surfaceDestroyed(eq(opaque.getHolder()));
     }
 
     @Test
     @Feature("Compositor")
     @Config(shadows = {MyShadowSurfaceView.class})
     public void testRequestOpaqueThenTranslucentSurface() {
         // Request opaque then translucent.
         SurfaceView opaque = requestThenCreateSurface(PixelFormat.OPAQUE);
         SurfaceView translucent = requestThenCreateSurface(PixelFormat.TRANSLUCENT);
 
@@ skipping 13 matching lines @@
         assertNotNull(findSurface(PixelFormat.TRANSLUCENT));
     }
 
     @Test
     @Feature("Compositor")
     @Config(shadows = {MyShadowSurfaceView.class})
     public void testRequestSameSurface() {
         // Request an opaque surface, get it, then request it again.  Verify that we get synthetic
         // create / destroy callbacks.
         SurfaceView opaque = requestThenCreateSurface(PixelFormat.OPAQUE);
-        verify(mCallback, times(1)).surfaceCreated(opaque.getHolder());
+        verify(mCallback, times(1)).surfaceCreated(eq(opaque.getHolder()));
         verify(mCallback, times(1))
                 .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
         verify(mCallback, times(0)).surfaceDestroyed(opaque.getHolder());
 
-        // Surface is curerntly valid.  Request again.  We should get back a destroy and create.
+        // Surface is currently valid.  Request again.  We should get back a destroy and create.
         assertEquals(opaque, requestSurface(PixelFormat.OPAQUE));
         verify(mCallback, times(2)).surfaceCreated(opaque.getHolder());
         verify(mCallback, times(2))
-                .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
-        verify(mCallback, times(1)).surfaceDestroyed(opaque.getHolder());
+                .surfaceChanged(eq(opaque.getHolder()), eq(mActualFormat), eq(mWidth), eq(mHeight));
+        verify(mCallback, times(1)).surfaceDestroyed(eq(opaque.getHolder()));
         assertEquals(1, mLayout.getChildCount());
     }
 
     @Test
     @Feature("Compositor")
     @Config(shadows = {MyShadowSurfaceView.class})
     public void testRequestSameSurfaceBeforeReady() {
         // Request an opaque surface, then request it again before the first one shows up.
         SurfaceView opaque = requestSurface(PixelFormat.OPAQUE);
         verify(mCallback, times(0)).surfaceCreated(opaque.getHolder());
         verify(mCallback, times(0))
                 .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
         verify(mCallback, times(0)).surfaceDestroyed(opaque.getHolder());
 
         // Request again.  We shouldn't get any callbacks, since the surface is still pending.
         assertEquals(opaque, requestSurface(PixelFormat.OPAQUE));
         verify(mCallback, times(0)).surfaceCreated(opaque.getHolder());
         verify(mCallback, times(0))
                 .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
         verify(mCallback, times(0)).surfaceDestroyed(opaque.getHolder());
 
         // Only the opaque view should be attached.
         assertEquals(1, mLayout.getChildCount());
 
         // When the surface is created, we should get notified created / changed, but not destroyed.
         callbackFor(opaque).surfaceCreated(opaque.getHolder());
         verify(mCallback, times(1)).surfaceCreated(opaque.getHolder());
 
-        callbackFor(opaque).surfaceChanged(opaque.getHolder(), PixelFormat.RGB_565, 320, 240);
+        sendSurfaceChanged(opaque, PixelFormat.RGB_565, 320, 240);
         verify(mCallback, times(1))
-                .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
+                .surfaceChanged(eq(opaque.getHolder()), eq(mActualFormat), eq(mWidth), eq(mHeight));
         verify(mCallback, times(0)).surfaceDestroyed(opaque.getHolder());
     }
 
     @Test
     @Feature("Compositor")
     @Config(shadows = {MyShadowSurfaceView.class})
     public void testRequestDifferentSurfacesBeforeReady() {
         // Request an opaque surface, then request the translucent one before the it one shows up.
         SurfaceView opaque = requestSurface(PixelFormat.OPAQUE);
         verify(mCallback, times(0)).surfaceCreated(opaque.getHolder());
@@ skipping 39 matching lines @@
 
         // Re-request while 'changed' is still pending.  We should get a synthetic 'destroyed' and
         // synthetic 'created'.
         assertEquals(opaque, requestSurface(PixelFormat.OPAQUE));
         verify(mCallback, times(2)).surfaceCreated(opaque.getHolder());
         verify(mCallback, times(1)).surfaceDestroyed(opaque.getHolder());
         verify(mCallback, times(0))
                 .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
 
         // Send 'changed', and expect that we'll receive it.
-        callbackFor(opaque).surfaceChanged(opaque.getHolder(), PixelFormat.RGB_565, 320, 240);
+        sendSurfaceChanged(opaque, PixelFormat.OPAQUE, 320, 240);
         verify(mCallback, times(1))
-                .surfaceChanged(eq(opaque.getHolder()), anyInt(), anyInt(), anyInt());
+                .surfaceChanged(eq(opaque.getHolder()), eq(mActualFormat), eq(mWidth), eq(mHeight));
     }
 
     @Test
     @Feature("Compositor")
     @Config(shadows = {MyShadowSurfaceView.class})
     public void testJellyBeanWorkaround() {
         // See if recreateSurfaceForJellyBean destroys / re-creates the surface.
         // should get a synthetic 'created', but a real 'changed' callback.
         SurfaceView opaque = requestThenCreateSurface(PixelFormat.OPAQUE);
         verify(mCallback, times(1)).surfaceCreated(opaque.getHolder());
@@ skipping 51 matching lines @@
 
         // When the opaque surface becomes available, we'll get the synthetic destroy for the
         // translucent one that we lost ownership of, and the real create for the opaque one.
         callbackFor(opaque).surfaceCreated(opaque.getHolder());
         assertEquals(2, mLayout.getChildCount());
         verify(mCallback, times(2)).surfaceCreated(opaque.getHolder());
         verify(mCallback, times(1)).surfaceDestroyed(opaque.getHolder());
         verify(mCallback, times(1)).surfaceDestroyed(translucent.getHolder());
     }
 }