Convert the rest of chrome_public_test_apk InstrumentationTestCases to JUnit4

chrome/android/javatests/src/org/chromium/chrome/browser/BackgroundSyncLauncherTest.java

 // Copyright 2015 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.chrome.browser;
 
 import android.content.Context;
+import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.SmallTest;
-import android.test.InstrumentationTestCase;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
 
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.base.test.util.AdvancedMockContext;
 import org.chromium.base.test.util.Feature;
 import org.chromium.base.test.util.RetryOnFailure;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Semaphore;
 
 /**
  * Tests {@link BackgroundSyncLauncher}.
  */
-public class BackgroundSyncLauncherTest extends InstrumentationTestCase {
+@RunWith(ChromeJUnit4ClassRunner.class)
+public class BackgroundSyncLauncherTest {
     private Context mContext;
     private BackgroundSyncLauncher mLauncher;
     private Boolean mShouldLaunchResult;
 
-    @Override
-    protected void setUp() throws Exception {
-        mContext = new AdvancedMockContext(getInstrumentation().getTargetContext());
+    @Before
+    public void setUp() throws Exception {
+        mContext = new AdvancedMockContext(
+                InstrumentationRegistry.getInstrumentation().getTargetContext());
         BackgroundSyncLauncher.setGCMEnabled(false);
         RecordHistogram.setDisabledForTests(true);
         mLauncher = BackgroundSyncLauncher.create(mContext);
         // Ensure that the initial task is given enough time to complete.
         waitForLaunchBrowserTask();
     }
 
-    @Override
+    @After
     public void tearDown() throws Exception {
-        super.tearDown();
         RecordHistogram.setDisabledForTests(false);
     }
 
     private void deleteLauncherInstance() {
         mLauncher.destroy();
         mLauncher = null;
     }
 
     private Boolean shouldLaunchBrowserIfStoppedSync() {
         mShouldLaunchResult = false;
 
         // Use a semaphore to wait for the callback to be called.
         final Semaphore semaphore = new Semaphore(0);
 
         BackgroundSyncLauncher.ShouldLaunchCallback callback =
                 new BackgroundSyncLauncher.ShouldLaunchCallback() {
                     @Override
                     public void run(Boolean shouldLaunch) {
                         mShouldLaunchResult = shouldLaunch;
                         semaphore.release();
                     }
                 };
 
         BackgroundSyncLauncher.shouldLaunchBrowserIfStopped(callback);
         try {
             // Wait on the callback to be called.
             semaphore.acquire();
         } catch (InterruptedException e) {
-            fail("Failed to acquire semaphore");
+            Assert.fail("Failed to acquire semaphore");
         }
         return mShouldLaunchResult;
     }
 
     private void waitForLaunchBrowserTask() {
         try {
             mLauncher.mLaunchBrowserIfStoppedTask.get();
         } catch (InterruptedException e) {
-            fail("Launch task was interrupted");
+            Assert.fail("Launch task was interrupted");
         } catch (ExecutionException e) {
-            fail("Launch task had execution exception");
+            Assert.fail("Launch task had execution exception");
         }
     }
 
+    @Test
     @SmallTest
     @Feature({"BackgroundSync"})
     @RetryOnFailure
     public void testHasInstance() {
-        assertTrue(BackgroundSyncLauncher.hasInstance());
+        Assert.assertTrue(BackgroundSyncLauncher.hasInstance());
         mLauncher.destroy();
-        assertFalse(BackgroundSyncLauncher.hasInstance());
+        Assert.assertFalse(BackgroundSyncLauncher.hasInstance());
     }
 
+    @Test
     @SmallTest
     @Feature({"BackgroundSync"})
     public void testDefaultNoLaunch() {
-        assertFalse(shouldLaunchBrowserIfStoppedSync());
+        Assert.assertFalse(shouldLaunchBrowserIfStoppedSync());
     }
 
+    @Test
     @SmallTest
     @Feature({"BackgroundSync"})
     @RetryOnFailure
     public void testSetLaunchWhenNextOnline() {
-        assertFalse(shouldLaunchBrowserIfStoppedSync());
+        Assert.assertFalse(shouldLaunchBrowserIfStoppedSync());
         mLauncher.launchBrowserIfStopped(true, 0);
         waitForLaunchBrowserTask();
-        assertTrue(shouldLaunchBrowserIfStoppedSync());
+        Assert.assertTrue(shouldLaunchBrowserIfStoppedSync());
         mLauncher.launchBrowserIfStopped(false, 0);
         waitForLaunchBrowserTask();
-        assertFalse(shouldLaunchBrowserIfStoppedSync());
+        Assert.assertFalse(shouldLaunchBrowserIfStoppedSync());
     }
 
+    @Test
     @SmallTest
     @Feature({"BackgroundSync"})
     @RetryOnFailure
     public void testNewLauncherDisablesNextOnline() {
         mLauncher.launchBrowserIfStopped(true, 0);
         waitForLaunchBrowserTask();
-        assertTrue(shouldLaunchBrowserIfStoppedSync());
+        Assert.assertTrue(shouldLaunchBrowserIfStoppedSync());
 
         // Simulate restarting the browser by deleting the launcher and creating a new one.
         deleteLauncherInstance();
         mLauncher = BackgroundSyncLauncher.create(mContext);
         waitForLaunchBrowserTask();
-        assertFalse(shouldLaunchBrowserIfStoppedSync());
+        Assert.assertFalse(shouldLaunchBrowserIfStoppedSync());
     }
 }