Convert ChromeActivityTestCaseBase direct children to JUnit4

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

Index: chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageBridgeTest.java
diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageBridgeTest.java b/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageBridgeTest.java
index 914066870cf745bc3c084ba7dabdd1d043202328..c6a60382397fc925520b33fc891b0fd8938c4fa2 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageBridgeTest.java
+++ b/chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageBridgeTest.java
@@ -4,17 +4,27 @@
 
 package org.chromium.chrome.browser.offlinepages;
 
+import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.SmallTest;
 
+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.base.test.util.RetryOnFailure;
 import org.chromium.chrome.browser.ChromeActivity;
+import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.chrome.browser.offlinepages.OfflinePageBridge.OfflinePageModelObserver;
 import org.chromium.chrome.browser.offlinepages.OfflinePageBridge.SavePageCallback;
 import org.chromium.chrome.browser.profiles.Profile;
-import org.chromium.chrome.test.ChromeActivityTestCaseBase;
+import org.chromium.chrome.test.ChromeActivityTestRule;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
 import org.chromium.components.offlinepages.DeletePageResult;
 import org.chromium.components.offlinepages.SavePageResult;
 import org.chromium.net.NetworkChangeNotifier;
@@ -30,8 +40,15 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
 /** Unit tests for {@link OfflinePageBridge}. */
-@CommandLineFlags.Add("enable-features=OfflineBookmarks")
-public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActivity> {
+@RunWith(ChromeJUnit4ClassRunner.class)
+@CommandLineFlags.Add({"enable-features=OfflineBookmarks",
+        ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE,
+        ChromeActivityTestRule.DISABLE_NETWORK_PREDICTION_FLAG})
+public class OfflinePageBridgeTest {
+    @Rule
+    public ChromeActivityTestRule<ChromeActivity> mActivityTestRule =
+            new ChromeActivityTestRule<>(ChromeActivity.class);
+
     private static final String TEST_PAGE = "/chrome/test/data/android/about.html";
     private static final int TIMEOUT_MS = 5000;
     private static final long POLLING_INTERVAL = 100;
@@ -42,10 +59,6 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
     private EmbeddedTestServer mTestServer;
     private String mTestPage;
 
-    public OfflinePageBridgeTest() {
-        super(ChromeActivity.class);
-    }
-
     private void initializeBridgeForProfile(final boolean incognitoProfile)
             throws InterruptedException {
         final Semaphore semaphore = new Semaphore(0);
@@ -71,12 +84,12 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                 });
             }
         });
