Android: Remove GetApplicationContext part 2

chrome/android/java/src/org/chromium/chrome/browser/crash/MinidumpUploadService.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 android.annotation.SuppressLint;
 import android.app.IntentService;
 import android.app.job.JobInfo;
 import android.content.ComponentName;
-import android.content.Context;
 import android.content.Intent;
 import android.os.Build;
 import android.os.PersistableBundle;
 import android.support.annotation.StringDef;
 
+import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.StreamUtil;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.browser.preferences.ChromePreferenceManager;
 import org.chromium.chrome.browser.preferences.privacy.PrivacyPreferencesManager;
 import org.chromium.components.background_task_scheduler.TaskIds;
 import org.chromium.components.minidump_uploader.CrashFileManager;
 import org.chromium.components.minidump_uploader.MinidumpUploadCallable;
@@ skipping 53 matching lines @@
      */
     public static boolean shouldUseJobSchedulerForUploads() {
         // The JobScheduler API is only usable as of Android M.
         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
     }
 
     /**
      * Schedules uploading of all pending minidumps, using the JobScheduler API.
      */
     @SuppressLint("NewApi")
-    public static void scheduleUploadJob(Context context) {
+    public static void scheduleUploadJob() {
         assert shouldUseJobSchedulerForUploads();
 
         CrashReportingPermissionManager permissionManager = PrivacyPreferencesManager.getInstance();
         PersistableBundle permissions = new PersistableBundle();
         permissions.putBoolean(ChromeMinidumpUploaderDelegate.IS_CLIENT_IN_METRICS_SAMPLE,
                 permissionManager.isClientInMetricsSample());
         permissions.putBoolean(ChromeMinidumpUploaderDelegate.IS_UPLOAD_ENABLED_FOR_TESTS,
                 permissionManager.isUploadEnabledForTests());
 
         JobInfo.Builder builder =
                 new JobInfo
                         .Builder(TaskIds.CHROME_MINIDUMP_UPLOADING_JOB_ID,
-                                new ComponentName(context, ChromeMinidumpUploadJobService.class))
+                                new ComponentName(ContextUtils.getApplicationContext(),
+                                        ChromeMinidumpUploadJobService.class))
                         .setExtras(permissions);
-        MinidumpUploadJobService.scheduleUpload(context, builder);
+        MinidumpUploadJobService.scheduleUpload(builder);
     }
 
     /**
      * Stores the successes and failures from uploading crash to UMA,
      */
     public static void storeBreakpadUploadStatsInUma(ChromePreferenceManager pref) {
         for (String type : TYPES) {
             for (int success = pref.getCrashSuccessUploadCount(type); success > 0; success--) {
                 RecordHistogram.recordEnumeratedHistogram(
                         HISTOGRAM_NAME_PREFIX + type, SUCCESS, HISTOGRAM_MAX);
@@ skipping 168 matching lines @@
         return new MinidumpUploadCallable(
                 minidumpFile, logfile, getCrashReportingPermissionManager());
     }
 
     /**
      * Attempts to upload the specified {@param minidumpFile}.
      *
      * Note that this method is asynchronous. All that is guaranteed is that an upload attempt will
      * be enqueued.
      *
-     * @param context The application context, in which to initiate the crash report upload.
-     * @throws A security excpetion if the caller doesn't have permission to start the upload
+     * @throws SecurityException if the caller doesn't have permission to start the upload
      *         service. This can only happen on KitKat and below, due to a framework bug.
      */
-    public static void tryUploadCrashDump(Context context, File minidumpFile)
-            throws SecurityException {
+    public static void tryUploadCrashDump(File minidumpFile) throws SecurityException {
         assert !shouldUseJobSchedulerForUploads();
-        CrashFileManager fileManager = new CrashFileManager(context.getCacheDir());
-        Intent intent = new Intent(context, MinidumpUploadService.class);
+        CrashFileManager fileManager =
+                new CrashFileManager(ContextUtils.getApplicationContext().getCacheDir());
+        Intent intent =
+                new Intent(ContextUtils.getApplicationContext(), MinidumpUploadService.class);
         intent.setAction(ACTION_UPLOAD);
         intent.putExtra(FILE_TO_UPLOAD_KEY, minidumpFile.getAbsolutePath());
         intent.putExtra(UPLOAD_LOG_KEY, fileManager.getCrashUploadLogFile().getAbsolutePath());
-        context.startService(intent);
+        ContextUtils.getApplicationContext().startService(intent);
     }
 
     /**
      * Attempts to upload all minidump files using the given {@link android.content.Context}.
      *
      * Note that this method is asynchronous. All that is guaranteed is that
      * upload attempts will be enqueued.
      *
      * This method is safe to call from the UI thread.
      *
-     * @param context Context of the application.
      */
-    public static void tryUploadAllCrashDumps(Context context) {
+    public static void tryUploadAllCrashDumps() {
         assert !shouldUseJobSchedulerForUploads();
-        CrashFileManager fileManager = new CrashFileManager(context.getCacheDir());
+        CrashFileManager fileManager =
+                new CrashFileManager(ContextUtils.getApplicationContext().getCacheDir());
         File[] minidumps = fileManager.getAllMinidumpFiles(MAX_TRIES_ALLOWED);
         Log.i(TAG, "Attempting to upload accumulated crash dumps.");
         for (File minidump : minidumps) {
-            tryUploadCrashDump(context, minidump);
+            tryUploadCrashDump(minidump);
         }
     }
 
     /**
      * Attempts to upload the crash report with the given local ID.
      *
      * Note that this method is asynchronous. All that is guaranteed is that
      * upload attempts will be enqueued.
      *
      * This method is safe to call from the UI thread.
      *
-     * @param context the context to use for the intent.
      * @param localId The local ID of the crash report.
      */
     @CalledByNative
-    public static void tryUploadCrashDumpWithLocalId(Context context, String localId) {
+    public static void tryUploadCrashDumpWithLocalId(String localId) {
         if (localId == null || localId.isEmpty()) {
             Log.w(TAG, "Cannot force crash upload since local crash id is absent.");
             return;
         }
 
-        CrashFileManager fileManager = new CrashFileManager(context.getCacheDir());
+        CrashFileManager fileManager =
+                new CrashFileManager(ContextUtils.getApplicationContext().getCacheDir());
         File minidumpFile = fileManager.getCrashFileWithLocalId(localId);
         if (minidumpFile == null) {
             Log.w(TAG, "Could not find a crash dump with local ID " + localId);
             return;
         }
         File renamedMinidumpFile = CrashFileManager.trySetForcedUpload(minidumpFile);
         if (renamedMinidumpFile == null) {
             Log.w(TAG, "Could not rename the file " + minidumpFile.getName() + " for re-upload");
             return;
         }
 
         if (shouldUseJobSchedulerForUploads()) {
-            scheduleUploadJob(context);
+            scheduleUploadJob();
         } else {
-            tryUploadCrashDump(context, renamedMinidumpFile);
+            tryUploadCrashDump(renamedMinidumpFile);
         }
     }
 }