[Android WebView] Ensure we have user consent before uploading minidumps

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.webkit.ValueCallback;
 
+import org.chromium.android_webview.UserConsentInterface;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.components.minidump_uploader.CrashFileManager;
 import org.chromium.components.minidump_uploader.MinidumpUploadCallable;
 import org.chromium.components.minidump_uploader.util.CrashReportingPermissionManager;
 
 import java.io.File;
 
 /**
  * Class in charge of uploading Minidumps from WebView's data directory.
  * This class gets invoked from a JobScheduler job and posts the operation of uploading minidumps to
  * a privately defined worker thread.
  * Note that this implementation is state-less in the sense that it doesn't keep track of whether it
  * successfully uploaded any minidumps. At the end of a job it simply checks whether there are any
  * minidumps left to upload, and if so, the job is rescheduled.
  */
 public class MinidumpUploaderImpl implements MinidumpUploader {
     private static final String TAG = "MinidumpUploaderImpl";
     private Thread mWorkerThread;
     private final CrashFileManager mFileManager;
 
     private Object mCancelLock = new Object();
     private boolean mCancelUpload = false;
 
     private final boolean mCleanOutMinidumps;
 
+    private final UserConsentInterface mUserConsentInterface;
+
     @VisibleForTesting
     public static final int MAX_UPLOAD_TRIES_ALLOWED = 3;
 
     /**
      * Notify the worker thread that the current job has been canceled - so we shouldn't upload any
      * more minidumps.
      */
     private void setCancelUpload(boolean cancel) {
         synchronized (mCancelLock) {
             mCancelUpload = cancel;
         }
     }
 
     /**
      * Check whether the current job has been canceled.
      */
     private boolean getCancelUpload() {
         synchronized (mCancelLock) {
             return mCancelUpload;
         }
     }
 
     @VisibleForTesting
-    public MinidumpUploaderImpl(Context context, boolean cleanOutMinidumps) {
+    public MinidumpUploaderImpl(
+            Context context, boolean cleanOutMinidumps, UserConsentInterface userConsentInterface) {
         File webviewCrashDir = CrashReceiverService.createWebViewCrashDir(context);
         mFileManager = new CrashFileManager(webviewCrashDir);
         if (!mFileManager.ensureCrashDirExists()) {
             Log.e(TAG, "Crash directory doesn't exist!");
         }
         mCleanOutMinidumps = cleanOutMinidumps;
+        mUserConsentInterface = userConsentInterface;
     }
 
     /**
      * Utility method to allow us to test the logic of this class by injecting
      * test-MinidumpUploadCallables.
      */
     @VisibleForTesting
     public MinidumpUploadCallable createMinidumpUploadCallable(File minidumpFile, File logfile) {
         return new MinidumpUploadCallable(
                 minidumpFile, logfile, createWebViewCrashReportingManager());
@@ skipping 23 matching lines @@
             /**
              * This method is already represented by isClientInMetricsSample() and
              * isNetworkAvailableForCrashUploads().
              */
             @Override
             public boolean isMetricsUploadPermitted() {
                 return true;
             }
             @Override
             public boolean isUsageAndCrashReportingPermittedByUser() {
-                // TODO(gsennton): make this depend on Android Checkbox when we can read that
-                // through GmsCore.
-                return false;
+                // We ensure we have user permission before starting to upload minidumps - so always
+                // return true here.
+                return true;
             }
             @Override
             public boolean isUploadEnabledForTests() {
                 return SynchronizedWebViewCommandLine.hasSwitch(
                         CrashReceiverService.CRASH_UPLOADS_ENABLED_FOR_TESTING_SWITCH);
             }
         };
     }
 
     /**
@@ skipping 37 matching lines @@
 
             // Reschedule if there are still minidumps to upload.
             boolean reschedule =
                     mFileManager.getAllMinidumpFiles(MAX_UPLOAD_TRIES_ALLOWED).length > 0;
             mUploadsFinishedCallback.uploadsFinished(reschedule);
         }
     }
 
     @Override
     public void uploadAllMinidumps(
-            MinidumpUploader.UploadsFinishedCallback uploadsFinishedCallback) {
+            final MinidumpUploader.UploadsFinishedCallback uploadsFinishedCallback) {
         if (mWorkerThread != null) {
             throw new RuntimeException("Only one upload-job should be active at a time");
         }
-        mWorkerThread = new Thread(new UploadRunnable(uploadsFinishedCallback), "mWorkerThread");
         setCancelUpload(false);
-        mWorkerThread.start();
+
+        // Abort if we cannot get the user-consent value.
+        if (!mUserConsentInterface.userConsentInterfaceAvailable()) {
+            uploadsFinishedCallback.uploadsFinished(false /* reschedule */);
+            return;
+        }
+
+        mUserConsentInterface.userConsents(new ValueCallback<Boolean>() {
+            @Override
+            public void onReceiveValue(Boolean enabled) {
+                // TODO if (mWorkerThread != null) return; ?
+                // This callback is posted to the UI thread when we know whether the U&D flag is
+                // toggled on or off. We need to check that the flag is on and that our job hasn't
+                // been cancelled already.
+                if (getCancelUpload()) {
+                    return;
+                }
+                if (enabled) {

[gsennton, 2017/01/13 19:01:55]

TODO also read enabledForTesting flag and have it override userPermission

[gsennton, 2017/01/23 17:50:40]

Done (in CrashReceiverService).

+                    mWorkerThread = new Thread(
+                            new UploadRunnable(uploadsFinishedCallback), "mWorkerThread");
+                    mWorkerThread.start();
+                } else {
+                    uploadsFinishedCallback.uploadsFinished(false /* reschedule */);
+                }
+            }
+        });
     }
 
     /**
      * @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;
     }
 }