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 18 matching lines @@
  */
 @JNINamespace("base::android")
 public final class MultiprocessTestClientLauncher {
     private static final String TAG = "cr_MProcTCLauncher";
 
     private static ConnectionAllocator sConnectionAllocator = new ConnectionAllocator();
 
     // Not supposed to be instantiated.
     private MultiprocessTestClientLauncher() {}
 
+    /**
+     * Spawns and connects to a child process.
+     * May not be called from the main thread.
+     *
+     * @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(

[agrieve, 2017/03/31 14:34:28]

Not sure if this was caused by you or a cl in between, but there's a huge diff
on this one because the methods have moved. Could you try and fix this up?

[Peter Wen, 2017/04/04 19:08:36]

Done.

+            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, connection, Context.BIND_AUTO_CREATE | Context.BIND_IMPORTANT)) {
+            Log.e(TAG, "Failed to bind service: " + packageName + "." + 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 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) {
+        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);
+        }
+    }
+
+    @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);
+            } else {
+                connection.getService().forceStop(exitCode);
+            }
+        } catch (RemoteException e) {
+            // We expect this failure, since the forceStop's service implementation calls
+            // System.exit().
+        } finally {
+            freeConnection(connection);
+        }
+        return true;
+    }
+
+    private static void freeConnection(ClientServiceConnection connection) {
+        ContextUtils.getApplicationContext().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;
+        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 */);
+    }
+
     private static class ConnectionAllocator {
         // Services are identified by a slot number, which is used in the service name to
         // differentiate them (MultiprocessTestClientService0, MultiprocessTestClientService1, ...).
         // They are stored in a FIFO queue in order to minimize the risk of the framework reusing a
         // service without restarting its associated process (which can cause all kind of problems
         // with static native variables already being initialized).
         private static final int MAX_SUBPROCESS_COUNT = 5;
 
         private final Object mLock = new Object();
 
@@ skipping 119 matching lines @@
         }
 
         public int getSlot() {
             return mSlot;
         }
 
         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 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();
-        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: " + 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(
-            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(context, connection);
-        }
-    }
-
-    @CalledByNative
-    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(context, connection);
-        }
-        return true;
-    }
-
-    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 */);
-    }
 }