Rename best icon to best primary icon in Web app related code.

chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebApkUpdateManagerTest.java

 // Copyright 2016 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.webapps;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
@@ skipping 32 matching lines @@
 /**
  * Unit tests for WebApkUpdateManager.
  */
 @RunWith(LocalRobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class WebApkUpdateManagerTest {
     @Rule
     public DisableHistogramsRule mDisableHistogramsRule = new DisableHistogramsRule();
 
     /** WebAPK's id in {@link WebAppDataStorage}. */
-    private static final String WEBAPK_ID =
-            WebApkConstants.WEBAPK_ID_PREFIX + WebApkTestHelper.WEBAPK_PACKAGE_NAME;
+    private static final String WEBAPK_ID = WebApkConstants.WEBAPK_ID_PREFIX
+            + WebApkTestHelper.WEBAPK_PACKAGE_NAME;
 
     /** Web Manifest URL */
     private static final String WEB_MANIFEST_URL = "manifest.json";
 
     private static final String START_URL = "/start_url.html";
     private static final String SCOPE_URL = "/";
     private static final String NAME = "Long Name";
     private static final String SHORT_NAME = "Short Name";
     private static final String ICON_URL = "/icon.png";
     private static final String ICON_MURMUR2_HASH = "3";
@@ skipping 73 matching lines @@
             return mDestroyedFetcher;
         }
 
         @Override
         protected WebApkUpdateDataFetcher buildFetcher() {
             mFetcher = new TestWebApkUpdateDataFetcher();
             return mFetcher;
         }
 
         @Override
-        protected void scheduleUpdate(WebApkInfo info, String bestIconUrl,
+        protected void scheduleUpdate(WebApkInfo info, String bestPrimaryIconUrl,
                 boolean isManifestStale) {
             mUpdateName = info.name();
-            super.scheduleUpdate(info, bestIconUrl, isManifestStale);
+            super.scheduleUpdate(info, bestPrimaryIconUrl, isManifestStale);
         }
 
         @Override
-        protected void updateAsyncImpl(WebApkInfo info, String bestIconUrl,
+        protected void updateAsyncImpl(WebApkInfo info, String bestPrimaryIconUrl,
                 boolean isManifestStale) {
             mUpdateRequested = true;
         }
 
         @Override
         protected boolean isInForeground() {
             return mIsWebApkForeground;
         }
 
         @Override
@@ skipping 17 matching lines @@
             return TextUtils.equals(url1, url2);
         }
     }
 
     private static class ManifestData {
         public String startUrl;
         public String scopeUrl;
         public String name;
         public String shortName;
         public Map<String, String> iconUrlToMurmur2HashMap;
-        public String bestIconUrl;
-        public Bitmap bestIcon;
+        public String bestPrimaryIconUrl;
+        public Bitmap bestPrimaryIcon;
         public int displayMode;
         public int orientation;
         public long themeColor;
         public long backgroundColor;
     }
 
     private MockClock mClock;
 
     private WebappDataStorage getStorage() {
         return WebappRegistry.getInstance().getWebappDataStorage(WEBAPK_ID);
     }
 
     /**
      * Registers WebAPK with default package name. Overwrites previous registrations.
-     * @param manifestData        <meta-data> values for WebAPK's Android Manifest.
+     *
+     * @param manifestData <meta-data> values for WebAPK's Android Manifest.
      * @param shellApkVersionCode WebAPK's version of the //chrome/android/webapk/shell_apk code.
      */
     private void registerWebApk(ManifestData manifestData, int shellApkVersionCode) {
         Bundle metaData = new Bundle();
         metaData.putInt(
                 WebApkMetaDataKeys.SHELL_APK_VERSION, shellApkVersionCode);
         metaData.putString(WebApkMetaDataKeys.START_URL, manifestData.startUrl);
         metaData.putString(WebApkMetaDataKeys.SCOPE, manifestData.scopeUrl);
         metaData.putString(WebApkMetaDataKeys.NAME, manifestData.name);
         metaData.putString(WebApkMetaDataKeys.SHORT_NAME, manifestData.shortName);
@@ skipping 19 matching lines @@
     private static ManifestData defaultManifestData() {
         ManifestData manifestData = new ManifestData();
         manifestData.startUrl = START_URL;
         manifestData.scopeUrl = SCOPE_URL;
         manifestData.name = NAME;
         manifestData.shortName = SHORT_NAME;
 
         manifestData.iconUrlToMurmur2HashMap = new HashMap<String, String>();
         manifestData.iconUrlToMurmur2HashMap.put(ICON_URL, ICON_MURMUR2_HASH);
 
-        manifestData.bestIconUrl = ICON_URL;
-        manifestData.bestIcon = createBitmap(Color.GREEN);
+        manifestData.bestPrimaryIconUrl = ICON_URL;
+        manifestData.bestPrimaryIcon = createBitmap(Color.GREEN);
         manifestData.displayMode = DISPLAY_MODE;
         manifestData.orientation = ORIENTATION;
         manifestData.themeColor = THEME_COLOR;
         manifestData.backgroundColor = BACKGROUND_COLOR;
         return manifestData;
     }
 
     private static WebApkInfo infoFromManifestData(ManifestData manifestData) {
         if (manifestData == null) return null;
 
         return WebApkInfo.create(WEBAPK_ID, "", manifestData.scopeUrl,
-                new WebApkInfo.Icon(manifestData.bestIcon), manifestData.name,
+                new WebApkInfo.Icon(manifestData.bestPrimaryIcon), manifestData.name,
                 manifestData.shortName, manifestData.displayMode, manifestData.orientation, -1,
                 manifestData.themeColor, manifestData.backgroundColor,
                 WebApkTestHelper.WEBAPK_PACKAGE_NAME, -1, WEB_MANIFEST_URL,
                 manifestData.startUrl, manifestData.iconUrlToMurmur2HashMap);
     }
 
     /**
      * Creates 1x1 bitmap.
+     *
      * @param color The bitmap color.
      */
     private static Bitmap createBitmap(int color) {
-        int colors[] = { color };
+        int colors[] = {
+                color
+        };
         return ShadowBitmap.createBitmap(colors, 1, 1, Bitmap.Config.ALPHA_8);
     }
 
     private static void updateIfNeeded(WebApkUpdateManager updateManager) {
         // Use the intent version of {@link WebApkInfo#create()} in order to test default values
         // set by the intent version of {@link WebApkInfo#create()}.
         Intent intent = new Intent();
         intent.putExtra(ShortcutHelper.EXTRA_URL, "");
         intent.putExtra(
                 ShortcutHelper.EXTRA_WEBAPK_PACKAGE_NAME, WebApkTestHelper.WEBAPK_PACKAGE_NAME);
         WebApkInfo info = WebApkInfo.create(intent);
 
         updateManager.updateIfNeeded(null, info);
     }
 
     private static void onGotUnchangedWebManifestData(WebApkUpdateManager updateManager) {
         onGotManifestData(updateManager, defaultManifestData());
     }
 
     private static void onGotManifestData(WebApkUpdateManager updateManager,
             ManifestData fetchedManifestData) {
-        String bestIconUrl = randomIconUrl(fetchedManifestData);
-        updateManager.onGotManifestData(infoFromManifestData(fetchedManifestData), bestIconUrl);
+        String bestPrimaryIconUrl = randomIconUrl(fetchedManifestData);
+        updateManager.onGotManifestData(infoFromManifestData(fetchedManifestData),
+                bestPrimaryIconUrl);
     }
 
     private static String randomIconUrl(ManifestData fetchedManifestData) {
         if (fetchedManifestData == null || fetchedManifestData.iconUrlToMurmur2HashMap.isEmpty()) {
             return null;
         }
         return fetchedManifestData.iconUrlToMurmur2HashMap.keySet().iterator().next();
     }
 
     /**
-     * Runs {@link WebApkUpdateManager#updateIfNeeded()} and returns whether an
-     * is-update-needed check has been triggered.
+     * Runs {@link WebApkUpdateManager#updateIfNeeded()} and returns whether an is-update-needed
+     * check has been triggered.
      */
     private boolean updateIfNeededChecksForUpdatedWebManifest() {
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         return updateManager.updateCheckStarted();
     }
 
     /**
      * Checks whether the WebAPK is updated given data from the WebAPK's Android Manifest and data
      * from the fetched Web Manifest.
      */
     private boolean checkUpdateNeededForFetchedManifest(
             ManifestData androidManifestData, ManifestData fetchedManifestData) {
         registerWebApk(androidManifestData, WebApkVersion.CURRENT_SHELL_APK_VERSION);
         mClock.advance(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL);
 
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         assertTrue(updateManager.updateCheckStarted());
         updateManager.onGotManifestData(
-                infoFromManifestData(fetchedManifestData), fetchedManifestData.bestIconUrl);
+                infoFromManifestData(fetchedManifestData), fetchedManifestData.bestPrimaryIconUrl);
         return updateManager.updateRequested();
     }
 
     @Before
     public void setUp() {
         ContextUtils.initApplicationContextForTests(RuntimeEnvironment.application);
         CommandLine.init(null);
         ChromeWebApkHost.initForTesting(true);
 
         registerWebApk(defaultManifestData(), WebApkVersion.CURRENT_SHELL_APK_VERSION);
         Settings.Secure.putInt(RuntimeEnvironment.application.getContentResolver(),
                 Settings.Secure.INSTALL_NON_MARKET_APPS, 1);
 
         mClock = new MockClock();
         WebappDataStorage.setClockForTests(mClock);
 
         WebappRegistry.getInstance().register(
                 WEBAPK_ID, new WebappRegistry.FetchWebappDataStorageCallback() {
                     @Override
-                    public void onWebappDataStorageRetrieved(WebappDataStorage storage) {}
+                    public void onWebappDataStorageRetrieved(WebappDataStorage storage) {
+                    }
                 });
         ShadowApplication.getInstance().runBackgroundTasks();
 
         WebappDataStorage storage = getStorage();
         storage.updateTimeOfLastCheckForUpdatedWebManifest();
         storage.updateTimeOfLastWebApkUpdateRequestCompletion();
         storage.updateDidLastWebApkUpdateRequestSucceed(true);
     }
 
     /**
      * Test that if the WebAPK update failed (e.g. because the WebAPK server is not reachable) that
      * the is-update-needed check is retried after less time than if the WebAPK update had
-     * succeeded.
-     * The is-update-needed check is the first step in retrying to update the WebAPK.
+     * succeeded. The is-update-needed check is the first step in retrying to update the WebAPK.
      */
     @Test
     public void testCheckUpdateMoreFrequentlyIfUpdateFails() {
         assertTrue(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL
                 > WebApkUpdateManager.RETRY_UPDATE_DURATION);
 
         WebappDataStorage storage = getStorage();
 
         assertTrue(storage.getDidLastWebApkUpdateRequestSucceed());
         assertFalse(updateIfNeededChecksForUpdatedWebManifest());
@@ skipping 60 matching lines @@
         }
 
         {
             // Relaunching the WebAPK should not do an is-update-needed-check.
             TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
             updateIfNeeded(updateManager);
             assertFalse(updateManager.updateCheckStarted());
         }
     }
 
     /**

[pkotwicz, 2017/02/03 18:42:15]

Leave the bullet points one per line with the AND on a seperate line

[F, 2017/02/06 12:40:12]

Acknowledged. Will avoid auto-formatter next time :)

-     * Test that the completion time of the previous WebAPK update is not modified if:
-     * - The previous WebAPK update succeeded.
-     * AND
-     * - A WebAPK update is not required.
+     * Test that the completion time of the previous WebAPK update is not modified if: - The
+     * previous WebAPK update succeeded. AND - A WebAPK update is not required.
      */
     @Test
     public void testUpdateNotNeeded() {
         long initialTime = mClock.currentTimeMillis();
         mClock.advance(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL);
 
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         assertTrue(updateManager.updateCheckStarted());
         onGotUnchangedWebManifestData(updateManager);
         assertFalse(updateManager.updateRequested());
 
         WebappDataStorage storage = getStorage();
         assertTrue(storage.getDidLastWebApkUpdateRequestSucceed());
         assertEquals(initialTime, storage.getLastWebApkUpdateRequestCompletionTime());
     }
 
     /**
-     * Test that the last WebAPK update is marked as having succeeded if:
-     * - The previous WebAPK update failed.
-     * AND
-     * - A WebAPK update is no longer required.
+     * Test that the last WebAPK update is marked as having succeeded if: - The previous WebAPK
+     * update failed. AND - A WebAPK update is no longer required.
      */
     @Test
     public void testMarkUpdateAsSucceededIfUpdateNoLongerNeeded() {
         WebappDataStorage storage = getStorage();
         storage.updateDidLastWebApkUpdateRequestSucceed(false);
         mClock.advance(WebApkUpdateManager.RETRY_UPDATE_DURATION);
 
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         assertTrue(updateManager.updateCheckStarted());
@@ skipping 24 matching lines @@
         // Chrome is killed. {@link WebApkUpdateManager#onBuiltWebApk} is never called.
 
         // Check {@link WebappDataStorage} state.
         WebappDataStorage storage = getStorage();
         assertFalse(storage.getDidLastWebApkUpdateRequestSucceed());
         assertEquals(
                 mClock.currentTimeMillis(), storage.getLastWebApkUpdateRequestCompletionTime());
     }
 
     /**
-     * Test that an update with data from the WebAPK's Android manifest is done if:
-     * - WebAPK's code is out of date
-     * AND
-     * - WebAPK's start_url does not refer to a Web Manifest.
-     *
-     * It is good to minimize the number of users with out of date WebAPKs. We try to keep WebAPKs
-     * up to date even if the web developer has removed the Web Manifest from their site.
+     * Test that an update with data from the WebAPK's Android manifest is done if: - WebAPK's code
+     * is out of date AND - WebAPK's start_url does not refer to a Web Manifest. It is good to
+     * minimize the number of users with out of date WebAPKs. We try to keep WebAPKs up to date even
+     * if the web developer has removed the Web Manifest from their site.
      */
     @Test
     public void testShellApkOutOfDateNoWebManifest() {
         registerWebApk(defaultManifestData(), WebApkVersion.CURRENT_SHELL_APK_VERSION - 1);
         mClock.advance(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL);
 
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         assertTrue(updateManager.updateCheckStarted());
 
@@ skipping 21 matching lines @@
         assertTrue(updateManager.updateCheckStarted());
 
         onGotManifestData(updateManager, defaultManifestData());
         assertTrue(updateManager.updateRequested());
         assertEquals(NAME, updateManager.requestedUpdateName());
 
         assertTrue(updateManager.destroyedFetcher());
     }
 
     /**
-     * Test that an update is requested if:
-     * - start_url does not refer to a Web Manifest.
-     * AND
-     * - The user eventually navigates to a page pointing to a Web Manifest with the correct URL.
-     * AND
-     * - The Web Manifest has changed.
-     *
-     * This scenario can occur if the WebAPK's start_url is a Javascript redirect.
+     * Test that an update is requested if: - start_url does not refer to a Web Manifest. AND - The
+     * user eventually navigates to a page pointing to a Web Manifest with the correct URL. AND -
+     * The Web Manifest has changed. This scenario can occur if the WebAPK's start_url is a
+     * Javascript redirect.
      */
     @Test
     public void testStartUrlRedirectsToPageWithUpdatedWebManifest() {
         mClock.advance(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL);
 
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         assertTrue(updateManager.updateCheckStarted());
 
         // start_url does not have a Web Manifest. No update should be requested.
         updateManager.onWebManifestForInitialUrlNotWebApkCompatible();
         assertFalse(updateManager.updateRequested());
         // {@link ManifestUpgradeDetector} should still be alive so that it can get
         // {@link #onGotManifestData} when page with the Web Manifest finishes loading.
         assertFalse(updateManager.destroyedFetcher());
 
         // start_url redirects to page with Web Manifest.
 
         ManifestData manifestData = defaultManifestData();
         manifestData.name = DIFFERENT_NAME;
         onGotManifestData(updateManager, manifestData);
         assertTrue(updateManager.updateRequested());
         assertEquals(DIFFERENT_NAME, updateManager.requestedUpdateName());
 
         assertTrue(updateManager.destroyedFetcher());
     }
 
     /**
-     * Test that an update is not requested if:
-     * - start_url does not refer to a Web Manifest.
-     * AND
-     * - The user eventually navigates to a page pointing to a Web Manifest with the correct URL.
-     * AND
+     * Test that an update is not requested if: - start_url does not refer to a Web Manifest. AND -
+     * The user eventually navigates to a page pointing to a Web Manifest with the correct URL. AND
      * - The Web Manifest has not changed.
      */
     @Test
     public void testStartUrlRedirectsToPageWithUnchangedWebManifest() {
         mClock.advance(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL);
 
         TestWebApkUpdateManager updateManager = new TestWebApkUpdateManager(mClock);
         updateIfNeeded(updateManager);
         updateManager.onWebManifestForInitialUrlNotWebApkCompatible();
         onGotManifestData(updateManager, defaultManifestData());
@@ skipping 37 matching lines @@
         assertTrue(
                 !oldData.scopeUrl.equals(ShortcutHelper.getScopeFromUrl(oldData.startUrl)));
         ManifestData fetchedData = defaultManifestData();
         fetchedData.startUrl = "/fancy/scope/special/snowflake.html";
         fetchedData.scopeUrl = "";
 
         assertTrue(checkUpdateNeededForFetchedManifest(oldData, fetchedData));
     }
 
     /**
-     * Test that an upgrade is requested when:
-     * - WebAPK was generated using icon at {@link ICON_URL} from Web Manifest.
-     * - Bitmap at {@link ICON_URL} has changed.
+     * Test that an upgrade is requested when: - WebAPK was generated using icon at {@link ICON_URL}
+     * from Web Manifest. - Bitmap at {@link ICON_URL} has changed.
      */
     @Test
     public void testHomescreenIconChangeShouldUpgrade() {
         ManifestData fetchedData = defaultManifestData();
-        fetchedData.iconUrlToMurmur2HashMap.put(fetchedData.bestIconUrl, ICON_MURMUR2_HASH + "1");
-        fetchedData.bestIcon = createBitmap(Color.BLUE);
+        fetchedData.iconUrlToMurmur2HashMap.put(fetchedData.bestPrimaryIconUrl,
+                ICON_MURMUR2_HASH + "1");
+        fetchedData.bestPrimaryIcon = createBitmap(Color.BLUE);
         assertTrue(checkUpdateNeededForFetchedManifest(defaultManifestData(), fetchedData));
     }
 
     /**
-     * Test that an upgrade is requested when:
-     * - WebAPK is generated using icon at {@link ICON_URL} from Web Manifest.
-     * - Web Manifest is updated to refer to different icon.
+     * Test that an upgrade is requested when: - WebAPK is generated using icon at {@link ICON_URL}
+     * from Web Manifest. - Web Manifest is updated to refer to different icon.
      */
     @Test
