[Android WebView] Ensure Android Checkbox is on when uploading minidumps

android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.java

Index: android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.java
diff --git a/android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.java b/android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.java
index 0f39c4c4fe377d4cc63311ed13a89026b4cbd9bc..1ff8dc96dd7392e79809448409e17a11f0418809 100644
--- a/android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.java
+++ b/android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.java
@@ -9,11 +9,14 @@ import static org.chromium.base.test.util.ScalableTimeout.scaleTimeout;
 import android.content.Context;
 import android.os.ParcelFileDescriptor;
 import android.test.suitebuilder.annotation.MediumTest;
+import android.webkit.ValueCallback;
 
+import org.chromium.android_webview.PlatformServiceBridge;
 import org.chromium.android_webview.crash.CrashReceiverService;
 import org.chromium.android_webview.crash.MinidumpUploader;
 import org.chromium.android_webview.crash.MinidumpUploaderImpl;
 import org.chromium.base.FileUtils;
+import org.chromium.base.ThreadUtils;
 import org.chromium.components.minidump_uploader.CrashFileManager;
 import org.chromium.components.minidump_uploader.CrashTestCase;
 import org.chromium.components.minidump_uploader.MinidumpUploadCallable;
@@ -47,6 +50,51 @@ public class MinidumpUploaderTest extends CrashTestCase {
         return CrashReceiverService.createWebViewCrashDir(getInstrumentation().getTargetContext());
     }
 
+    private static class TestPlatformServiceBridge extends PlatformServiceBridge {
+        boolean mCanUseGms;
+        boolean mUserPermitted;
+
+        public TestPlatformServiceBridge(boolean canUseGms, boolean userPermitted) {
+            mCanUseGms = canUseGms;
+            mUserPermitted = userPermitted;
+        }
+
+        @Override
+        public boolean canUseGms() {
+            return mCanUseGms;
+        }
+
+        @Override
+        public void queryMetricsSetting(ValueCallback<Boolean> callback) {
+            ThreadUtils.assertOnUiThread();
+            callback.onReceiveValue(mUserPermitted);
+        }
+    }
+
+    private static class TestMinidumpUploaderImpl extends MinidumpUploaderImpl {
+        private CrashReportingPermissionManager mPermissionManager;
+
+        TestMinidumpUploaderImpl(Context context, CrashReportingPermissionManager permissionManager,
+                boolean cleanOutMinidumps) {
+            super(context, cleanOutMinidumps);
+            mPermissionManager = permissionManager;
+        }
+
+        @Override
+        public MinidumpUploadCallable createMinidumpUploadCallable(
+                File minidumpFile, File logfile) {
+            return new MinidumpUploadCallable(minidumpFile, logfile,
+                    new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(),
+                    mPermissionManager);
+        }
+
+        @Override
+        public PlatformServiceBridge createPlatformServiceBridge() {
+            return new TestPlatformServiceBridge(true /* canUseGms */,
+                    mPermissionManager.isUsageAndCrashReportingPermittedByUser());
+        }
+    }
+
     /**
      * Test to ensure the minidump uploading mechanism behaves as expected when we fail to upload
      * minidumps.
@@ -64,15 +112,9 @@ public class MinidumpUploaderTest extends CrashTestCase {
                         mIsEnabledForTests = false;
                     }
                 };
-        MinidumpUploader minidumpUploader = new MinidumpUploaderImpl(
-                getInstrumentation().getTargetContext(), false /* cleanOutMinidumps */) {
-            @Override
-            public MinidumpUploadCallable createMinidumpUploadCallable(
-                    File minidumpFile, File logfile) {
-                return new MinidumpUploadCallable(minidumpFile, logfile,
-                        new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(), permManager);
-            }
-        };
+        MinidumpUploader minidumpUploader =
+                new TestMinidumpUploaderImpl(getInstrumentation().getTargetContext(), permManager,
+                        false /* cleanOutMinidumps */);
 
         File firstFile = createMinidumpFileInCrashDir("1_abc.dmp0");
         File secondFile = createMinidumpFileInCrashDir("12_abc.dmp0");
@@ -98,16 +140,31 @@ public class MinidumpUploaderTest extends CrashTestCase {
         assertTrue(maxTriesFile.exists());
     }
 
