Change ITestClient to be similar to IChildProcessService.

base/test/android/java/src/org/chromium/base/MultiprocessTestClientLauncher.java

 // 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.base;
 
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
+import android.os.Bundle;
 import android.os.IBinder;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.process_launcher.FileDescriptorInfo;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
+import java.util.concurrent.CountDownLatch;
 
 import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Helper class for launching test client processes for multiprocess unit tests.
  */
 @JNINamespace("base::android")
 public final class MultiprocessTestClientLauncher {
     private static final String TAG = "cr_MProcTCLauncher";
 
@@ skipping 58 matching lines @@
                     if (connection.getPid() == pid) {
                         return connection;
                     }
                 }
             }
             return null;
         }
     }
 
     private static class ClientServiceConnection implements ServiceConnection {
-        private final String[] mCommandLine;
-        private final FileDescriptorInfo[] mFilesToMap;
+        private final Bundle mSetupBundle;
         private final Object mConnectedLock = new Object();
+        private final CountDownLatch mPidReceived = new CountDownLatch(1);
         private final int mSlot;
         private ITestClient mService = null;
         @GuardedBy("mConnectedLock")
         private boolean mConnected;
         private int mPid;
+        private ITestController mTestController;
+        private final ITestCallback.Stub mCallback = new ITestCallback.Stub() {
+            public void childConnected(ITestController controller) {
+                mTestController = controller;
+                // This method can be called before onServiceConnected below has set the PID.
+                // Wait for mPid to be set before notifying.
+                try {
+                    mPidReceived.await();
+                } catch (InterruptedException ie) {
+                    Log.e(TAG, "Interrupted while waiting for connection PID.");
+                    return;
+                }
+                // Now we are fully initialized, notify clients.
+                synchronized (mConnectedLock) {
+                    mConnected = true;
+                    mConnectedLock.notifyAll();
+                }
+            }
+        };
 
         ClientServiceConnection(int slot, String[] commandLine, FileDescriptorInfo[] filesToMap) {
             mSlot = slot;
-            mCommandLine = commandLine;
-            mFilesToMap = filesToMap;
+            mSetupBundle = new Bundle();
+            mSetupBundle.putStringArray(ChildProcessConstants.EXTRA_COMMAND_LINE, commandLine);
+            mSetupBundle.putParcelableArray(ChildProcessConstants.EXTRA_FILES, filesToMap);
         }
 
         public void waitForConnection() {
             synchronized (mConnectedLock) {
                 while (!mConnected) {
                     try {
                         mConnectedLock.wait();
                     } catch (InterruptedException ie) {
                         Log.e(TAG, "Interrupted while waiting for connection.");
                     }
                 }
             }
         }
 
         @Override
         public void onServiceConnected(ComponentName className, IBinder service) {
             try {
                 mService = ITestClient.Stub.asInterface(service);
-                mPid = mService.launch(mCommandLine, mFilesToMap);
-                synchronized (mConnectedLock) {
-                    mConnected = true;
-                    mConnectedLock.notifyAll();
+                if (!mService.bindToCaller()) {
+                    Log.e(TAG, "Failed to bind to child service");
+                    return;
                 }
+                mPid = mService.setupConnection(mSetupBundle, mCallback);
+                mPidReceived.countDown();
             } catch (RemoteException e) {
                 Log.e(TAG, "Connect failed");
             }
         }
 
         @Override
         public void onServiceDisconnected(ComponentName className) {
             if (mPid == 0) {
                 Log.e(TAG, "Early ClientServiceConnection disconnection.");
                 return;
             }
             sConnectionAllocator.freeConnection(this);
         }
 
-        public ITestClient getService() {
-            return mService;
+        public ITestController getTestController() {
+            return mTestController;
         }
 
         public String getServiceClassName() {
             // In order to use different processes, we have to declare multiple services in the
             // AndroidManifest.xml file, each service associated with its own process. The various
             // services are functionnaly identical but need to each have their own class.
             // We differentiate them by their class name having a trailing number.
             return MultiprocessTestClientService.class.getName() + mSlot;
         }
 
@@ skipping 57 matching lines @@
      * @return the return code returned by the main method or whether it timed-out.
      */
     @CalledByNative
     private static MainReturnCodeResult waitForMainToReturn(int pid, int timeoutMs) {
         ClientServiceConnection connection = sConnectionAllocator.getConnectionByPid(pid);
         if (connection == null) {
             Log.e(TAG, "waitForMainToReturn called on unknown connection for pid " + pid);
             return null;
         }
         try {
-            return connection.getService().waitForMainToReturn(timeoutMs);
+            return connection.getTestController().waitForMainToReturn(timeoutMs);
         } catch (RemoteException e) {
             Log.e(TAG, "Remote call to waitForMainToReturn failed.");
             return null;
         } finally {
             freeConnection(connection);
         }
     }
 
     @CalledByNative
     private static boolean terminate(int pid, int exitCode, boolean wait) {
         ClientServiceConnection connection = sConnectionAllocator.getConnectionByPid(pid);
         if (connection == null) {
             Log.e(TAG, "terminate called on unknown connection for pid " + pid);
             return false;
         }
         try {
             if (wait) {
-                connection.getService().forceStopSynchronous(exitCode);
+                connection.getTestController().forceStopSynchronous(exitCode);
             } else {
-                connection.getService().forceStop(exitCode);
+                connection.getTestController().forceStop(exitCode);
             }
         } catch (RemoteException e) {
             // We expect this failure, since the forceStop's service implementation calls
             // System.exit().
         } finally {
             freeConnection(connection);
         }
         return true;
     }
 
@@ skipping 21 matching lines @@
         ParcelFileDescriptor parcelableFd = null;
         try {
             parcelableFd = ParcelFileDescriptor.fromFd(fd);
         } catch (IOException e) {
             Log.e(TAG, "Invalid FD provided for process connection, aborting connection.", e);
             return null;
         }
         return new FileDescriptorInfo(id, parcelableFd, 0 /* offset */, 0 /* size */);
     }
 }