[Android Crash Reporting] Allow uploading minidumps via the JobScheduler

chrome/android/javatests/src/org/chromium/chrome/browser/crash/MinidumpUploadServiceTest.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 static org.chromium.chrome.browser.crash.MinidumpUploadService.BROWSER;
 import static org.chromium.chrome.browser.crash.MinidumpUploadService.GPU;
 import static org.chromium.chrome.browser.crash.MinidumpUploadService.OTHER;
 import static org.chromium.chrome.browser.crash.MinidumpUploadService.RENDERER;
 
+import android.annotation.TargetApi;
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
+import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.support.test.filters.SmallTest;
 
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.test.util.AdvancedMockContext;
 import org.chromium.base.test.util.Feature;
+import org.chromium.chrome.browser.ChromeFeatureList;
+import org.chromium.components.background_task_scheduler.TaskIds;
 import org.chromium.components.minidump_uploader.CrashTestCase;
 import org.chromium.components.minidump_uploader.MinidumpUploadCallable;
 import org.chromium.components.minidump_uploader.util.CrashReportingPermissionManager;
 import org.chromium.content.browser.test.util.Criteria;
 import org.chromium.content.browser.test.util.CriteriaHelper;
 import org.chromium.net.NetworkChangeNotifier;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 /**
  * Testcase for {@link MinidumpUploadService}.
  */
 public class MinidumpUploadServiceTest extends CrashTestCase {
     private static final int CHECK_INTERVAL_MS = 250;
     private static final int MAX_TIMEOUT_MS = 20000;
     private static final String BOUNDARY = "TESTBOUNDARY";
 
     private static class TestMinidumpUploadService extends MinidumpUploadService {
@@ skipping 21 matching lines @@
 
         CrashReportingPermissionManager getCrashReportingPermissionManager() {
             return mPermissionManager;
         }
 
         public void setIsNetworkAvailableForCrashUploads(boolean networkAvailable) {
             mPermissionManager.setIsNetworkAvailableForCrashUploads(networkAvailable);
         }
     }
 
+    @Override
+    protected void tearDown() throws Exception {
+        ChromeFeatureList.setTestFeatures(null);
+        super.tearDown();
+    }
+
+    /**
+     * Sets whether to upload minidumps using the JobScheduler API. Minidumps can either be uploaded
+     * via a JobScheduler, or via a direct Intent service.
+     * @param enable Whether to enable the JobScheduler API.
+     */
+    private void setJobSchedulerEnabled(boolean enable) {
+        Map<String, Boolean> features = new HashMap<>();
+        features.put(ChromeFeatureList.UPLOAD_CRASH_REPORTS_USING_JOB_SCHEDULER, enable);
+        ChromeFeatureList.setTestFeatures(features);
+    }
+
     @SmallTest
     @Feature({"Android-AppBase"})
     public void testTryUploadAllCrashDumps() throws IOException {
         // Setup prerequisites.
+        setJobSchedulerEnabled(false);
         final AtomicInteger numServiceStarts = new AtomicInteger(0);
         final File[] minidumpFiles = {
                 new File(mCrashDir, "chromium_renderer-111.dmp1"),
                 new File(mCrashDir, "chromium_renderer-222.dmp2"),
                 new File(mCrashDir, "chromium_renderer-333.dmp3"),
         };
         MinidumpPreparationContext context = new MinidumpPreparationContext(
                 getInstrumentation().getTargetContext()) {
             @Override
             public ComponentName startService(Intent intentToCheck) {
                 String filePath =
                         intentToCheck.getStringExtra(MinidumpUploadService.FILE_TO_UPLOAD_KEY);
                 // Assuming numServicesStart value corresponds to minidumpFiles index.
-                assertEquals("Minidump path should be the absolute path",
-                        minidumpFiles[numServiceStarts.intValue()].getAbsolutePath(), filePath);
+                assertEquals("Action should be correct", MinidumpUploadService.ACTION_UPLOAD,
+                        intentToCheck.getAction());
                 assertTrue("Should not call service more than number of files",
                         numServiceStarts.incrementAndGet() <= minidumpFiles.length);
-                assertEquals("Action should be correct", MinidumpUploadService.ACTION_UPLOAD,
-                        intentToCheck.getAction());
+                assertEquals("Minidump path should be the absolute path",
+                        minidumpFiles[numServiceStarts.intValue() - 1].getAbsolutePath(), filePath);
                 return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
             }
 
         };
         MinidumpUploadService service = new TestMinidumpUploadService(context);
         for (File minidumpFile : minidumpFiles) {
             setUpMinidumpFile(minidumpFile, BOUNDARY);
         }
 
         // Run test.
@@ skipping 54 matching lines @@
         runUploadCrashTest(callables);
     }
 
     @SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
     private void runUploadCrashTest(final List<CountedMinidumpUploadCallable> callables)
             throws IOException, InterruptedException {
         // Setup prerequisites.
         // This version of the service overrides the createMinidumpUploadCallable(...) to be able
         // to return fake ones. It also ensures that the service never tries to create a callable
         // too many times.
+        setJobSchedulerEnabled(false);
         TestMinidumpUploadService service = new TestMinidumpUploadService() {
             int mIndex = 0;
             boolean mTriggerNetworkChange = false;
 
             @Override
             MinidumpUploadCallable createMinidumpUploadCallable(File minidumpFile, File logfile) {
                 if (mIndex >= callables.size()) {
                     fail("Should not create callable number " + mIndex);
                 }
                 CountedMinidumpUploadCallable callable = callables.get(mIndex++);
@@ skipping 94 matching lines @@
                             }
                         }
                         return true;
                     }
                 },
                 MAX_TIMEOUT_MS, CHECK_INTERVAL_MS);
     }
 
     @SmallTest
     @Feature({"Android-AppBase"})
