[Android] Provide an API for manually triggering a crash report upload.

chrome/android/java/src/org/chromium/chrome/browser/crash/CrashFileManager.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.crash;
 
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 
 import java.io.File;
@@ skipping 27 matching lines @@
             Pattern.compile("\\.dmp([0-9]*)$\\z");
 
     private static final Pattern MINIDUMP_MIME_FIRST_TRY_PATTERN =
             Pattern.compile("\\.dmp([0-9]+)$\\z");
 
     private static final Pattern MINIDUMP_PATTERN =
             Pattern.compile("\\.dmp([0-9]*)(\\.try[0-9])?\\z");
 
     private static final Pattern UPLOADED_MINIDUMP_PATTERN = Pattern.compile("\\.up([0-9]*)\\z");
 
+    private static final String NOT_YET_UPLOADED_MINIDUMP_SUFFIX = ".dmp";
+
     private static final String UPLOADED_MINIDUMP_SUFFIX = ".up";
 
     private static final String UPLOAD_SKIPPED_MINIDUMP_SUFFIX = ".skipped";
 
+    private static final String UPLOAD_FORCED_MINIDUMP_SUFFIX = ".forced";
+
     private static final String UPLOAD_ATTEMPT_DELIMITER = ".try";
 
     @VisibleForTesting
     protected static final String TMP_SUFFIX = ".tmp";
 
     private static final Pattern TMP_PATTERN = Pattern.compile("\\.tmp\\z");
 
     // The maximum number of non-uploaded crashes that may be kept in the crash reports directory.
     // Chosen to attempt to balance between keeping a generous number of crashes, and not using up
     // too much filesystem storage space for obsolete crash reports.
@@ skipping 47 matching lines @@
     }
 
     /**
      * @return The file name to rename to after an addition attempt to upload
      */
     @VisibleForTesting
     public static String filenameWithIncrementedAttemptNumber(String filename) {
         int numTried = readAttemptNumber(filename);
         if (numTried > 0) {
             int newCount = numTried + 1;
-            return filename.replaceAll(UPLOAD_ATTEMPT_DELIMITER + numTried,
-                    UPLOAD_ATTEMPT_DELIMITER + newCount);
+            return filename.replace(
+                    UPLOAD_ATTEMPT_DELIMITER + numTried, UPLOAD_ATTEMPT_DELIMITER + newCount);
         } else {
             return filename + UPLOAD_ATTEMPT_DELIMITER + "1";
         }
     }
 
