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

chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappDataStorage.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 android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.graphics.Bitmap;
@@ skipping 66 matching lines @@
     // updates less frequently. crbug.com/680128.
     public static final long RELAXED_UPDATE_INTERVAL = TimeUnit.DAYS.toMillis(30L);
 
     // Number of milliseconds to wait before re-requesting an updated WebAPK from the WebAPK
     // server if the previous update attempt failed.
     public static final long RETRY_UPDATE_DURATION = TimeUnit.HOURS.toMillis(12L);
 
     // The default shell Apk version of WebAPKs.
     static final int DEFAULT_SHELL_APK_VERSION = 1;
 
-    // Invalid constants for timestamps and URLs. '0' is used as the invalid timestamp as
-    // WebappRegistry and WebApkUpdateManager assume that timestamps are always valid.
-    static final long TIMESTAMP_INVALID = 0;
+    // Unset/invalid constants for last used times and URLs. 0 is used as the null last used time as
+    // WebappRegistry assumes that this is always a valid timestamp.
+    static final long LAST_USED_UNSET = 0;
+    static final long LAST_USED_INVALID = -1;
     static final String URL_INVALID = "";
     static final int VERSION_INVALID = 0;
 
     // We use a heuristic to determine whether a web app is still installed on the home screen, as
     // there is no way to do so directly. Any web app which has been opened in the last ten days
     // is considered to be still on the home screen.
     static final long WEBAPP_LAST_OPEN_MAX_TIME = TimeUnit.DAYS.toMillis(10L);
 
     private static Clock sClock = new Clock();
     private static Factory sFactory = new Factory();
@@ skipping 31 matching lines @@
          */
         public long currentTimeMillis() {
             return System.currentTimeMillis();
         }
     }
 
     /**
      * Opens an instance of WebappDataStorage for the web app specified.
      * @param webappId The ID of the web app.
      */
-    static WebappDataStorage open(String webappId) {
-        return sFactory.create(webappId);
+    static WebappDataStorage open(final String webappId) {
+        final WebappDataStorage storage = sFactory.create(webappId);
+        if (storage.getLastUsedTime() == LAST_USED_INVALID) {
+            // If the last used time is invalid then ensure that there is no data in the
+            // WebappDataStorage which needs to be cleaned up.
+            assert storage.isEmpty();
+        }
+        return storage;
     }
 
     /**
      * Sets the clock used to get the current time.
      */
     @VisibleForTesting
     public static void setClockForTests(Clock clock) {
         sClock = clock;
     }
 
@@ skipping 154 matching lines @@
         mPreferences.edit().clear().apply();
     }
 
     /**
      * Deletes the URL and scope, and sets all timestamps to 0 in SharedPreferences.
      * This does not remove the stored splash screen image (if any) for the app.
      */
     void clearHistory() {
         SharedPreferences.Editor editor = mPreferences.edit();
 
-        editor.remove(KEY_LAST_USED);
+        // The last used time is set to 0 to ensure that a valid value is always present.
+        // If the web app is not launched prior to the next cleanup, then its remaining data will be
+        // removed. Otherwise, the next launch from home screen will update the last used time.
+        editor.putLong(KEY_LAST_USED, LAST_USED_UNSET);
         editor.remove(KEY_URL);
         editor.remove(KEY_SCOPE);
         editor.remove(KEY_LAST_CHECK_WEB_MANIFEST_UPDATE_TIME);
         editor.remove(KEY_LAST_UPDATE_REQUEST_COMPLETE_TIME);
         editor.remove(KEY_DID_LAST_UPDATE_REQUEST_SUCCEED);
         editor.remove(KEY_UPDATE_REQUESTED);
         editor.remove(KEY_RELAX_UPDATES);
         editor.remove(KEY_DISMISSED_DISCLOSURE);
         editor.apply();
     }
