Revert of [Android Refactor] Merge WebappDataStorage#LAST_USED_UNSET and LAST_USED_INVALID

chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebappRegistryTest.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.webapps;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.text.TextUtils;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowLooper;
 
 import org.chromium.base.ContextUtils;
 import org.chromium.base.test.util.Feature;
 import org.chromium.chrome.browser.ShortcutHelper;
 import org.chromium.chrome.browser.browsing_data.UrlFilters;
 import org.chromium.testing.local.BackgroundShadowAsyncTask;
 import org.chromium.testing.local.LocalRobolectricTestRunner;
@@ skipping 89 matching lines @@
     }
 
     @Test
     @Feature({"Webapp"})
     public void testWebappRegistrationUpdatesLastUsed() throws Exception {
         registerWebapp("test", null);
 
         long after = System.currentTimeMillis();
         SharedPreferences webAppPrefs = ContextUtils.getApplicationContext().getSharedPreferences(
                 WebappDataStorage.SHARED_PREFS_FILE_PREFIX + "test", Context.MODE_PRIVATE);
-        long actual = webAppPrefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
+        long actual = webAppPrefs.getLong(WebappDataStorage.KEY_LAST_USED,
+                WebappDataStorage.LAST_USED_INVALID);
         assertTrue("Timestamp is out of range", actual <= after);
     }
 
     @Test
     @Feature({"Webapp"})
     public void testWebappIdsRetrieval() throws Exception {
         final Set<String> expected = addWebappsToRegistry("first", "second");
         assertEquals(expected, WebappRegistry.getRegisteredWebappIdsForTesting());
     }
 
@@ skipping 98 matching lines @@
                 WebappDataStorage.SHARED_PREFS_FILE_PREFIX + "oldWebapp", Context.MODE_PRIVATE);
         webAppPrefs.edit().putLong(WebappDataStorage.KEY_LAST_USED, Long.MIN_VALUE).apply();
 
         // Force a re-read of the preferences from disk.
         WebappRegistry.refreshSharedPrefsForTesting();
         WebappRegistry.getInstance().unregisterOldWebapps(currentTime);
 
         Set<String> actual = getRegisteredWebapps();
         assertEquals(new HashSet<>(Arrays.asList("oldWebapp")), actual);
 
