content/public/android/java/src/org/chromium/content/browser/ChildConnectionAllocator.java - chromium/src - Git at Google

 // 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.content.browser;

 import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.os.Bundle;

 import org.chromium.base.Log;
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.process_launcher.ChildProcessCreationParams;

 import java.util.ArrayList;
 import java.util.Arrays;

 /**
  * This class is responsible for allocating and managing connections to child
  * process services. These connections are in a pool (the services are defined
  * in the AndroidManifest.xml).
  */
 public class ChildConnectionAllocator {
     private static final String TAG = "ChildConnAllocator";

     /** Listener that clients can use to get notified when connections get allocated/freed. */
     public interface Listener {
         /** Called when a connection has been allocated, before it gets bound. */
         void onConnectionAllocated(
                 ChildConnectionAllocator allocator, ChildProcessConnection connection);

         /** Called when a connection has been freed. */
         void onConnectionFreed(
                 ChildConnectionAllocator allocator, ChildProcessConnection connection);
     }

     /** Factory interface. Used by tests to specialize created connections. */
     @VisibleForTesting
     protected interface ConnectionFactory {
         ChildProcessConnection createConnection(Context context, ComponentName serviceName,
                 boolean bindAsExternalService, Bundle serviceBundle,
                 ChildProcessCreationParams creationParams);
     }

     /** Default implementation of the ConnectionFactory that creates actual connections. */
     private static class ConnectionFactoryImpl implements ConnectionFactory {
         @Override
         public ChildProcessConnection createConnection(Context context, ComponentName serviceName,
                 boolean bindAsExternalService, Bundle serviceBundle,
                 ChildProcessCreationParams creationParams) {
             return new ChildProcessConnection(
                     context, serviceName, bindAsExternalService, serviceBundle, creationParams);
         }
     }

     // Delay between the call to freeConnection and the connection actually beeing   freed.
     private static final long FREE_CONNECTION_DELAY_MILLIS = 1;

     // Connections to services. Indices of the array correspond to the service numbers.
     private final ChildProcessConnection[] mChildProcessConnections;

     private final String mPackageName;
     private final String mServiceClassName;
     private final boolean mBindAsExternalService;
     private final boolean mUseStrongBinding;
     private final ChildProcessCreationParams mCreationParams;

     // The list of free (not bound) service indices.
     private final ArrayList<Integer> mFreeConnectionIndices;

     private final ObserverList<Listener> mListeners = new ObserverList<>();

     private ConnectionFactory mConnectionFactory = new ConnectionFactoryImpl();

     /**
      * Factory method that retrieves the service name and number of service from the
      * AndroidManifest.xml.
      */
     public static ChildConnectionAllocator create(Context context,
             ChildProcessCreationParams creationParams, String packageName,
             String serviceClassNameManifestKey, String numChildServicesManifestKey,
             boolean bindAsExternalService, boolean useStrongBinding) {
         String serviceClassName = null;
         int numServices = -1;
         PackageManager packageManager = context.getPackageManager();
         try {
             ApplicationInfo appInfo =
                     packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
             if (appInfo.metaData != null) {
                 serviceClassName = appInfo.metaData.getString(serviceClassNameManifestKey);
                 numServices = appInfo.metaData.getInt(numChildServicesManifestKey, -1);
             }
         } catch (PackageManager.NameNotFoundException e) {
             throw new RuntimeException("Could not get application info.");
         }

         if (numServices < 0) {
             throw new RuntimeException("Illegal meta data value for number of child services");
         }

         // Check that the service exists.
         try {
             // PackageManager#getServiceInfo() throws an exception if the service does not
             // exist.
             packageManager.getServiceInfo(
                     new ComponentName(packageName, serviceClassName + "0"), 0);
         } catch (PackageManager.NameNotFoundException e) {
             throw new RuntimeException("Illegal meta data value: the child service doesn't exist");
         }

         return new ChildConnectionAllocator(creationParams, packageName, serviceClassName,
                 bindAsExternalService, useStrongBinding, numServices);
     }

     // TODO(jcivelli): remove this method once crbug.com/693484 has been addressed.
     static int getNumberOfServices(
             Context context, String packageName, String numChildServicesManifestKey) {
         int numServices = -1;
         try {
             PackageManager packageManager = context.getPackageManager();
             ApplicationInfo appInfo =
                     packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
             if (appInfo.metaData != null) {
                 numServices = appInfo.metaData.getInt(numChildServicesManifestKey, -1);
             }
         } catch (PackageManager.NameNotFoundException e) {
             throw new RuntimeException("Could not get application info", e);
         }
         if (numServices < 0) {
             throw new RuntimeException("Illegal meta data value for number of child services");
         }
         return numServices;
     }

     /**
      * Factory method used with some tests to create an allocator with values passed in directly
      * instead of being retrieved from the AndroidManifest.xml.
      */
     @VisibleForTesting
     public static ChildConnectionAllocator createForTest(ChildProcessCreationParams creationParams,
             String packageName, String serviceClassName, int serviceCount,
             boolean bindAsExternalService, boolean useStrongBinding) {
         return new ChildConnectionAllocator(creationParams, packageName, serviceClassName,
                 bindAsExternalService, useStrongBinding, serviceCount);
     }

     private ChildConnectionAllocator(ChildProcessCreationParams creationParams, String packageName,
             String serviceClassName, boolean bindAsExternalService, boolean useStrongBinding,
             int numChildServices) {
         mCreationParams = creationParams;
         mPackageName = packageName;
         mServiceClassName = serviceClassName;
         mBindAsExternalService = bindAsExternalService;
         mUseStrongBinding = useStrongBinding;
         mChildProcessConnections = new ChildProcessConnection[numChildServices];
         mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
         for (int i = 0; i < numChildServices; i++) {
             mFreeConnectionIndices.add(i);
         }
     }

     /** @return a bound connection, or null if there are no free slots. */
     public ChildProcessConnection allocate(Context context, Bundle serviceBundle,
             final ChildProcessConnection.ServiceCallback serviceCallback) {
         assert LauncherThread.runningOnLauncherThread();
         if (mFreeConnectionIndices.isEmpty()) {
             Log.d(TAG, "Ran out of services to allocate.");
             return null;
         }
         int slot = mFreeConnectionIndices.remove(0);
         assert mChildProcessConnections[slot] == null;
         ComponentName serviceName = new ComponentName(mPackageName, mServiceClassName + slot);

         // Wrap the service callbacks so that:
         // - we can intercept onChildProcessDied and clean-up connections
         // - the callbacks are actually posted so that this method will return before the callbacks
         //   are called (so that the caller may set any reference to the returned connection before
         //   any callback logic potentially tries to access that connection).
         ChildProcessConnection.ServiceCallback serviceCallbackWrapper =
                 new ChildProcessConnection.ServiceCallback() {
                     @Override
                     public void onChildStarted() {
                         assert LauncherThread.runningOnLauncherThread();
                         if (serviceCallback != null) {
                             LauncherThread.post(new Runnable() {
                                 @Override
                                 public void run() {
                                     serviceCallback.onChildStarted();
                                 }
                             });
                         }
                     }

                     @Override
                     public void onChildStartFailed() {
                         assert LauncherThread.runningOnLauncherThread();
                         if (serviceCallback != null) {
                             LauncherThread.post(new Runnable() {
                                 @Override
                                 public void run() {
                                     serviceCallback.onChildStartFailed();
                                 }
                             });
                         }
                     }

                     @Override
                     public void onChildProcessDied(final ChildProcessConnection connection) {
                         assert LauncherThread.runningOnLauncherThread();
                         if (serviceCallback != null) {
                             LauncherThread.post(new Runnable() {
                                 @Override
                                 public void run() {
                                     serviceCallback.onChildProcessDied(connection);
                                 }
                             });
                         }

                         // Freeing a service should be delayed. This is so that we avoid immediately
                         // reusing the freed service (see http://crbug.com/164069): the framework
                         // might keep a service process alive when it's been unbound for a short
                         // time. If a new connection to the same service is bound at that point, the
                         // process is reused and bad things happen (mostly static variables are set
                         // when we don't expect them to).
                         LauncherThread.postDelayed(new Runnable() {
                             @Override
                             public void run() {
                                 free(connection);
                             }
                         }, FREE_CONNECTION_DELAY_MILLIS);
                     }
                 };

         ChildProcessConnection connection = mConnectionFactory.createConnection(
                 context, serviceName, mBindAsExternalService, serviceBundle, mCreationParams);
         mChildProcessConnections[slot] = connection;

         for (Listener listener : mListeners) {
             listener.onConnectionAllocated(this, connection);
         }

         connection.start(mUseStrongBinding, serviceCallbackWrapper);
         Log.d(TAG, "Allocator allocated and bound a connection, name: %s, slot: %d",
                 mServiceClassName, slot);
         return connection;
     }

     /** Frees a connection and notifies listeners. */
     private void free(ChildProcessConnection connection) {
         assert LauncherThread.runningOnLauncherThread();

         // mChildProcessConnections is relatively short (20 items at max at this point).
         // We are better of iterating than caching in a map.
         int slot = Arrays.asList(mChildProcessConnections).indexOf(connection);
         if (slot == -1) {
             Log.e(TAG, "Unable to find connection to free.");
             assert false;
         } else {
             mChildProcessConnections[slot] = null;
             assert !mFreeConnectionIndices.contains(slot);
             mFreeConnectionIndices.add(slot);
             Log.d(TAG, "Allocator freed a connection, name: %s, slot: %d", mServiceClassName, slot);
         }

         for (Listener listener : mListeners) {
             listener.onConnectionFreed(this, connection);
         }
     }

     public String getPackageName() {
         return mPackageName;
     }

     public boolean anyConnectionAllocated() {
         return mFreeConnectionIndices.size() < mChildProcessConnections.length;
     }

     public boolean isFreeConnectionAvailable() {
         assert LauncherThread.runningOnLauncherThread();
         return !mFreeConnectionIndices.isEmpty();
     }

     public int getNumberOfServices() {
         return mChildProcessConnections.length;
     }

     public void addListener(Listener listener) {
         assert !mListeners.hasObserver(listener);
         mListeners.addObserver(listener);
     }

     public void removeListener(Listener listener) {
         boolean removed = mListeners.removeObserver(listener);
         assert removed;
     }

     @VisibleForTesting
     void setConnectionFactoryForTesting(ConnectionFactory connectionFactory) {
         mConnectionFactory = connectionFactory;
     }

     /** @return the count of connections managed by the allocator */
     @VisibleForTesting
     int allocatedConnectionsCountForTesting() {
         assert LauncherThread.runningOnLauncherThread();
         return mChildProcessConnections.length - mFreeConnectionIndices.size();
     }

     @VisibleForTesting
     ChildProcessConnection getChildProcessConnectionAtSlotForTesting(int slotNumber) {
         return mChildProcessConnections[slotNumber];
     }
 }
	// 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.content.browser;

	import android.content.ComponentName;
	import android.content.Context;
	import android.content.pm.ApplicationInfo;
	import android.content.pm.PackageManager;
	import android.os.Bundle;

	import org.chromium.base.Log;
	import org.chromium.base.ObserverList;
	import org.chromium.base.VisibleForTesting;
	import org.chromium.base.process_launcher.ChildProcessCreationParams;

	import java.util.ArrayList;
	import java.util.Arrays;

	/**
	* This class is responsible for allocating and managing connections to child
	* process services. These connections are in a pool (the services are defined
	* in the AndroidManifest.xml).
	*/
	public class ChildConnectionAllocator {
	private static final String TAG = "ChildConnAllocator";

	/** Listener that clients can use to get notified when connections get allocated/freed. */
	public interface Listener {
	/** Called when a connection has been allocated, before it gets bound. */
	void onConnectionAllocated(
	ChildConnectionAllocator allocator, ChildProcessConnection connection);

	/** Called when a connection has been freed. */
	void onConnectionFreed(
	ChildConnectionAllocator allocator, ChildProcessConnection connection);
	}

	/** Factory interface. Used by tests to specialize created connections. */
	@VisibleForTesting
	protected interface ConnectionFactory {
	ChildProcessConnection createConnection(Context context, ComponentName serviceName,
	boolean bindAsExternalService, Bundle serviceBundle,
	ChildProcessCreationParams creationParams);
	}

	/** Default implementation of the ConnectionFactory that creates actual connections. */
	private static class ConnectionFactoryImpl implements ConnectionFactory {
	@Override
	public ChildProcessConnection createConnection(Context context, ComponentName serviceName,
	boolean bindAsExternalService, Bundle serviceBundle,
	ChildProcessCreationParams creationParams) {
	return new ChildProcessConnection(
	context, serviceName, bindAsExternalService, serviceBundle, creationParams);
	}
	}

	// Delay between the call to freeConnection and the connection actually beeing freed.
	private static final long FREE_CONNECTION_DELAY_MILLIS = 1;

	// Connections to services. Indices of the array correspond to the service numbers.
	private final ChildProcessConnection[] mChildProcessConnections;

	private final String mPackageName;
	private final String mServiceClassName;
	private final boolean mBindAsExternalService;
	private final boolean mUseStrongBinding;
	private final ChildProcessCreationParams mCreationParams;

	// The list of free (not bound) service indices.
	private final ArrayList<Integer> mFreeConnectionIndices;

	private final ObserverList<Listener> mListeners = new ObserverList<>();

	private ConnectionFactory mConnectionFactory = new ConnectionFactoryImpl();

	/**
	* Factory method that retrieves the service name and number of service from the
	* AndroidManifest.xml.
	*/
	public static ChildConnectionAllocator create(Context context,
	ChildProcessCreationParams creationParams, String packageName,
	String serviceClassNameManifestKey, String numChildServicesManifestKey,
	boolean bindAsExternalService, boolean useStrongBinding) {
	String serviceClassName = null;
	int numServices = -1;
	PackageManager packageManager = context.getPackageManager();
	try {
	ApplicationInfo appInfo =
	packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
	if (appInfo.metaData != null) {
	serviceClassName = appInfo.metaData.getString(serviceClassNameManifestKey);
	numServices = appInfo.metaData.getInt(numChildServicesManifestKey, -1);
	}
	} catch (PackageManager.NameNotFoundException e) {
	throw new RuntimeException("Could not get application info.");
	}

	if (numServices < 0) {
	throw new RuntimeException("Illegal meta data value for number of child services");
	}

	// Check that the service exists.
	try {
	// PackageManager#getServiceInfo() throws an exception if the service does not
	// exist.
	packageManager.getServiceInfo(
	new ComponentName(packageName, serviceClassName + "0"), 0);
	} catch (PackageManager.NameNotFoundException e) {
	throw new RuntimeException("Illegal meta data value: the child service doesn't exist");
	}

	return new ChildConnectionAllocator(creationParams, packageName, serviceClassName,
	bindAsExternalService, useStrongBinding, numServices);
	}

	// TODO(jcivelli): remove this method once crbug.com/693484 has been addressed.
	static int getNumberOfServices(
	Context context, String packageName, String numChildServicesManifestKey) {
	int numServices = -1;
	try {
	PackageManager packageManager = context.getPackageManager();
	ApplicationInfo appInfo =
	packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
	if (appInfo.metaData != null) {
	numServices = appInfo.metaData.getInt(numChildServicesManifestKey, -1);
	}
	} catch (PackageManager.NameNotFoundException e) {
	throw new RuntimeException("Could not get application info", e);
	}
	if (numServices < 0) {
	throw new RuntimeException("Illegal meta data value for number of child services");
	}
	return numServices;
	}

	/**
	* Factory method used with some tests to create an allocator with values passed in directly
	* instead of being retrieved from the AndroidManifest.xml.
	*/
	@VisibleForTesting
	public static ChildConnectionAllocator createForTest(ChildProcessCreationParams creationParams,
	String packageName, String serviceClassName, int serviceCount,
	boolean bindAsExternalService, boolean useStrongBinding) {
	return new ChildConnectionAllocator(creationParams, packageName, serviceClassName,
	bindAsExternalService, useStrongBinding, serviceCount);
	}

	private ChildConnectionAllocator(ChildProcessCreationParams creationParams, String packageName,
	String serviceClassName, boolean bindAsExternalService, boolean useStrongBinding,
	int numChildServices) {
	mCreationParams = creationParams;
	mPackageName = packageName;
	mServiceClassName = serviceClassName;
	mBindAsExternalService = bindAsExternalService;
	mUseStrongBinding = useStrongBinding;
	mChildProcessConnections = new ChildProcessConnection[numChildServices];
	mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
	for (int i = 0; i < numChildServices; i++) {
	mFreeConnectionIndices.add(i);
	}
	}

	/** @return a bound connection, or null if there are no free slots. */
	public ChildProcessConnection allocate(Context context, Bundle serviceBundle,
	final ChildProcessConnection.ServiceCallback serviceCallback) {
	assert LauncherThread.runningOnLauncherThread();
	if (mFreeConnectionIndices.isEmpty()) {
	Log.d(TAG, "Ran out of services to allocate.");
	return null;
	}
	int slot = mFreeConnectionIndices.remove(0);
	assert mChildProcessConnections[slot] == null;
	ComponentName serviceName = new ComponentName(mPackageName, mServiceClassName + slot);

	// Wrap the service callbacks so that:
	// - we can intercept onChildProcessDied and clean-up connections
	// - the callbacks are actually posted so that this method will return before the callbacks
	// are called (so that the caller may set any reference to the returned connection before
	// any callback logic potentially tries to access that connection).
	ChildProcessConnection.ServiceCallback serviceCallbackWrapper =
	new ChildProcessConnection.ServiceCallback() {
	@Override
	public void onChildStarted() {
	assert LauncherThread.runningOnLauncherThread();
	if (serviceCallback != null) {
	LauncherThread.post(new Runnable() {
	@Override
	public void run() {
	serviceCallback.onChildStarted();
	}
	});
	}
	}

	@Override
	public void onChildStartFailed() {
	assert LauncherThread.runningOnLauncherThread();
	if (serviceCallback != null) {
	LauncherThread.post(new Runnable() {
	@Override
	public void run() {
	serviceCallback.onChildStartFailed();
	}
	});
	}
	}

	@Override
	public void onChildProcessDied(final ChildProcessConnection connection) {
	assert LauncherThread.runningOnLauncherThread();
	if (serviceCallback != null) {
	LauncherThread.post(new Runnable() {
	@Override
	public void run() {
	serviceCallback.onChildProcessDied(connection);
	}
	});
	}

	// Freeing a service should be delayed. This is so that we avoid immediately
	// reusing the freed service (see http://crbug.com/164069): the framework
	// might keep a service process alive when it's been unbound for a short
	// time. If a new connection to the same service is bound at that point, the
	// process is reused and bad things happen (mostly static variables are set
	// when we don't expect them to).
	LauncherThread.postDelayed(new Runnable() {
	@Override
	public void run() {
	free(connection);
	}
	}, FREE_CONNECTION_DELAY_MILLIS);
	}
	};

	ChildProcessConnection connection = mConnectionFactory.createConnection(
	context, serviceName, mBindAsExternalService, serviceBundle, mCreationParams);
	mChildProcessConnections[slot] = connection;

	for (Listener listener : mListeners) {
	listener.onConnectionAllocated(this, connection);
	}

	connection.start(mUseStrongBinding, serviceCallbackWrapper);
	Log.d(TAG, "Allocator allocated and bound a connection, name: %s, slot: %d",
	mServiceClassName, slot);
	return connection;
	}

	/** Frees a connection and notifies listeners. */
	private void free(ChildProcessConnection connection) {
	assert LauncherThread.runningOnLauncherThread();

	// mChildProcessConnections is relatively short (20 items at max at this point).
	// We are better of iterating than caching in a map.
	int slot = Arrays.asList(mChildProcessConnections).indexOf(connection);
	if (slot == -1) {
	Log.e(TAG, "Unable to find connection to free.");
	assert false;
	} else {
	mChildProcessConnections[slot] = null;
	assert !mFreeConnectionIndices.contains(slot);
	mFreeConnectionIndices.add(slot);
	Log.d(TAG, "Allocator freed a connection, name: %s, slot: %d", mServiceClassName, slot);
	}

	for (Listener listener : mListeners) {
	listener.onConnectionFreed(this, connection);
	}
	}

	public String getPackageName() {
	return mPackageName;
	}

	public boolean anyConnectionAllocated() {
	return mFreeConnectionIndices.size() < mChildProcessConnections.length;
	}

	public boolean isFreeConnectionAvailable() {
	assert LauncherThread.runningOnLauncherThread();
	return !mFreeConnectionIndices.isEmpty();
	}

	public int getNumberOfServices() {
	return mChildProcessConnections.length;
	}

	public void addListener(Listener listener) {
	assert !mListeners.hasObserver(listener);
	mListeners.addObserver(listener);
	}

	public void removeListener(Listener listener) {
	boolean removed = mListeners.removeObserver(listener);
	assert removed;
	}

	@VisibleForTesting
	void setConnectionFactoryForTesting(ConnectionFactory connectionFactory) {
	mConnectionFactory = connectionFactory;
	}

	/** @return the count of connections managed by the allocator */
	@VisibleForTesting
	int allocatedConnectionsCountForTesting() {
	assert LauncherThread.runningOnLauncherThread();
	return mChildProcessConnections.length - mFreeConnectionIndices.size();
	}

	@VisibleForTesting
	ChildProcessConnection getChildProcessConnectionAtSlotForTesting(int slotNumber) {
	return mChildProcessConnections[slotNumber];
	}
	}