-    public void testHomescreenBestIconUrlChangeShouldUpgrade() {
+    public void testHomescreenBestPrimaryIconUrlChangeShouldUpgrade() {
         ManifestData fetchedData = defaultManifestData();
         fetchedData.iconUrlToMurmur2HashMap.clear();
         fetchedData.iconUrlToMurmur2HashMap.put("/icon2.png", "22");
-        fetchedData.bestIconUrl = "/icon2.png";
+        fetchedData.bestPrimaryIconUrl = "/icon2.png";
         assertTrue(checkUpdateNeededForFetchedManifest(defaultManifestData(), fetchedData));
     }
 
     /**
-     * Test that an upgrade is not requested if:
-     * - icon URL is added to the Web Manifest
-     * AND
-     * - "best" icon URL for the launcher icon did not change.
+     * Test that an upgrade is not requested if: - icon URL is added to the Web Manifest AND -
+     * "best" icon URL for the launcher icon did not change.
      */
     @Test
-    public void testIconUrlsChangeShouldNotUpgradeIfTheBestIconUrlDoesNotChange() {
+    public void testIconUrlsChangeShouldNotUpgradeIfTheBestPrimaryIconUrlDoesNotChange() {
         ManifestData fetchedData = defaultManifestData();
         fetchedData.iconUrlToMurmur2HashMap.clear();
         fetchedData.iconUrlToMurmur2HashMap.put(ICON_URL, ICON_MURMUR2_HASH);
         fetchedData.iconUrlToMurmur2HashMap.put("/icon2.png", null);
         assertFalse(checkUpdateNeededForFetchedManifest(defaultManifestData(), fetchedData));
     }
 
     /**
-     * Test than upgrade is requested if:
-     * - the WebAPK's meta data has murmur2 hashes for all of the icons.
-     * AND
-     * - the Web Manifest has not changed
-     * AND
-     * - the computed best icon URL is different from the one stored in the WebAPK's meta data.
+     * Test than upgrade is requested if: - the WebAPK's meta data has murmur2 hashes for all of the
+     * icons. AND - the Web Manifest has not changed AND - the computed best icon URL is different
+     * from the one stored in the WebAPK's meta data.
      */
     @Test
-    public void testWebManifestSameButBestIconUrlChangedShouldNotUpgrade() {
+    public void testWebManifestSameButBestPrimaryIconUrlChangedShouldNotUpgrade() {
         String iconUrl1 = "/icon1.png";
         String iconUrl2 = "/icon2.png";
         String hash1 = "11";
         String hash2 = "22";
 
         ManifestData oldData = defaultManifestData();
-        oldData.bestIconUrl = iconUrl1;
+        oldData.bestPrimaryIconUrl = iconUrl1;
         oldData.iconUrlToMurmur2HashMap.clear();
         oldData.iconUrlToMurmur2HashMap.put(iconUrl1, hash1);
         oldData.iconUrlToMurmur2HashMap.put(iconUrl2, hash2);
 
         ManifestData fetchedData = defaultManifestData();
-        fetchedData.bestIconUrl = iconUrl2;
+        fetchedData.bestPrimaryIconUrl = iconUrl2;
         fetchedData.iconUrlToMurmur2HashMap.clear();
         fetchedData.iconUrlToMurmur2HashMap.put(iconUrl1, null);
         fetchedData.iconUrlToMurmur2HashMap.put(iconUrl2, hash2);
 
         assertFalse(checkUpdateNeededForFetchedManifest(oldData, fetchedData));
     }
 
     @Test
     public void testForceUpdateWhenUncompletedUpdateRequestRechesMaximumTimes() {
         mClock.advance(WebApkUpdateManager.FULL_CHECK_UPDATE_INTERVAL);
@@ skipping 42 matching lines @@
         // Since {@link WebApkActivity#OnStop()} calls {@link requestPendingUpdate()} to trigger an
         // update request, we call it directly for testing.
         updateManager.setIsWebApkForeground(false);
         updateManager.requestPendingUpdate();
 
         assertFalse(updateManager.getHasPendingUpdateForTesting());
         assertTrue(updateManager.updateRequested());
         assertEquals(0, storage.getUpdateRequests());
     }
 }