-        long actualLastUsed = webAppPrefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
+        long actualLastUsed = webAppPrefs.getLong(WebappDataStorage.KEY_LAST_USED,
+                WebappDataStorage.LAST_USED_INVALID);
         assertEquals(Long.MIN_VALUE, actualLastUsed);
 
         // The last cleanup time was set to 0 in setUp() so check that this hasn't changed.
         long lastCleanup = mSharedPreferences.getLong(WebappRegistry.KEY_LAST_CLEANUP, -1);
         assertEquals(INITIAL_TIME, lastCleanup);
     }
 
     @Test
     @Feature({"Webapp"})
     public void testCleanupDoesNotRemoveRecentApps() throws Exception {
@@ skipping 11 matching lines @@
         WebappRegistry.refreshSharedPrefsForTesting();
 
         // Because the time is just inside the window, there should be a cleanup but the web app
         // should not be deleted as it was used recently. The last cleanup time should also be
         // set to the current time.
         WebappRegistry.getInstance().unregisterOldWebapps(currentTime);
 
         Set<String> actual = getRegisteredWebapps();
         assertEquals(new HashSet<>(Arrays.asList("recentWebapp")), actual);
 
-        long actualLastUsed = webAppPrefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
+        long actualLastUsed = webAppPrefs.getLong(WebappDataStorage.KEY_LAST_USED,
+                WebappDataStorage.LAST_USED_INVALID);
         assertEquals(lastUsed, actualLastUsed);
 
         long lastCleanup = mSharedPreferences.getLong(WebappRegistry.KEY_LAST_CLEANUP, -1);
         assertEquals(currentTime, lastCleanup);
     }
 
     @Test
     @Feature({"Webapp"})
     public void testCleanupRemovesOldApps() throws Exception {
         // Put the current time such that the task runs.
         long currentTime = INITIAL_TIME + WebappRegistry.FULL_CLEANUP_DURATION;
 
         // Put the last used time just outside the no-cleanup window.
         addWebappsToRegistry("oldWebapp");
         SharedPreferences webAppPrefs = ContextUtils.getApplicationContext().getSharedPreferences(
                 WebappDataStorage.SHARED_PREFS_FILE_PREFIX + "oldWebapp", Context.MODE_PRIVATE);
         long lastUsed = currentTime - WebappRegistry.WEBAPP_UNOPENED_CLEANUP_DURATION;
         webAppPrefs.edit().putLong(WebappDataStorage.KEY_LAST_USED, lastUsed).apply();
 
         // Force a re-read of the preferences from disk.
         WebappRegistry.refreshSharedPrefsForTesting();
 
         // Because the time is just inside the window, there should be a cleanup of old web apps and
         // the last cleaned up time should be set to the current time.
         WebappRegistry.getInstance().unregisterOldWebapps(currentTime);
 
         Set<String> actual = getRegisteredWebapps();
         assertTrue(actual.isEmpty());
 
-        long actualLastUsed = webAppPrefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
-        assertEquals(WebappDataStorage.TIMESTAMP_INVALID, actualLastUsed);
+        long actualLastUsed = webAppPrefs.getLong(WebappDataStorage.KEY_LAST_USED,
+                WebappDataStorage.LAST_USED_INVALID);
+        assertEquals(WebappDataStorage.LAST_USED_INVALID, actualLastUsed);
 
         long lastCleanup = mSharedPreferences.getLong(WebappRegistry.KEY_LAST_CLEANUP, -1);
         assertEquals(currentTime, lastCleanup);
     }
 
     @Test
     @Feature({"WebApk"})
     public void testCleanupRemovesUninstalledWebApks() throws Exception {
         String webappId1 = "webapk:uninstalledWebApk1";
         String webApkPackage1 = "uninstalledWebApk1";
@@ skipping 87 matching lines @@
         FetchStorageCallback storageCallback2 = new FetchStorageCallback(shortcutIntent2);
         registerWebapp("webapp2", storageCallback2);
         assertTrue(storageCallback2.getCallbackCalled());
 
         SharedPreferences webapp1Prefs = ContextUtils.getApplicationContext().getSharedPreferences(
                 WebappDataStorage.SHARED_PREFS_FILE_PREFIX + "webapp1", Context.MODE_PRIVATE);
         SharedPreferences webapp2Prefs = ContextUtils.getApplicationContext().getSharedPreferences(
                 WebappDataStorage.SHARED_PREFS_FILE_PREFIX + "webapp2", Context.MODE_PRIVATE);
 
         long webapp1OriginalLastUsed = webapp2Prefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_UNSET);
         long webapp2OriginalLastUsed = webapp2Prefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
-        assertTrue(webapp1OriginalLastUsed != WebappDataStorage.TIMESTAMP_INVALID);
-        assertTrue(webapp2OriginalLastUsed != WebappDataStorage.TIMESTAMP_INVALID);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_UNSET);
+        assertTrue(webapp1OriginalLastUsed != WebappDataStorage.LAST_USED_UNSET);
+        assertTrue(webapp2OriginalLastUsed != WebappDataStorage.LAST_USED_UNSET);
 
         // Clear data for |webapp1Url|.
         WebappRegistry.getInstance().clearWebappHistoryForUrlsImpl(
                 new UrlFilters.OneUrl(webapp1Url));
 
         Set<String> actual = getRegisteredWebapps();
         assertEquals(2, actual.size());
         assertTrue(actual.contains("webapp1"));
         assertTrue(actual.contains("webapp2"));
 
         // Verify that the last used time for the first web app is
-        // WebappDataStorage.TIMESTAMP_INVALID, while for the second one it's unchanged.
+        // WebappDataStorage.LAST_USED_UNSET, while for the second one it's unchanged.
         long actualLastUsed = webapp1Prefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