-    private static void uploadMinidumpsSync(
-            MinidumpUploader minidumpUploader, final boolean expectReschedule) {
-        final CountDownLatch uploadsFinishedLatch = new CountDownLatch(1);
-        minidumpUploader.uploadAllMinidumps(new MinidumpUploader.UploadsFinishedCallback() {
+    /**
+     * Utility method for running {@param minidumpUploader}.uploadAllMinidumps on the UI thread to
+     * avoid breaking any assertions about running on the UI thread.
+     */
+    private static void uploadAllMinidumpsOnUiThread(final MinidumpUploader minidumpUploader,
+            final MinidumpUploader.UploadsFinishedCallback uploadsFinishedCallback) {
+        ThreadUtils.runOnUiThread(new Runnable() {
             @Override
-            public void uploadsFinished(boolean reschedule) {
-                assertEquals(expectReschedule, reschedule);
-                uploadsFinishedLatch.countDown();
+            public void run() {
+                minidumpUploader.uploadAllMinidumps(uploadsFinishedCallback);
             }
         });
+    }
+
+    private static void uploadMinidumpsSync(
+            MinidumpUploader minidumpUploader, final boolean expectReschedule) {
+        final CountDownLatch uploadsFinishedLatch = new CountDownLatch(1);
+        uploadAllMinidumpsOnUiThread(
+                minidumpUploader, new MinidumpUploader.UploadsFinishedCallback() {
+                    @Override
+                    public void uploadsFinished(boolean reschedule) {
+                        assertEquals(expectReschedule, reschedule);
+                        uploadsFinishedLatch.countDown();
+                    }
+                });
         try {
             assertTrue(uploadsFinishedLatch.await(
                     scaleTimeout(TIME_OUT_MILLIS), TimeUnit.MILLISECONDS));
@@ -131,15 +188,9 @@ public class MinidumpUploaderTest extends CrashTestCase {
                 new MockCrashReportingPermissionManager() {
                     { mIsEnabledForTests = true; }
                 };
-        MinidumpUploader minidumpUploader = new MinidumpUploaderImpl(
-                getInstrumentation().getTargetContext(), false /* cleanOutMinidumps */) {
-            @Override
-            public MinidumpUploadCallable createMinidumpUploadCallable(
-                    File minidumpFile, File logfile) {
-                return new MinidumpUploadCallable(minidumpFile, logfile,
-                        new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(), permManager);
-            }
-        };
+        MinidumpUploader minidumpUploader =
+                new TestMinidumpUploaderImpl(getInstrumentation().getTargetContext(), permManager,
+                        false /* cleanOutMinidumps */);
 
         File firstFile = createMinidumpFileInCrashDir("1_abc.dmp0");
         File secondFile = createMinidumpFileInCrashDir("12_abcd.dmp0");
@@ -160,8 +211,8 @@ public class MinidumpUploaderTest extends CrashTestCase {
         MinidumpUploadCallable createCallable(File minidumpFile, File logfile);
     }
 
-    private static MinidumpUploaderImpl createCallableListMinidumpUploader(
-            Context context, final List<MinidumpUploadCallableCreator> callables) {
+    private static MinidumpUploaderImpl createCallableListMinidumpUploader(Context context,
+            final List<MinidumpUploadCallableCreator> callables, final boolean userPermitted) {
         return new MinidumpUploaderImpl(context, false /* cleanOutMinidumps */) {
             private int mIndex = 0;
 
@@ -173,6 +224,10 @@ public class MinidumpUploaderTest extends CrashTestCase {
                 }
                 return callables.get(mIndex++).createCallable(minidumpFile, logfile);
             }
+            @Override
+            public PlatformServiceBridge createPlatformServiceBridge() {
+                return new TestPlatformServiceBridge(true /* canUseGms*/, userPermitted);
+            }
         };
     }
 
@@ -197,8 +252,9 @@ public class MinidumpUploaderTest extends CrashTestCase {
                         new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(), permManager);
             }
         });
-        MinidumpUploader minidumpUploader = createCallableListMinidumpUploader(
-                getInstrumentation().getTargetContext(), callables);
+        MinidumpUploader minidumpUploader =
+                createCallableListMinidumpUploader(getInstrumentation().getTargetContext(),
+                        callables, permManager.isUsageAndCrashReportingPermittedByUser());
 
         File firstFile = createMinidumpFileInCrashDir("firstFile.dmp0");
         File secondFile = createMinidumpFileInCrashDir("secondFile.dmp0");
@@ -276,18 +332,25 @@ public class MinidumpUploaderTest extends CrashTestCase {
                 return new MinidumpUploadCallable(
                         minidumpFile, logfile, new StallingHttpUrlConnectionFactory(), permManager);
             }
+            @Override
+            public PlatformServiceBridge createPlatformServiceBridge() {
+                return new TestPlatformServiceBridge(
+                        true /* canUseGms*/, permManager.isUsageAndCrashReportingPermittedByUser());
+            }
         };
 
         File firstFile = createMinidumpFileInCrashDir("123_abc.dmp0");
         File nonExpectedFirstUploadFile = new File(mCrashDir, firstFile.getName() + ".up");
         File nonExpectedFirstRetryFile = new File(mCrashDir, firstFile.getName() + ".try1");
 
-        minidumpUploader.uploadAllMinidumps(new MinidumpUploader.UploadsFinishedCallback() {
-            @Override
-            public void uploadsFinished(boolean reschedule) {
-                fail("This method shouldn't be called when we interrupt uploads.");
-            }
-        });
+        // This is run on the UI thread to avoid failing any assertOnUiThread assertions.
+        uploadAllMinidumpsOnUiThread(
+                minidumpUploader, new MinidumpUploader.UploadsFinishedCallback() {
+                    @Override
+                    public void uploadsFinished(boolean reschedule) {
+                        fail("This method shouldn't be called when we interrupt uploads.");
+                    }
+                });
         minidumpUploader.cancelUploads();
 
         assertTrue(firstFile.exists());
@@ -326,6 +389,91 @@ public class MinidumpUploaderTest extends CrashTestCase {
         assertEquals(0, webviewTmpDir.listFiles().length);
     }
 
+    /**
+     * Ensure that when PlatformServiceBridge returns true we do upload minidumps.
+     */
+    @MediumTest
+    public void testPlatformServicesBridgeIsUsedUserConsent() throws IOException {
+        testPlatformServicesBridgeIsUsed(true);
+    }
+
+    /**
+     * Ensure that when PlatformServiceBridge returns false we do not upload minidumps.
+     */
+    @MediumTest
+    public void testPlatformServicesBridgeIsUsedNoUserConsent() throws IOException {
+        testPlatformServicesBridgeIsUsed(false);
+    }
+
+    /**
+     * MinidumpUploaderImpl sub-class that uses MinidumpUploaderImpl's implementation of
+     * CrashReportingPermissionManager.isUsageAndCrashReportingPermittedByUser().
+     */
+    private static class WebViewUserConsentMinidumpUploaderImpl extends MinidumpUploaderImpl {
+        boolean mUserConsent;
+        WebViewUserConsentMinidumpUploaderImpl(
+                Context context, boolean cleanOutMinidumps, boolean userConsent) {
+            super(context, cleanOutMinidumps);
+            mUserConsent = userConsent;
+        }
+        @Override
+        public PlatformServiceBridge createPlatformServiceBridge() {
+            return new TestPlatformServiceBridge(true /* canUseGms */, mUserConsent);
+        }
+        @Override
+        public MinidumpUploadCallable createMinidumpUploadCallable(
+                File minidumpFile, File logfile) {
+            return new MinidumpUploadCallable(minidumpFile, logfile,
+                    new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(),
+                    createWebViewCrashReportingManager());
+        }
+        @Override
+        protected CrashReportingPermissionManager createWebViewCrashReportingManager() {
+            final CrashReportingPermissionManager realPermissionManager =
+                    super.createWebViewCrashReportingManager();
+            return new MockCrashReportingPermissionManager() {
+                {
+                    // This setup ensures we depend on
+                    // isUsageAndCrashReportingPermittedByUser().
+                    mIsInSample = true;
+                    mIsPermitted = true;
+                    mIsCommandLineDisabled = false;
+                    mIsNetworkAvailable = true;
+                    mIsEnabledForTests = false;
+                }
+                @Override
+                public boolean isUsageAndCrashReportingPermittedByUser() {
+                    // Ensure that we use the real implementation of
+                    // isUsageAndCrashReportingPermittedByUser.
+                    boolean userPermitted =
+                            realPermissionManager.isUsageAndCrashReportingPermittedByUser();
+                    assertEquals(mUserConsent, userPermitted);
+                    return userPermitted;
+                }
+            };
+        }
+    }
+
+    private void testPlatformServicesBridgeIsUsed(final boolean userConsent) throws IOException {
+        MinidumpUploader minidumpUploader =
+                new WebViewUserConsentMinidumpUploaderImpl(getInstrumentation().getTargetContext(),
+                        false /* cleanOutMinidumps */, userConsent);
+
+        File firstFile = createMinidumpFileInCrashDir("1_abc.dmp0");
+        File secondFile = createMinidumpFileInCrashDir("12_abcd.dmp0");
+        File expectedFirstFile = new File(
+                mCrashDir, firstFile.getName().replace(".dmp", userConsent ? ".up" : ".skipped"));
+        File expectedSecondFile = new File(
+                mCrashDir, secondFile.getName().replace(".dmp", userConsent ? ".up" : ".skipped"));
+
+        uploadMinidumpsSync(minidumpUploader, false /* expectReschedule */);
+
+        assertFalse(firstFile.exists());
+        assertTrue(expectedFirstFile.exists());
+        assertFalse(secondFile.exists());
+        assertTrue(expectedSecondFile.exists());
+    }
+
     private static String readEntireFile(File file) throws IOException {
         FileInputStream fileInputStream = new FileInputStream(file);
         try {
@@ -450,15 +598,9 @@ public class MinidumpUploaderTest extends CrashTestCase {
                 new MockCrashReportingPermissionManager() {
                     { mIsEnabledForTests = true; }
                 };
-        MinidumpUploader minidumpUploader = new MinidumpUploaderImpl(
-                getInstrumentation().getTargetContext(), false /* cleanOutMinidumps */) {
-            @Override
-            public MinidumpUploadCallable createMinidumpUploadCallable(
-                    File minidumpFile, File logfile) {
-                return new MinidumpUploadCallable(minidumpFile, logfile,
-                        new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(), permManager);
-            }
-        };
+        MinidumpUploader minidumpUploader =
+                new TestMinidumpUploaderImpl(getInstrumentation().getTargetContext(), permManager,
+                        false /* cleanOutMinidumps */);
 
         uploadMinidumpsSync(minidumpUploader, false /* expectReschedule */);
         // Ensure there are no minidumps left to upload.