Moving BindingManager and ChildProcessConnection to base/.

base/android/junit/src/org/chromium/base/process_launcher/BindingManagerImplTest.java

 // Copyright 2014 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;
+package org.chromium.base.process_launcher;
 
 import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL;
 import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW;
 import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE;
 
 import android.app.Activity;
 import android.app.Application;
+import android.os.Handler;
 import android.util.Pair;
 
-import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.Robolectric;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowLooper;
 
-import org.chromium.base.process_launcher.ChildProcessCreationParams;
 import org.chromium.base.test.util.Feature;
 import org.chromium.testing.local.LocalRobolectricTestRunner;
 
 import java.util.ArrayList;
 
 /**
  * Unit tests for BindingManagerImpl. The tests run agains mock ChildProcessConnection
  * implementation, thus testing only the BindingManagerImpl itself.
  *
  * Default property of being low-end device is overriden, so that both low-end and high-end policies
@@ skipping 25 matching lines @@
 
     private static class TestChildProcessConnection extends ManagedChildProcessConnection {
         private final int mPid;
         private boolean mConnected;
 
         /**
          * Creates a mock binding corresponding to real ManagedChildProcessConnection after the
          * connection is established: with initial binding bound and no strong binding.
          */
         private TestChildProcessConnection(int pid) {
-            super(null /* context */, pid /* number */, true /* sandboxed */,
+            super(new Handler(), null /* context */, pid /* number */, true /* sandboxed */,
                     null /* deathCallback */, null /* serviceClassName */,
                     null /* childProcessCommonParameters */,
                     new ChildProcessCreationParams("org.chromium.test",
                             false /* isExternalService */, 0 /* libraryProcessType */,
                             false /* bindToCallerCheck */));
             mPid = pid;
         }
 
         @Override
         public int getPid() {
@@ skipping 24 matching lines @@
         }
     }
 
     /**
      * Helper class that stores a manager along with its text label. This is used for tests that
      * iterate over all managers to indicate which manager was being tested when an assertion
      * failed.
      */
     private static class ManagerEntry {
         BindingManagerImpl mManager;
-        String mLabel;  // Name of the manager.
+        String mLabel; // Name of the manager.
 
         ManagerEntry(BindingManagerImpl manager, String label) {
             mManager = manager;
             mLabel = label;
         }
 
         String getErrorMessage() {
             return "Failed for the " + mLabel + " manager.";
         }
     }
 
     Activity mActivity;
 
     // The managers are created in setUp() for convenience.
     BindingManagerImpl mLowEndManager;
     BindingManagerImpl mHighEndManager;
     BindingManagerImpl mModerateBindingManager;
     ManagerEntry[] mAllManagers;
 
     @Before
     public void setUp() {
-        // The tests run on only one thread. Pretend that is the launcher thread so LauncherThread
-        // asserts are not triggered.
-        LauncherThread.setCurrentThreadAsLauncherThread();
-
         mActivity = Robolectric.buildActivity(Activity.class).setup().get();
-
-        mLowEndManager =
-                BindingManagerImpl.createBindingManagerForTesting(true /* isLowEndDevice */);
-        mHighEndManager =
-                BindingManagerImpl.createBindingManagerForTesting(false /* isLowEndDevice */);
-        mModerateBindingManager =
-                BindingManagerImpl.createBindingManagerForTesting(false /* isLowEndDevice */);
+        Handler handler = new Handler();
+        mLowEndManager = BindingManagerImpl.createBindingManagerForTesting(
+                handler, true /* isLowEndDevice */);
+        mHighEndManager = BindingManagerImpl.createBindingManagerForTesting(
+                handler, false /* isLowEndDevice */);
+        mModerateBindingManager = BindingManagerImpl.createBindingManagerForTesting(
+                handler, false /* isLowEndDevice */);
         mModerateBindingManager.startModerateBindingManagement(mActivity, 4 /* maxSize */);
-        mAllManagers = new ManagerEntry[] {
-                new ManagerEntry(mLowEndManager, "low-end"),
+        mAllManagers = new ManagerEntry[] {new ManagerEntry(mLowEndManager, "low-end"),
                 new ManagerEntry(mHighEndManager, "high-end"),
                 new ManagerEntry(mModerateBindingManager, "moderate-binding")};
     }
 
-    @After
-    public void tearDown() {
-        LauncherThread.setLauncherThreadAsLauncherThread();
-    }
-
     /**
      * Verifies that when running on low-end, the binding manager drops the oom bindings for the
      * previously bound connection when a new connection is used in foreground.
      */
     @Test
     @Feature({"ProcessManagement"})
     public void testNewConnectionDropsPreviousOnLowEnd() {
         // This test applies only to the low-end manager.
         BindingManagerImpl manager = mLowEndManager;
 
@@ skipping 436 matching lines @@
         }
     }
 
     /*
      * Test that a moderate binding is added to background renderer processes when the initial
      * binding is removed.
      */
     @Test
     @Feature({"ProcessManagement"})
     public void testModerateBindingTillBackgroundedBackgroundProcess() {
-        BindingManagerImpl manager = BindingManagerImpl.createBindingManagerForTesting(false);
+        BindingManagerImpl manager =
+                BindingManagerImpl.createBindingManagerForTesting(new Handler(), false);
         manager.startModerateBindingManagement(mActivity, 4);
 
         TestChildProcessConnection connection = new TestChildProcessConnection(0);
         connection.start(null /* startCallback */);
         manager.addNewConnection(connection.getPid(), connection);
         Assert.assertTrue(connection.isInitialBindingBound());
         Assert.assertFalse(connection.isModerateBindingBound());
 
         manager.setInForeground(connection.getPid(), false);
         manager.onDeterminedVisibility(connection.getPid());
         Assert.assertFalse(connection.isInitialBindingBound());
         Assert.assertTrue(connection.isModerateBindingBound());
     }
 
     /*
      * Test that a moderate binding is not added to foreground renderer processes when the initial
      * binding is removed.
      */
     @Test
     @Feature({"ProcessManagement"})
     public void testModerateBindingTillBackgroundedForegroundProcess() {
-        BindingManagerImpl manager = BindingManagerImpl.createBindingManagerForTesting(false);
+        BindingManagerImpl manager =
+                BindingManagerImpl.createBindingManagerForTesting(new Handler(), false);
         manager.startModerateBindingManagement(mActivity, 4);
 
         TestChildProcessConnection connection = new TestChildProcessConnection(0);
         connection.start(null /* startCallback */);
         manager.addNewConnection(connection.getPid(), connection);
         Assert.assertTrue(connection.isInitialBindingBound());
         Assert.assertFalse(connection.isStrongBindingBound());
         Assert.assertFalse(connection.isModerateBindingBound());
 
         manager.setInForeground(connection.getPid(), true);
         manager.onDeterminedVisibility(connection.getPid());
         Assert.assertFalse(connection.isInitialBindingBound());
         Assert.assertTrue(connection.isStrongBindingBound());
         Assert.assertFalse(connection.isModerateBindingBound());
     }
 
     /*
      * Test that Chrome is sent to the background, that the initially added moderate bindings are
      * removed and are not re-added when Chrome is brought back to the foreground.
      */
     @Test
     @Feature({"ProcessManagement"})
     public void testModerateBindingTillBackgroundedSentToBackground() {
-        BindingManagerImpl manager = BindingManagerImpl.createBindingManagerForTesting(false);
+        BindingManagerImpl manager =
+                BindingManagerImpl.createBindingManagerForTesting(new Handler(), false);
         manager.startModerateBindingManagement(mActivity, 4);
 
         TestChildProcessConnection connection = new TestChildProcessConnection(0);
         connection.start(null /* startCallback */);
         manager.addNewConnection(connection.getPid(), connection);
         manager.setInForeground(connection.getPid(), false);
         manager.onDeterminedVisibility(connection.getPid());
         Assert.assertTrue(connection.isModerateBindingBound());
 
         manager.onSentToBackground();
         ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
         Assert.assertFalse(connection.isModerateBindingBound());
 
         // Bringing Chrome to the foreground should not re-add the moderate bindings.
         manager.onBroughtToForeground();
         Assert.assertFalse(connection.isModerateBindingBound());
     }
 }