-        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
@@ -91,37 +104,34 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
 
         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
     @SmallTest
     @RetryOnFailure
     public void testLoadOfflinePagesWhenEmpty() throws Exception {
         List<OfflinePageItem> offlinePages = getAllPages();
-        assertEquals("Offline pages count incorrect.", 0, offlinePages.size());
+        Assert.assertEquals("Offline pages count incorrect.", 0, offlinePages.size());
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testAddOfflinePageAndLoad() throws Exception {
-        loadUrl(mTestPage);
+        mActivityTestRule.loadUrl(mTestPage);
         savePage(SavePageResult.SUCCESS, mTestPage);
         List<OfflinePageItem> allPages = getAllPages();
         OfflinePageItem offlinePage = allPages.get(0);
-        assertEquals("Offline pages count incorrect.", 1, allPages.size());
-        assertEquals("Offline page item url incorrect.", mTestPage, offlinePage.getUrl());
+        Assert.assertEquals("Offline pages count incorrect.", 1, allPages.size());
+        Assert.assertEquals("Offline page item url incorrect.", mTestPage, offlinePage.getUrl());
 
         // We don't care about the exact file size of the mhtml file:
         // - exact file size is not something that the end user sees or cares about
@@ -133,33 +143,36 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
         // OTOH, it still seems useful to assert that the file is not empty and that its size is in
         // the right ballpark.
         long size = offlinePage.getFileSize();
-        assertTrue("Offline page item size is incorrect: " + size, 600 < size && size < 800);
+        Assert.assertTrue("Offline page item size is incorrect: " + size, 600 < size && size < 800);
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testGetPageByBookmarkId() throws Exception {
-        loadUrl(mTestPage);
+        mActivityTestRule.loadUrl(mTestPage);
         savePage(SavePageResult.SUCCESS, mTestPage);
         OfflinePageItem offlinePage = getPageByClientId(BOOKMARK_ID);
-        assertEquals("Offline page item url incorrect.", mTestPage, offlinePage.getUrl());
-        assertNull("Offline page is not supposed to exist",
+        Assert.assertEquals("Offline page item url incorrect.", mTestPage, offlinePage.getUrl());
+        Assert.assertNull("Offline page is not supposed to exist",
                 getPageByClientId(new ClientId(OfflinePageBridge.BOOKMARK_NAMESPACE, "-42")));
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testDeleteOfflinePage() throws Exception {
         deletePage(BOOKMARK_ID, DeletePageResult.SUCCESS);
-        loadUrl(mTestPage);
+        mActivityTestRule.loadUrl(mTestPage);
         savePage(SavePageResult.SUCCESS, mTestPage);
-        assertNotNull(
+        Assert.assertNotNull(
                 "Offline page should be available, but it is not.", getPageByClientId(BOOKMARK_ID));
         deletePage(BOOKMARK_ID, DeletePageResult.SUCCESS);
-        assertNull("Offline page should be gone, but it is available.",
+        Assert.assertNull("Offline page should be gone, but it is available.",
                 getPageByClientId(BOOKMARK_ID));
     }
 
+    @Test
     @CommandLineFlags.Add("disable-features=OfflinePagesSharing")
     @SmallTest
     @RetryOnFailure
@@ -167,17 +180,19 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
-                assertFalse("If offline page sharing is off, we should see the feature disabled",
+                Assert.assertFalse(
+                        "If offline page sharing is off, we should see the feature disabled",
                         OfflinePageBridge.isPageSharingEnabled());
             }
         });
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testCheckPagesExistOffline() throws Exception {
         // If we save a page, then it should exist in the result.
-        loadUrl(mTestPage);
+        mActivityTestRule.loadUrl(mTestPage);
         savePage(SavePageResult.SUCCESS, mTestPage);
         Set<String> testCases = new HashSet<>();
         testCases.add(mTestPage);
@@ -187,13 +202,14 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
 
         Set<String> pages = checkPagesExistOffline(testCases);
 
-        assertEquals(
+        Assert.assertEquals(
                 "We only saved one page and queried for it, so the result should be one string.", 1,
                 pages.size());
-        assertTrue("The only page returned should be the page that was actually saved.",
+        Assert.assertTrue("The only page returned should be the page that was actually saved.",
                 pages.contains(mTestPage));
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testGetRequestsInQueue() throws Exception {
@@ -201,15 +217,15 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
         String namespace = "custom_tabs";
         savePageLater(url, namespace);
         SavePageRequest[] requests = getRequestsInQueue();
-        assertEquals(1, requests.length);
-        assertEquals(namespace, requests[0].getClientId().getNamespace());
-        assertEquals(url, requests[0].getUrl());
+        Assert.assertEquals(1, requests.length);
+        Assert.assertEquals(namespace, requests[0].getClientId().getNamespace());
+        Assert.assertEquals(url, requests[0].getUrl());
 
         String url2 = "https://mail.google.com/";
         String namespace2 = "last_n";
         savePageLater(url2, namespace2);
         requests = getRequestsInQueue();
-        assertEquals(2, requests.length);
+        Assert.assertEquals(2, requests.length);
 
         HashSet<String> expectedUrls = new HashSet<>();
         expectedUrls.add(url);
@@ -220,20 +236,22 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
         expectedNamespaces.add(namespace2);
 
         for (SavePageRequest request : requests) {
-            assertTrue(expectedNamespaces.contains(request.getClientId().getNamespace()));
+            Assert.assertTrue(expectedNamespaces.contains(request.getClientId().getNamespace()));
             expectedNamespaces.remove(request.getClientId().getNamespace());
-            assertTrue(expectedUrls.contains(request.getUrl()));
+            Assert.assertTrue(expectedUrls.contains(request.getUrl()));
             expectedUrls.remove(request.getUrl());
         }
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testOfflinePageBridgeDisabledInIncognito() throws Exception {
         initializeBridgeForProfile(true);
-        assertEquals(null, mOfflinePageBridge);
+        Assert.assertEquals(null, mOfflinePageBridge);
     }
 
+    @Test
     @SmallTest
     @RetryOnFailure
     public void testRemoveRequestsFromQueue() throws Exception {
@@ -246,22 +264,23 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
         savePageLater(url2, namespace2);
 
         SavePageRequest[] requests = getRequestsInQueue();
-        assertEquals(2, requests.length);
+        Assert.assertEquals(2, requests.length);
 
         List<Long> requestsToRemove = new ArrayList<>();
         requestsToRemove.add(Long.valueOf(requests[1].getRequestId()));
 
         List<OfflinePageBridge.RequestRemovedResult> removed =
                 removeRequestsFromQueue(requestsToRemove);
-        assertEquals(requests[1].getRequestId(), removed.get(0).getRequestId());
-        assertEquals(org.chromium.components.offlinepages.background.UpdateRequestResult.SUCCESS,
+        Assert.assertEquals(requests[1].getRequestId(), removed.get(0).getRequestId());
+        Assert.assertEquals(
+                org.chromium.components.offlinepages.background.UpdateRequestResult.SUCCESS,
                 removed.get(0).getUpdateRequestResult());
 
         SavePageRequest[] remaining = getRequestsInQueue();
-        assertEquals(1, remaining.length);
+        Assert.assertEquals(1, remaining.length);
 
-        assertEquals(requests[0].getRequestId(), remaining[0].getRequestId());
-        assertEquals(requests[0].getUrl(), remaining[0].getUrl());
+        Assert.assertEquals(requests[0].getRequestId(), remaining[0].getRequestId());
+        Assert.assertEquals(requests[0].getUrl(), remaining[0].getUrl());
     }
 
     private void savePage(final int expectedResult, final String expectedUrl)
@@ -270,27 +289,29 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
-                assertNotNull("Tab is null", getActivity().getActivityTab());
-                assertEquals("URL does not match requested.", expectedUrl,
-                        getActivity().getActivityTab().getUrl());
-                assertNotNull("WebContents is null",
-                        getActivity().getActivityTab().getWebContents());
-
-                mOfflinePageBridge.savePage(getActivity().getActivityTab().getWebContents(),
+                Assert.assertNotNull(
+                        "Tab is null", mActivityTestRule.getActivity().getActivityTab());
+                Assert.assertEquals("URL does not match requested.", expectedUrl,
+                        mActivityTestRule.getActivity().getActivityTab().getUrl());
+                Assert.assertNotNull("WebContents is null",
+                        mActivityTestRule.getActivity().getActivityTab().getWebContents());
+
+                mOfflinePageBridge.savePage(
+                        mActivityTestRule.getActivity().getActivityTab().getWebContents(),
                         BOOKMARK_ID, new SavePageCallback() {
                             @Override
                             public void onSavePageDone(
                                     int savePageResult, String url, long offlineId) {
-                                assertEquals(
+                                Assert.assertEquals(
                                         "Requested and returned URLs differ.", expectedUrl, url);
-                                assertEquals(
+                                Assert.assertEquals(
                                         "Save result incorrect.", expectedResult, savePageResult);
                                 semaphore.release();
                             }
                         });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
     }
 
     private void deletePage(final ClientId bookmarkId, final int expectedResult)
@@ -309,8 +330,8 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                 });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-        assertEquals("Delete result incorrect.", expectedResult, deletePageResultRef.get());
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertEquals("Delete result incorrect.", expectedResult, deletePageResultRef.get());
     }
 
     private List<OfflinePageItem> getAllPages() throws InterruptedException {
@@ -328,7 +349,7 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                 });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
         return result;
     }
 
@@ -362,7 +383,7 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                         });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
         return result[0];
     }
 
@@ -382,7 +403,7 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                 });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
         return result;
     }
 
@@ -411,7 +432,7 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                 });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
         return ref.get();
     }
 
@@ -434,7 +455,7 @@ public class OfflinePageBridgeTest extends ChromeActivityTestCaseBase<ChromeActi
                         });
             }
         });
-        assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+        Assert.assertTrue(semaphore.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS));
         return ref.get();
     }
 }