-    public void testHandleForceUploadCrash_MinidumpFileExists() throws IOException {
+    public void testHandleForceUploadCrash_MinidumpFileExists_SansJobScheduler()
+            throws IOException {
         // Set up prerequisites.
+        setJobSchedulerEnabled(false);
         File minidumpFile =
                 new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.dmp0.try3");
         final File expectedRenamedMinidumpFile =
                 new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.forced0.try0");
         setUpMinidumpFile(minidumpFile, BOUNDARY);
         final String startServiceFlag = "startServiceFlag";
         MinidumpPreparationContext context = new MinidumpPreparationContext(
                 getInstrumentation().getTargetContext()) {
             @Override
             public ComponentName startService(Intent intentToCheck) {
                 assertEquals(MinidumpUploadService.ACTION_UPLOAD, intentToCheck.getAction());
                 String filePath =
                         intentToCheck.getStringExtra(MinidumpUploadService.FILE_TO_UPLOAD_KEY);
                 assertEquals("Minidump path should be for a fresh upload",
                         expectedRenamedMinidumpFile.getAbsolutePath(), filePath);
                 setFlag(startServiceFlag);
                 return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
             }
         };
 
         // Run test.
         MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
 
         // Verify.
         assertTrue("Should have called startService(...)", context.isFlagSet(startServiceFlag));
     }
 
     @SmallTest
     @Feature({"Android-AppBase"})
-    public void testHandleForceUploadCrash_SkippedMinidumpFileExists() throws IOException {
+    public void testHandleForceUploadCrash_MinidumpFileExists_WithJobScheduler()
+            throws IOException {
+        // The JobScheduler API is only available as of Android L.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
+        setJobSchedulerEnabled(true);
+
         // Set up prerequisites.
+        setUpMinidumpFile(
+                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.dmp0.try3"),
+                BOUNDARY);
+        AdvancedMockContext context =
+                new MinidumpPreparationContext(getInstrumentation().getTargetContext());
+
+        // Run test.
+        MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
+
+        // Verify.
+        final File expectedRenamedMinidumpFile =
+                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.forced0.try0");
+        assertTrue("Should have renamed the minidump file for forced upload",
+                expectedRenamedMinidumpFile.exists());
+        assertTrue("Should have tried to schedule an upload job",
+                context.isFlagSet(TestJobScheduler.SCHEDULE_JOB_FLAG));
+    }
+
+    @SmallTest
+    @Feature({"Android-AppBase"})
+    public void testHandleForceUploadCrash_SkippedMinidumpFileExists_SansJobScheduler()
+            throws IOException {
+        // Set up prerequisites.
+        setJobSchedulerEnabled(false);
         File minidumpFile =
                 new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.skipped0.try0");
         final File expectedRenamedMinidumpFile =
                 new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.forced0.try0");
         setUpMinidumpFile(minidumpFile, BOUNDARY);
         final String startServiceFlag = "startServiceFlag";
         MinidumpPreparationContext context = new MinidumpPreparationContext(
                 getInstrumentation().getTargetContext()) {
             @Override
             public ComponentName startService(Intent intentToCheck) {
                 assertEquals(MinidumpUploadService.ACTION_UPLOAD, intentToCheck.getAction());
                 String filePath =
                         intentToCheck.getStringExtra(MinidumpUploadService.FILE_TO_UPLOAD_KEY);
                 assertEquals("Minidump path should be for a fresh upload",
                         expectedRenamedMinidumpFile.getAbsolutePath(), filePath);
                 setFlag(startServiceFlag);
                 return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
             }
         };
 
         // Run test.
         MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
 
         // Verify.
         assertTrue("Should have called startService(...)", context.isFlagSet(startServiceFlag));
     }
 
     @SmallTest
     @Feature({"Android-AppBase"})
-    public void testHandleForceUploadCrash_FileDoesntExist() {
+    public void testHandleForceUploadCrash_SkippedMinidumpFileExists_WithJobScheduler()
+            throws IOException {
+        // The JobScheduler API is only available as of Android L.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
+        setJobSchedulerEnabled(true);
+
         // Set up prerequisites.
+        setUpMinidumpFile(
+                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.skipped0.try3"),
+                BOUNDARY);
+        AdvancedMockContext context =
+                new MinidumpPreparationContext(getInstrumentation().getTargetContext());
+
+        // Run test.
+        MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
+
+        // Verify.
+        final File expectedRenamedMinidumpFile =
+                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.forced0.try0");
+        assertTrue("Should have renamed the minidump file for forced upload",
+                expectedRenamedMinidumpFile.exists());
+        assertTrue("Should have tried to schedule an upload job",
+                context.isFlagSet(TestJobScheduler.SCHEDULE_JOB_FLAG));
+    }
+
+    @SmallTest
+    @Feature({"Android-AppBase"})
+    public void testHandleForceUploadCrash_FileDoesntExist_SansJobScheduler() {
+        // Set up prerequisites.
+        setJobSchedulerEnabled(false);
         final String startServiceFlag = "startServiceFlag";
         MinidumpPreparationContext context = new MinidumpPreparationContext(
                 getInstrumentation().getTargetContext()) {
             @Override
             public ComponentName startService(Intent unused) {
                 setFlag(startServiceFlag);
                 return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
             }
         };
 
         // Run test.
         MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
 
         // Verify.
         assertFalse(
                 "Should not have called startService(...)", context.isFlagSet(startServiceFlag));
     }
 
     @SmallTest
     @Feature({"Android-AppBase"})
-    public void testHandleForceUploadCrash_FileAlreadyUploaded() throws IOException {
+    public void testHandleForceUploadCrash_FileDoesntExist_WithJobScheduler() throws IOException {
+        // The JobScheduler API is only available as of Android L.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
+        setJobSchedulerEnabled(true);
+
         // Set up prerequisites.
-        File minidumpFile =
-                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.up0.try0");
-        setUpMinidumpFile(minidumpFile, BOUNDARY);
+        AdvancedMockContext context =
+                new MinidumpPreparationContext(getInstrumentation().getTargetContext());
+
+        // Run test.
+        MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
+
+        // Verify.
+        assertFalse("Should not have tried to schedule an upload job",
+                context.isFlagSet(TestJobScheduler.SCHEDULE_JOB_FLAG));
+    }
+
+    @SmallTest
+    @Feature({"Android-AppBase"})
+    public void testHandleForceUploadCrash_FileAlreadyUploaded_SansJobScheduler()
+            throws IOException {
+        // Set up prerequisites.
+        setJobSchedulerEnabled(false);
+        setUpMinidumpFile(
+                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.up0.try0"),
+                BOUNDARY);
         final String startServiceFlag = "startServiceFlag";
         MinidumpPreparationContext context = new MinidumpPreparationContext(
                 getInstrumentation().getTargetContext()) {
             @Override
             public ComponentName startService(Intent unused) {
                 setFlag(startServiceFlag);
                 return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
             }
         };
 
         // Run test.
         MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
 
         // Verify.
         assertFalse(
                 "Should not have called startService(...)", context.isFlagSet(startServiceFlag));
     }
 
     @SmallTest
     @Feature({"Android-AppBase"})
+    public void testHandleForceUploadCrash_FileAlreadyUploaded_WithJobScheduler()
+            throws IOException {
+        // The JobScheduler API is only available as of Android L.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
+        setJobSchedulerEnabled(true);
+
+        // Set up prerequisites.
+        setUpMinidumpFile(
+                new File(mCrashDir, "chromium-renderer-minidump-f297dbcba7a2d0bb.up0.try0"),
+                BOUNDARY);
+        AdvancedMockContext context =
+                new MinidumpPreparationContext(getInstrumentation().getTargetContext());
+
+        // Run test.
+        MinidumpUploadService.tryUploadCrashDumpWithLocalId(context, "f297dbcba7a2d0bb");
+
+        // Verify.
+        assertFalse("Should not have tried to schedule an upload job",
+                context.isFlagSet(TestJobScheduler.SCHEDULE_JOB_FLAG));
+    }
+
+    @SmallTest
+    @Feature({"Android-AppBase"})
     public void testGetCrashType1() throws IOException {
         final File minidumpFile = new File(mCrashDir, "chromium_renderer-123.dmp");
         setUpMinidumpFile(minidumpFile, BOUNDARY, "browser");
         assertEquals(BROWSER, MinidumpUploadService.getCrashType(minidumpFile.getAbsolutePath()));
     }
 
     @SmallTest
     @Feature({"Android-AppBase"})
     public void testGetCrashType2() throws IOException {
         final File minidumpFile = new File(mCrashDir, "chromium_renderer-123.dmp");
@@ skipping 29 matching lines @@
 
         public MinidumpPreparationContext(Context targetContext, MinidumpUploadService service) {
             super(targetContext);
             mService = service;
         }
 
         @Override
         public File getCacheDir() {
             return mCacheDir;
         }
+
+        @Override
+        public Object getSystemService(String name) {
+            if (Context.JOB_SCHEDULER_SERVICE.equals(name)) {
+                assertTrue("Should only access the JobScheduler when it is enabled.",
+                        ChromeFeatureList.isEnabled(
+                                ChromeFeatureList.UPLOAD_CRASH_REPORTS_USING_JOB_SCHEDULER));
+                return new TestJobScheduler((JobScheduler) super.getSystemService(name), this);
+            }
+
+            return super.getSystemService(name);
+        }
     }
 
     /**
+     * A JobScheduler wrapper that verifies that the expected properties are set correctly.
+     */
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    private static class TestJobScheduler extends JobScheduler {
+        static final String SCHEDULE_JOB_FLAG = "scheduleJobFlag";
+
+        private final JobScheduler mRealScheduler;

[gsennton, 2017/03/15 12:57:43]

Here as well, I don't quite see why we are using a real jobscheduler - we don't
actually want to schedule any jobs during tests, right?

[Ilya Sherman, 2017/03/16 01:36:57]

Done.

+        private final AdvancedMockContext mContext;
+
+        TestJobScheduler(JobScheduler realScheduler, AdvancedMockContext context) {
+            mRealScheduler = realScheduler;
+            mContext = context;
+        }
+
+        @Override
+        public void cancel(int jobId) {
+            mRealScheduler.cancel(jobId);
+        }
+
+        @Override
+        public void cancelAll() {
+            mRealScheduler.cancelAll();
+        }
+
+        @Override
+        public List<JobInfo> getAllPendingJobs() {
+            return mRealScheduler.getAllPendingJobs();
+        }
+
+        @Override
+        public JobInfo getPendingJob(int jobId) {
+            return mRealScheduler.getPendingJob(jobId);
+        }
+
+        @Override
+        public int schedule(JobInfo job) {
+            mContext.setFlag(SCHEDULE_JOB_FLAG);
+            assertEquals(TaskIds.CHROME_MINIDUMP_UPLOADING_JOB_ID, job.getId());
+            assertEquals(ChromeMinidumpUploadJobService.class.getName(),
+                    job.getService().getClassName());
+            return mRealScheduler.schedule(job);
+        }
+    };
+
+    /**
      * A fake callable, that just counts the number of times it is called.
      *
      * It can be constructed with the wanted return-value of the call()-method.
      */
     private static class CountedMinidumpUploadCallable extends MinidumpUploadCallable {
         private int mCalledCount;
         @MinidumpUploadCallable.MinidumpUploadStatus private final int mResult;
         private final boolean mTriggerNetworkChange;
 
         /**
          * Creates a fake callable, that just counts the number of times it is called.
          *
          * @param result the value to return from the call()-method.
          * @param networkChange Should trigger a network change after this callable is finished.
          *     This essentially triggers a retry if result is set to fail.
          */
         private CountedMinidumpUploadCallable(String fileName, int result, boolean networkChange) {
             super(new File(fileName), null, null, null);
             this.mResult = result;
             this.mTriggerNetworkChange = networkChange;
         }
 
         @Override
         public Integer call() {
             ++mCalledCount;
             return mResult;
         }
     }
 }