Revert of Android: Remove GetApplicationContext part 2

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;
@@ skipping 162 matching lines @@
 
         public int getPid() {
             return mPid;
         }
     }
 
     /**
      * Spawns and connects to a child process.
      * May not be called from the main thread.
      *
+     * @param context context used to obtain the application context.
      * @param commandLine the child process command line argv.
      * @return the PID of the started process or 0 if the process could not be started.
      */
     @CalledByNative
-    private static int launchClient(
-            final String[] commandLine, final FileDescriptorInfo[] filesToMap) {
+    private static int launchClient(final Context context, final String[] commandLine,
+            final FileDescriptorInfo[] filesToMap) {
         if (ThreadUtils.runningOnUiThread()) {
             // This can't be called on the main thread as the native side will block until
             // onServiceConnected above is called, which cannot happen if the main thread is
             // blocked.
             throw new RuntimeException("launchClient cannot be called on the main thread");
         }
 
         ClientServiceConnection connection =
                 sConnectionAllocator.allocateConnection(commandLine, filesToMap);
         Intent intent = new Intent();
         String className = connection.getServiceClassName();
-        String packageName = ContextUtils.getApplicationContext().getPackageName();
-        intent.setComponent(new ComponentName(packageName, className));
-        if (!ContextUtils.getApplicationContext().bindService(
+        intent.setComponent(new ComponentName(context.getPackageName(), className));
+        if (!context.bindService(
                     intent, connection, Context.BIND_AUTO_CREATE | Context.BIND_IMPORTANT)) {
-            Log.e(TAG, "Failed to bind service: " + packageName + "." + className);
+            Log.e(TAG, "Failed to bind service: " + context.getPackageName() + "." + className);
             sConnectionAllocator.freeConnection(connection);
             return 0;
         }
 
         connection.waitForConnection();
 
         return connection.getPid();
     }
 
     /**
      * Blocks until the main method invoked by a previous call to launchClient terminates or until
      * the specified time-out expires.
      * Returns immediately if main has already returned.
+     * @param context context used to obtain the application context.
      * @param pid the process ID that was returned by the call to launchClient
      * @param timeoutMs the timeout in milliseconds after which the method returns even if main has
      *        not returned.
      * @return the return code returned by the main method or whether it timed-out.
      */
     @CalledByNative
-    private static MainReturnCodeResult waitForMainToReturn(int pid, int timeoutMs) {
+    private static MainReturnCodeResult waitForMainToReturn(
+            Context context, 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);
         } catch (RemoteException e) {
             Log.e(TAG, "Remote call to waitForMainToReturn failed.");
             return null;
         } finally {
-            freeConnection(connection);
+            freeConnection(context, connection);
         }
     }
 
     @CalledByNative
-    private static boolean terminate(int pid, int exitCode, boolean wait) {
+    private static boolean terminate(Context context, 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);
             } else {
                 connection.getService().forceStop(exitCode);
             }
         } catch (RemoteException e) {
             // We expect this failure, since the forceStop's service implementation calls
             // System.exit().
         } finally {
-            freeConnection(connection);
+            freeConnection(context, connection);
         }
         return true;
     }
 
-    private static void freeConnection(ClientServiceConnection connection) {
-        ContextUtils.getApplicationContext().unbindService(connection);
+    private static void freeConnection(Context context, ClientServiceConnection connection) {
+        context.unbindService(connection);
         sConnectionAllocator.freeConnection(connection);
     }
 
     /** Does not take ownership of of fds. */
     @CalledByNative
     private static FileDescriptorInfo[] makeFdInfoArray(int[] keys, int[] fds) {
         FileDescriptorInfo[] fdInfos = new FileDescriptorInfo[keys.length];
         for (int i = 0; i < keys.length; i++) {
             FileDescriptorInfo fdInfo = makeFdInfo(keys[i], fds[i]);
             if (fdInfo == null) {
                 Log.e(TAG, "Failed to make file descriptor (" + keys[i] + ", " + fds[i] + ").");
                 return null;
             }
             fdInfos[i] = fdInfo;
         }
         return fdInfos;
     }
 
     private static FileDescriptorInfo makeFdInfo(int id, int fd) {
         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 */);
     }
 }