[Android WebView] Always schedule new upload job after copying minidump.

android_webview/java/src/org/chromium/android_webview/crash/MinidumpUploaderImpl.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.android_webview.crash;
 
 import android.content.Context;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.webkit.ValueCallback;
@@ skipping 143 matching lines @@
         public void run() {
             File[] minidumps = mFileManager.getAllMinidumpFiles(MAX_UPLOAD_TRIES_ALLOWED);
             for (File minidump : minidumps) {
                 // Store the name of the current minidump so that we can mark it as a failure from
                 // the main thread if JobScheduler tells us to stop.
                 MinidumpUploadCallable uploadCallable = createMinidumpUploadCallable(
                         minidump, mFileManager.getCrashUploadLogFile());
                 int uploadResult = uploadCallable.call();
 
                 // Job was canceled -> early out: any clean-up will be performed in cancelUploads().
+                // Note that we check whether we are canceled AFTER trying to upload a minidump -
+                // this is to allow the uploading of at least one minidump per job (to deal with
+                // cases where we reschedule jobs over and over again and would never upload any
+                // minidumps because old jobs are canceled when scheduling new jobs).
                 if (getCancelUpload()) return;
 
                 if (uploadResult == MinidumpUploadCallable.UPLOAD_FAILURE) {
                     String newName = CrashFileManager.tryIncrementAttemptNumber(minidump);
                     if (newName == null) {
                         Log.w(TAG, "Failed to increment attempt number of " + minidump);
                     }
                 }
             }
 
@@ skipping 21 matching lines @@
         mWorkerThread = new Thread(new UploadRunnable(uploadsFinishedCallback), "mWorkerThread");
         setCancelUpload(false);
 
         createPlatformServiceBridge().queryMetricsSetting(new ValueCallback<Boolean>() {
             public void onReceiveValue(Boolean enabled) {
                 // This callback should be received on the main thread (e.g. mWorkerThread
                 // is not thread-safe).
                 ThreadUtils.assertOnUiThread();
 
                 mPermittedByUser = enabled;
-                // Our job might have been cancelled by now - make sure we honour this.
-                if (!getCancelUpload()) {
-                    mWorkerThread.start();
-                }
+                // Note that our job might have been cancelled by this time - however, we do start
+                // our worker thread anyway to try to make some progress towards uploading
+                // minidumps.
+                // This is to ensure that in the case where an app is crashing over and over again
+                // - and we are rescheduling jobs over and over again - we are still uploading at
+                // least one minidump per job, as long as that job starts before it is canceled by
+                // the next job.
+                // For cases where the job is cancelled because the network connection is lost, or
+                // because we switch over to a metered connection, we won't try to upload any
+                // minidumps anyway since we check the network connection just before the upload of
+                // each minidump.
+                mWorkerThread.start();
             }
         });
     }
 
+    @VisibleForTesting
+    public void joinWorkerThreadForTesting() throws InterruptedException {
+        mWorkerThread.join();
+    }
+
     /**
      * @return whether to reschedule the uploads.
      */
     @Override
     public boolean cancelUploads() {
         setCancelUpload(true);
 
         // Reschedule if there are still minidumps to upload.
         return mFileManager.getAllMinidumpFiles(MAX_UPLOAD_TRIES_ALLOWED).length > 0;
     }
 }