@@ skipping 19 matching lines @@
 
     /** Updates the source. */
     public void updateSource(int source) {
         mPreferences.edit().putInt(KEY_SOURCE, source).apply();
     }
 
     /**
      * Returns the last used time of this object, or -1 if it is not stored.
      */
     public long getLastUsedTime() {
-        return mPreferences.getLong(KEY_LAST_USED, TIMESTAMP_INVALID);
+        return mPreferences.getLong(KEY_LAST_USED, LAST_USED_INVALID);
     }
 
     /**
      * Update the information associated with the web app with the specified data. Used for testing.
      * @param splashScreenImage The image encoded as a string which should be shown on the splash
      *                          screen of the web app.
      */
     @VisibleForTesting
     void updateSplashScreenImageForTests(String splashScreenImage) {
         mPreferences.edit().putString(KEY_SPLASH_ICON, splashScreenImage).apply();
@@ skipping 21 matching lines @@
         mPreferences.edit()
                 .putLong(KEY_LAST_CHECK_WEB_MANIFEST_UPDATE_TIME, sClock.currentTimeMillis())
                 .apply();
     }
 
     /**
      * Returns the completion time of the last check for whether the WebAPK's Web Manifest was
      * updated. This time needs to be set when the WebAPK is registered.
      */
     private long getLastCheckForWebManifestUpdateTime() {
-        return mPreferences.getLong(KEY_LAST_CHECK_WEB_MANIFEST_UPDATE_TIME, TIMESTAMP_INVALID);
+        return mPreferences.getLong(KEY_LAST_CHECK_WEB_MANIFEST_UPDATE_TIME, LAST_USED_INVALID);
     }
 
     /**
      * Updates when the last WebAPK update request finished (successfully or unsuccessfully).
      */
     void updateTimeOfLastWebApkUpdateRequestCompletion() {
         mPreferences.edit()
                 .putLong(KEY_LAST_UPDATE_REQUEST_COMPLETE_TIME, sClock.currentTimeMillis())
                 .apply();
     }
 
     /**
      * Returns when the last WebAPK update request completed (successfully or unsuccessfully).
      * This time needs to be set when the WebAPK is registered.
      */
     long getLastWebApkUpdateRequestCompletionTime() {
-        return mPreferences.getLong(KEY_LAST_UPDATE_REQUEST_COMPLETE_TIME, TIMESTAMP_INVALID);
+        return mPreferences.getLong(KEY_LAST_UPDATE_REQUEST_COMPLETE_TIME, LAST_USED_INVALID);
     }
 
     /**
      * Updates whether the last update request to WebAPK Server succeeded.
      */
     void updateDidLastWebApkUpdateRequestSucceed(boolean success) {
         mPreferences.edit().putBoolean(KEY_DID_LAST_UPDATE_REQUEST_SUCCEED, success).apply();
     }
 
     /**
@@ skipping 41 matching lines @@
     int getLastRequestedShellApkVersion() {
         return mPreferences.getInt(KEY_LAST_REQUESTED_SHELL_APK_VERSION, DEFAULT_SHELL_APK_VERSION);
     }
 
     /**
      * Returns whether the previous WebAPK update attempt succeeded. Returns true if there has not
      * been any update attempts.
      */
     boolean didPreviousUpdateSucceed() {
         long lastUpdateCompletionTime = getLastWebApkUpdateRequestCompletionTime();
-        if (lastUpdateCompletionTime == TIMESTAMP_INVALID) {
+        if (lastUpdateCompletionTime == WebappDataStorage.LAST_USED_INVALID) {
             return true;
         }
         return getDidLastWebApkUpdateRequestSucceed();
     }
 
     /** Sets whether we should check for updates less frequently. */
     void setRelaxedUpdates(boolean relaxUpdates) {
         mPreferences.edit().putBoolean(KEY_RELAX_UPDATES, relaxUpdates).apply();
     }
 
@@ skipping 18 matching lines @@
     protected WebappDataStorage(String webappId) {
         mId = webappId;
         mPreferences = ContextUtils.getApplicationContext().getSharedPreferences(
                 SHARED_PREFS_FILE_PREFIX + webappId, Context.MODE_PRIVATE);
     }
 
     private boolean isEmpty() {
         return mPreferences.getAll().isEmpty();
     }
 }