-        assertEquals(WebappDataStorage.TIMESTAMP_INVALID, actualLastUsed);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_UNSET);
+        assertEquals(WebappDataStorage.LAST_USED_UNSET, actualLastUsed);
         actualLastUsed = webapp2Prefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_UNSET);
         assertEquals(webapp2OriginalLastUsed, actualLastUsed);
 
         // Verify that the URL and scope for the first web app is WebappDataStorage.URL_INVALID,
         // while for the second one it's unchanged.
         String actualScope = webapp1Prefs.getString(
                 WebappDataStorage.KEY_SCOPE, WebappDataStorage.URL_INVALID);
         assertEquals(WebappDataStorage.URL_INVALID, actualScope);
         String actualUrl = webapp1Prefs.getString(
                 WebappDataStorage.KEY_URL, WebappDataStorage.URL_INVALID);
         assertEquals(WebappDataStorage.URL_INVALID, actualUrl);
         actualScope = webapp2Prefs.getString(
                 WebappDataStorage.KEY_SCOPE, WebappDataStorage.URL_INVALID);
         assertEquals(webapp2Url + "/", actualScope);
         actualUrl = webapp2Prefs.getString(
                 WebappDataStorage.KEY_URL, WebappDataStorage.URL_INVALID);
         assertEquals(webapp2Url, actualUrl);
 
         // Clear data for all urls.
         WebappRegistry.getInstance().clearWebappHistoryForUrlsImpl(new UrlFilters.AllUrls());
 
-        // Verify that the last used time for both web apps is WebappDataStorage.TIMESTAMP_INVALID.
+        // Verify that the last used time for both web apps is WebappDataStorage.LAST_USED_UNSET.
         actualLastUsed = webapp1Prefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
-        assertEquals(WebappDataStorage.TIMESTAMP_INVALID, actualLastUsed);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_UNSET);
+        assertEquals(WebappDataStorage.LAST_USED_UNSET, actualLastUsed);
         actualLastUsed = webapp2Prefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
-        assertEquals(WebappDataStorage.TIMESTAMP_INVALID, actualLastUsed);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_UNSET);
+        assertEquals(WebappDataStorage.LAST_USED_UNSET, actualLastUsed);
 
         // Verify that the URL and scope for both web apps is WebappDataStorage.URL_INVALID.
         actualScope = webapp1Prefs.getString(
                 WebappDataStorage.KEY_SCOPE, WebappDataStorage.URL_INVALID);
         assertEquals(WebappDataStorage.URL_INVALID, actualScope);
         actualUrl = webapp1Prefs.getString(
                 WebappDataStorage.KEY_URL, WebappDataStorage.URL_INVALID);
         assertEquals(WebappDataStorage.URL_INVALID, actualUrl);
         actualScope = webapp2Prefs.getString(
                 WebappDataStorage.KEY_SCOPE, WebappDataStorage.URL_INVALID);
@@ skipping 10 matching lines @@
 
         SharedPreferences webappPrefs = ContextUtils.getApplicationContext().getSharedPreferences(
                 WebappDataStorage.SHARED_PREFS_FILE_PREFIX + "webapp", Context.MODE_PRIVATE);
         WebappRegistry.getInstance().clearWebappHistoryForUrlsImpl(new UrlFilters.AllUrls());
 
         // Open the webapp up and set the last used time.
         WebappRegistry.getInstance().getWebappDataStorage("webapp").updateLastUsedTime();
 
         // Verify that the last used time is valid.
         long actualLastUsed = webappPrefs.getLong(
-                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.TIMESTAMP_INVALID);
-        assertTrue(WebappDataStorage.TIMESTAMP_INVALID != actualLastUsed);
+                WebappDataStorage.KEY_LAST_USED, WebappDataStorage.LAST_USED_INVALID);
+        assertTrue(WebappDataStorage.LAST_USED_INVALID != actualLastUsed);
+        assertTrue(WebappDataStorage.LAST_USED_UNSET != actualLastUsed);
     }
 
     @Test
     @Feature({"Webapp"})
     public void testUpdateAfterClearWebappHistory() throws Exception {
         final String webappUrl = "http://www.google.com";
         final String webappScope = "http://www.google.com/";
         final Intent shortcutIntent = createShortcutIntent(webappUrl);
         registerWebapp("webapp", new FetchStorageCallback(shortcutIntent));
 
@@ skipping 111 matching lines @@
     }
 
     private Intent createWebApkIntent(String webappId, String webApkPackage) {
         Intent intent = new Intent();
         intent.putExtra(ShortcutHelper.EXTRA_ID, webappId)
                 .putExtra(ShortcutHelper.EXTRA_URL, "https://foo.com")
                 .putExtra(WebApkConstants.EXTRA_WEBAPK_PACKAGE_NAME, webApkPackage);
         return intent;
     }
 }