Convert ChromeTabbedActivityTestCaseBase children to JUnit4

chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/RecentTabsTest.java

Index: chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/RecentTabsTest.java
diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/RecentTabsTest.java b/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/RecentTabsTest.java
index 60f49ac4ac109876e2b29c2ddb65f80d3882cca9..bd270dc20f94dae256d82084ed2ddbf2491d6138 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/RecentTabsTest.java
+++ b/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/RecentTabsTest.java
@@ -4,18 +4,29 @@
 
 package org.chromium.chrome.browser.offlinepages;
 
+import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.MediumTest;
 
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
 import org.chromium.base.Callback;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.test.util.CommandLineFlags;
+import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.chrome.browser.offlinepages.OfflinePageBridge.OfflinePageModelObserver;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabModel;
 import org.chromium.chrome.browser.tabmodel.TabModelSelector;
 import org.chromium.chrome.browser.tabmodel.TabModelUtils;
-import org.chromium.chrome.test.ChromeTabbedActivityTestBase;
+import org.chromium.chrome.test.ChromeActivityTestRule;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
+import org.chromium.chrome.test.ChromeTabbedActivityTestRule;
 import org.chromium.net.NetworkChangeNotifier;
 import org.chromium.net.test.EmbeddedTestServer;
 
@@ -26,8 +37,14 @@ import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
 /** Integration tests for the Last 1 feature of Offline Pages. */
-@CommandLineFlags.Add("enable-features=OfflineRecentPages")
-public class RecentTabsTest extends ChromeTabbedActivityTestBase {
+@RunWith(ChromeJUnit4ClassRunner.class)
+@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE,
+        ChromeActivityTestRule.DISABLE_NETWORK_PREDICTION_FLAG,
+        "enable-features=OfflineRecentPages"})
+public class RecentTabsTest {
+    @Rule
+    public ChromeTabbedActivityTestRule mActivityTestRule = new ChromeTabbedActivityTestRule();
+
     private static final String TEST_PAGE = "/chrome/test/data/android/about.html";
     private static final int TIMEOUT_MS = 5000;
 
@@ -60,13 +77,12 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
                 });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     }
 
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
+    @Before
+    public void setUp() throws Exception {
+        mActivityTestRule.startMainActivityOnBlankPage();
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
@@ -80,39 +96,35 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
 
         initializeBridgeForProfile(false);
 
-        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
+        mTestServer = EmbeddedTestServer.createAndStartServer(
+                InstrumentationRegistry.getInstrumentation().getContext());
         mTestPage = mTestServer.getURL(TEST_PAGE);
     }
 