+    /**
+     * Attempts to rename the given file to clear any state from previous upload attempts,

[gayane -on leave until 09-2017, 2016/09/06 17:00:00]

The comment needs an update

[Ilya Sherman, 2016/09/07 00:54:01]

Done.

+     * essentially treating as a fresh minidump file. This is useful for manually initiating
+     * previously skipped uploads.
+     *
+     * @return The renamed file, or null if renaming failed.
+     */
+    public static File trySetForcedUpload(File fileToUpload) {
+        if (fileToUpload.getName().contains(UPLOADED_MINIDUMP_SUFFIX)) {
+            Log.w(TAG, "Refusing to reset upload attempt state for a file that has already been "
+                            + "successfully uploaded: " + fileToUpload.getName());
+            return null;
+        }
+        File renamedFile = new File(filenameWithForcedUploadState(fileToUpload.getPath()));
+        return fileToUpload.renameTo(renamedFile) ? renamedFile : null;
+    }
+
+    /**
+     * @return True iff the provided File was manually forced (by the user) to be uploaded.
+     */
+    public static boolean isForcedUpload(File fileToUpload) {
+        return fileToUpload.getName().contains(UPLOAD_FORCED_MINIDUMP_SUFFIX);
+    }
+
+    /**
+     * @return The filename to rename to so as to clear any upload attempt history.
+     */
+    @VisibleForTesting
+    protected static String filenameWithForcedUploadState(String filename) {
+        int numTried = readAttemptNumber(filename);
+        if (numTried > 0) {
+            filename = filename.replace(
+                    UPLOAD_ATTEMPT_DELIMITER + numTried, UPLOAD_ATTEMPT_DELIMITER + 0);
+        }
+        filename = filename.replace(UPLOAD_SKIPPED_MINIDUMP_SUFFIX, UPLOAD_FORCED_MINIDUMP_SUFFIX);
+        return filename.replace(NOT_YET_UPLOADED_MINIDUMP_SUFFIX, UPLOAD_FORCED_MINIDUMP_SUFFIX);
+    }
+
     @VisibleForTesting
     public static int readAttemptNumber(String filename) {
         int tryIndex = filename.lastIndexOf(UPLOAD_ATTEMPT_DELIMITER);
         if (tryIndex >= 0) {
             tryIndex += UPLOAD_ATTEMPT_DELIMITER.length();
             // To avoid out of bound exceptions
             if (tryIndex < filename.length()) {
                 // We don't try more than 3 times.
                 String numTriesString = filename.substring(
                         tryIndex, tryIndex + 1);
@@ skipping 28 matching lines @@
     public static void markUploadSkipped(File crashDumpFile) {
         CrashFileManager.renameCrashDumpFollowingUpload(
                 crashDumpFile, UPLOAD_SKIPPED_MINIDUMP_SUFFIX);
     }
 
     /**
      * Renames a crash dump file. However, if renaming fails, attempts to delete the file
      * immediately.
      */
     private static void renameCrashDumpFollowingUpload(File crashDumpFile, String suffix) {
-        boolean renamed = crashDumpFile.renameTo(
-                new File(crashDumpFile.getPath().replaceAll("\\.dmp", suffix)));
+        // The pre-upload filename might have been either "foo.dmpN.tryM" or "foo.forcedN.tryM".
+        String newName = crashDumpFile.getPath()
+                                 .replace(NOT_YET_UPLOADED_MINIDUMP_SUFFIX, suffix)
+                                 .replace(UPLOAD_FORCED_MINIDUMP_SUFFIX, suffix);
+        boolean renamed = crashDumpFile.renameTo(new File(newName));
         if (!renamed) {
             Log.w(TAG, "Failed to rename " + crashDumpFile);
             if (!crashDumpFile.delete()) {
                 Log.w(TAG, "Failed to delete " + crashDumpFile);
             }
         }
     }
 
     private final File mCacheDir;
 
@@ skipping 119 matching lines @@
                         + f.getAbsolutePath());
             }
         }
         return f;
     }
 
     File getCrashFile(String filename) {
         return new File(getCrashDirectory(), filename);
     }
 
+    /**
+     * Returns the minidump file with the given local ID, or null if no previously minidump file has
+     * the given ID.
+     * NOTE: Crash files that have already been successfully uploaded are not included.
+     *
+     * @param localId The local ID of the crash report.
+     * @return The matching File, or null if no matching file is found.
+     */
+    File getCrashFileWithLocalId(String localId) {
+        for (File f : getAllFilesSorted()) {
+            // Only match non-uploaded or previously skipped files.
+            if (!f.getName().contains(NOT_YET_UPLOADED_MINIDUMP_SUFFIX)
+                    && !f.getName().contains(UPLOAD_SKIPPED_MINIDUMP_SUFFIX)
+                    && !f.getName().contains(UPLOAD_FORCED_MINIDUMP_SUFFIX)) {
+                continue;
+            }
+
+            String filenameSansExtension = f.getName().split("\\.")[0];
+            if (filenameSansExtension.endsWith(localId)) {
+                return f;
+            }
+        }
+        return null;
+    }
+
     File getCrashUploadLogFile() {
         return new File(getCrashDirectory(), CRASH_DUMP_LOGFILE);
     }
 
     private File[] getAllTempFiles() {
         return getMatchingFiles(TMP_PATTERN);
     }
 }