-    @Override
-    protected void tearDown() throws Exception {
+    @After
+    public void tearDown() throws Exception {
         mTestServer.stopAndDestroyServer();
-        super.tearDown();
-    }
-
-    @Override
-    public void startMainActivity() throws InterruptedException {
-        startMainActivityOnBlankPage();
     }
 
+    @Test
     @CommandLineFlags.Add("short-offline-page-snapshot-delay-for-test")
     @MediumTest
     public void testLastNPageSavedWhenTabSwitched() throws Exception {
         // The tab of interest.
-        Tab tab = loadUrlInNewTab(mTestPage);
+        Tab tab = mActivityTestRule.loadUrlInNewTab(mTestPage);
 
         final ClientId firstTabClientId =
                 new ClientId(OfflinePageBridge.LAST_N_NAMESPACE, Integer.toString(tab.getId()));
 
         // The tab should be foreground and so no snapshot should exist.
-        assertNull(getPageByClientId(firstTabClientId));
+        Assert.assertNull(getPageByClientId(firstTabClientId));
 
         // Note, that switching to a new tab must occur after the SnapshotController believes the
         // page quality is good enough.  With the debug flag, the delay after DomContentLoaded is 0
         // so we can definitely snapshot after onload (which is what |loadUrlInNewTab| waits for).
 
         // Switch to a new tab to cause the WebContents hidden event.
-        loadUrlInNewTab("about:blank");
+        mActivityTestRule.loadUrlInNewTab("about:blank");
 
         waitForPageWithClientId(firstTabClientId);
     }
@@ -123,23 +135,24 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
      * local testing and I expect it to be "safe" but it flakiness is detected it might have to be
      * further increased.
      */
+    @Test
     @CommandLineFlags.Add("short-offline-page-snapshot-delay-for-test")
     @MediumTest
     public void testLastNClosingTabIsNotSaved() throws Exception {
         // Create the tab of interest.
-        final Tab tab = loadUrlInNewTab(mTestPage);
+        final Tab tab = mActivityTestRule.loadUrlInNewTab(mTestPage);
         final ClientId firstTabClientId =
                 new ClientId(OfflinePageBridge.LAST_N_NAMESPACE, Integer.toString(tab.getId()));
 
         // The tab should be foreground and so no snapshot should exist.
         TabModelSelector tabModelSelector = tab.getTabModelSelector();
-        assertEquals(tabModelSelector.getCurrentTab(), tab);
-        assertFalse(tab.isHidden());
-        assertNull(getPageByClientId(firstTabClientId));
+        Assert.assertEquals(tabModelSelector.getCurrentTab(), tab);
+        Assert.assertFalse(tab.isHidden());
+        Assert.assertNull(getPageByClientId(firstTabClientId));
 
         // The tab model is expected to support pending closures.
         final TabModel tabModel = tabModelSelector.getModelForTabId(tab.getId());
-        assertTrue(tabModel.supportsPendingClosures());
+        Assert.assertTrue(tabModel.supportsPendingClosures());
 
         // Requests closing of the tab allowing for closure undo and checks it's actually closing.
         boolean closeTabReturnValue = ThreadUtils.runOnUiThreadBlocking(new Callable<Boolean>() {
@@ -148,13 +161,13 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
                 return tabModel.closeTab(tab, false, false, true);
             }
         });
-        assertTrue(closeTabReturnValue);
-        assertTrue(tab.isHidden());
-        assertTrue(tab.isClosing());
+        Assert.assertTrue(closeTabReturnValue);
+        Assert.assertTrue(tab.isHidden());
+        Assert.assertTrue(tab.isClosing());
 
         // Wait a bit and checks that no snapshot was created.
         Thread.sleep(100); // Note: Flakiness potential here.
-        assertNull(getPageByClientId(firstTabClientId));
+        Assert.assertNull(getPageByClientId(firstTabClientId));
 
         // Undo the closure and make sure the tab is again the current one on foreground.
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
@@ -165,14 +178,14 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
                 TabModelUtils.setIndex(tabModel, tabIndex);
             }
         });
-        assertFalse(tab.isHidden());
-        assertFalse(tab.isClosing());
-        assertEquals(tabModelSelector.getCurrentTab(), tab);
+        Assert.assertFalse(tab.isHidden());
+        Assert.assertFalse(tab.isClosing());
+        Assert.assertEquals(tabModelSelector.getCurrentTab(), tab);
 
         // Finally switch to a new tab and check that a snapshot is created.
-        Tab newTab = loadUrlInNewTab("about:blank");
-        assertEquals(tabModelSelector.getCurrentTab(), newTab);
-        assertTrue(tab.isHidden());
+        Tab newTab = mActivityTestRule.loadUrlInNewTab("about:blank");
+        Assert.assertEquals(tabModelSelector.getCurrentTab(), newTab);
+        Assert.assertTrue(tab.isHidden());
         waitForPageWithClientId(firstTabClientId);
     }
 
@@ -194,7 +207,7 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
                 });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     }
 
     private OfflinePageItem getPageByClientId(ClientId clientId) throws InterruptedException {
@@ -218,7 +231,7 @@ public class RecentTabsTest extends ChromeTabbedActivityTestBase {
                         });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
         return result[0];
     }
 }