Revert of Android: Remove GetApplicationContext part 2

android_webview/javatests/src/org/chromium/android_webview/test/crash/MinidumpUploaderTest.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.test.crash;
 
 import static org.chromium.base.test.util.ScalableTimeout.scaleTimeout;
 
+import android.content.Context;
 import android.os.ParcelFileDescriptor;
 import android.support.test.filters.MediumTest;
 import android.webkit.ValueCallback;
 
 import org.chromium.android_webview.PlatformServiceBridge;
 import org.chromium.android_webview.crash.AwMinidumpUploaderDelegate;
 import org.chromium.android_webview.crash.CrashReceiverService;
 import org.chromium.base.FileUtils;
 import org.chromium.base.ThreadUtils;
 import org.chromium.components.minidump_uploader.CrashFileManager;
@@ skipping 24 matching lines @@
  * Instrumentation tests for MinidumpUploader.
  */
 public class MinidumpUploaderTest extends CrashTestCase {
     private static final String TAG = "MinidumpUploaderTest";
     private static final String BOUNDARY = "TESTBOUNDARY";
 
     private static final long TIME_OUT_MILLIS = 3000;
 
     @Override
     protected File getExistingCacheDir() {
-        return CrashReceiverService.getOrCreateWebViewCrashDir();
+        return CrashReceiverService.createWebViewCrashDir(getInstrumentation().getTargetContext());
     }
 
     private static class TestPlatformServiceBridge extends PlatformServiceBridge {
         private final boolean mEnabled;
 
         public TestPlatformServiceBridge(boolean enabled) {
             mEnabled = enabled;
         }
 
         @Override
         public boolean canUseGms() {
             return true;
         }
 
         @Override
         public void queryMetricsSetting(ValueCallback<Boolean> callback) {
             ThreadUtils.assertOnUiThread();
             callback.onReceiveValue(mEnabled);
         }
     }
 
     private class TestMinidumpUploaderImpl extends MinidumpUploaderImpl {
         private final CrashReportingPermissionManager mPermissionManager;
 
         TestMinidumpUploaderImpl(CrashReportingPermissionManager permissionManager) {
-            super(new AwMinidumpUploaderDelegate());
+            super(new AwMinidumpUploaderDelegate(getInstrumentation().getTargetContext()));
             mPermissionManager = permissionManager;
         }
 
         TestMinidumpUploaderImpl(MinidumpUploaderDelegate delegate,
                 CrashReportingPermissionManager permissionManager) {
             super(delegate);
             mPermissionManager = permissionManager;
         }
 
         @Override
@@ skipping 100 matching lines @@
             assertTrue(uploadsFinishedLatch.await(
                     scaleTimeout(TIME_OUT_MILLIS), TimeUnit.MILLISECONDS));
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * Ensure MinidumpUploaderImpl doesn't crash even if the WebView Crash dir doesn't exist (could
      * happen e.g. if a Job persists across WebView-updates?
-     *
-     * MinidumpUploaderImpl should automatically recreate the directory.
      */
     @MediumTest
     public void testUploadingWithoutCrashDir() throws IOException {
         File webviewCrashDir = getExistingCacheDir();
         // Delete the WebView crash directory to ensure MinidumpUploader doesn't crash without it.
         FileUtils.recursivelyDeleteFile(webviewCrashDir);
         assertFalse(webviewCrashDir.exists());
 
         PlatformServiceBridge.injectInstance(new TestPlatformServiceBridge(true));
         final CrashReportingPermissionManager permManager =
@@ skipping 14 matching lines @@
         assertFalse(firstFile.exists());
         assertTrue(expectedFirstUploadFile.exists());
         assertFalse(secondFile.exists());
         assertTrue(expectedSecondUploadFile.exists());
     }
 
     private interface MinidumpUploadCallableCreator {
         MinidumpUploadCallable createCallable(File minidumpFile, File logfile);
     }
 
-    private MinidumpUploaderImpl createCallableListMinidumpUploader(
+    private MinidumpUploaderImpl createCallableListMinidumpUploader(Context context,
             final List<MinidumpUploadCallableCreator> callables, final boolean userPermitted) {
         PlatformServiceBridge.injectInstance(new TestPlatformServiceBridge(userPermitted));
         return new TestMinidumpUploaderImpl(null) {
             private int mIndex = 0;
 
             @Override
             public MinidumpUploadCallable createMinidumpUploadCallable(
                     File minidumpFile, File logfile) {
                 if (mIndex >= callables.size()) {
                     fail("Should not create callable number " + mIndex);
                 }
                 return callables.get(mIndex++).createCallable(minidumpFile, logfile);
             }
         };
     }
 
     @MediumTest
     public void testFailingThenPassingUpload() throws IOException {
         final CrashReportingPermissionManager permManager =
                 new MockCrashReportingPermissionManager() {
                     { mIsEnabledForTests = true; }
                 };
-        List<MinidumpUploadCallableCreator> callables = new ArrayList<>();
+        List<MinidumpUploadCallableCreator> callables = new ArrayList();
         callables.add(new MinidumpUploadCallableCreator() {
             @Override
             public MinidumpUploadCallable createCallable(File minidumpFile, File logfile) {
                 return new MinidumpUploadCallable(
                         minidumpFile, logfile, new FailingHttpUrlConnectionFactory(), permManager);
             }
         });
         callables.add(new MinidumpUploadCallableCreator() {
             @Override
             public MinidumpUploadCallable createCallable(File minidumpFile, File logfile) {
                 return new MinidumpUploadCallable(minidumpFile, logfile,
                         new MinidumpUploadCallableTest.TestHttpURLConnectionFactory(), permManager);
             }
         });
-        MinidumpUploader minidumpUploader = createCallableListMinidumpUploader(
-                callables, permManager.isUsageAndCrashReportingPermittedByUser());
+        MinidumpUploader minidumpUploader =
+                createCallableListMinidumpUploader(getInstrumentation().getTargetContext(),
+                        callables, permManager.isUsageAndCrashReportingPermittedByUser());
 
         File firstFile = createMinidumpFileInCrashDir("firstFile.dmp0");
         File secondFile = createMinidumpFileInCrashDir("secondFile.dmp0");
 
         uploadMinidumpsSync(minidumpUploader, true /* expectReschedule */);
         assertFalse(firstFile.exists());
         assertFalse(secondFile.exists());
-        File expectedSecondFile;
+        File expectedSecondFile = null;
         // Not sure which minidump will fail and which will succeed, so just ensure one was uploaded
         // and the other one failed.
         if (new File(mCrashDir, firstFile.getName() + ".try1").exists()) {
             expectedSecondFile = new File(mCrashDir, secondFile.getName().replace(".dmp", ".up"));
         } else {
             File uploadedFirstFile =
                     new File(mCrashDir, firstFile.getName().replace(".dmp", ".up"));
             assertTrue(uploadedFirstFile.exists());
             expectedSecondFile = new File(mCrashDir, secondFile.getName() + ".try1");
         }
@@ skipping 115 matching lines @@
             assertTrue(firstFile.exists());
             assertFalse(expectedFirstUploadFile.exists());
             assertFalse(expectedFirstRetryFile.exists());
         }
     }
 
     /**
      * Ensures that the minidump copying works together with the minidump uploading.
      */
     @MediumTest
-    public void testCopyAndUploadWebViewMinidump() throws IOException {
-        final CrashFileManager fileManager =
-                new CrashFileManager(CrashReceiverService.getWebViewCrashDir());
+    public void testCopyAndUploadWebViewMinidump() throws FileNotFoundException, IOException {
+        final CrashFileManager fileManager = new CrashFileManager(
+                CrashReceiverService.getWebViewCrashDir(getInstrumentation().getTargetContext()));
         // Note that these minidump files are set up directly in the cache dir - not in the WebView
         // crash dir. This is to ensure the CrashFileManager doesn't see these minidumps without us
         // first copying them.
-        File minidumpToCopy = new File(getExistingCacheDir(), "toCopy.dmp");
+        File minidumpToCopy =
+                new File(getInstrumentation().getTargetContext().getCacheDir(), "toCopy.dmp");
         setUpMinidumpFile(minidumpToCopy, BOUNDARY, "browser");
         final String expectedFileContent = readEntireFile(minidumpToCopy);
 
         File[] uploadedFiles = copyAndUploadMinidumpsSync(
                 fileManager, new File[][] {{minidumpToCopy}}, new int[] {0});
 
         // CrashReceiverService will rename the minidumps to some globally unique file name
         // meaning that we have to check the contents of the minidump rather than the file
         // name.
         try {
             assertEquals(expectedFileContent, readEntireFile(uploadedFiles[0]));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
-        File webviewTmpDir = CrashReceiverService.getWebViewTmpCrashDir();
+        File webviewTmpDir =
+                CrashReceiverService.getWebViewTmpCrashDir(getInstrumentation().getTargetContext());
         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);
     }
 
     /**
      * MinidumpUploaderDelegate sub-class that uses MinidumpUploaderDelegate's implementation of
      * CrashReportingPermissionManager.isUsageAndCrashReportingPermittedByUser().
      */
     private static class WebViewUserConsentMinidumpUploaderDelegate
             extends AwMinidumpUploaderDelegate {
         private final boolean mUserConsent;
-        WebViewUserConsentMinidumpUploaderDelegate(boolean userConsent) {
-            super();
+        WebViewUserConsentMinidumpUploaderDelegate(Context context, boolean userConsent) {
+            super(context);
             mUserConsent = userConsent;
         }
         @Override
         public CrashReportingPermissionManager createCrashReportingPermissionManager() {
             final CrashReportingPermissionManager realPermissionManager =
                     super.createCrashReportingPermissionManager();
             return new MockCrashReportingPermissionManager() {
                 {
                     // This setup ensures we depend on
                     // isUsageAndCrashReportingPermittedByUser().
                     mIsInSample = true;
                     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 {
         PlatformServiceBridge.injectInstance(new TestPlatformServiceBridge(userConsent));
-        MinidumpUploaderDelegate delegate =
-                new WebViewUserConsentMinidumpUploaderDelegate(userConsent);
+        MinidumpUploaderDelegate delegate = new WebViewUserConsentMinidumpUploaderDelegate(
+                getInstrumentation().getTargetContext(), userConsent);
         MinidumpUploader minidumpUploader = new TestMinidumpUploaderImpl(
                 delegate, delegate.createCrashReportingPermissionManager());
 
         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 {
-        try (FileInputStream fileInputStream = new FileInputStream(file)) {
+        FileInputStream fileInputStream = new FileInputStream(file);
+        try {
             byte[] data = new byte[(int) file.length()];
             fileInputStream.read(data);
             return new String(data);
+        } finally {
+            fileInputStream.close();
         }
     }
 
     /**
      * Ensure that the minidump copying doesn't trigger when we pass it invalid file descriptors.
      */
     @MediumTest
-    public void testCopyingAbortsForInvalidFds() throws IOException {
-        assertFalse(CrashReceiverService.copyMinidumps(0 /* uid */, null));
+    public void testCopyingAbortsForInvalidFds() throws FileNotFoundException, IOException {
         assertFalse(CrashReceiverService.copyMinidumps(
+                getInstrumentation().getTargetContext(), 0 /* uid */, null));
+        assertFalse(CrashReceiverService.copyMinidumps(getInstrumentation().getTargetContext(),
                 0 /* uid */, new ParcelFileDescriptor[] {null, null}));
-        assertFalse(CrashReceiverService.copyMinidumps(0 /* uid */, new ParcelFileDescriptor[0]));
+        assertFalse(CrashReceiverService.copyMinidumps(
+                getInstrumentation().getTargetContext(), 0 /* uid */, new ParcelFileDescriptor[0]));
     }
 
     /**
      * Ensure deleting temporary files used when copying minidumps works correctly.
      */
     @MediumTest
     public void testDeleteFilesInDir() throws IOException {
-        File webviewTmpDir = CrashReceiverService.getWebViewTmpCrashDir();
+        Context context = getInstrumentation().getTargetContext();
+        File webviewTmpDir = CrashReceiverService.getWebViewTmpCrashDir(context);
         if (!webviewTmpDir.isDirectory()) {
             assertTrue(webviewTmpDir.mkdir());
         }
         File testFile1 = new File(webviewTmpDir, "testFile1");
         File testFile2 = new File(webviewTmpDir, "testFile2");
         assertTrue(testFile1.createNewFile());
         assertTrue(testFile2.createNewFile());
         assertTrue(testFile1.exists());
         assertTrue(testFile2.exists());
-        CrashReceiverService.deleteFilesInWebViewTmpDirIfExists();
+        CrashReceiverService.deleteFilesInWebViewTmpDirIfExists(context);
         assertFalse(testFile1.exists());
         assertFalse(testFile2.exists());
     }
 
     /**
      * Ensure we can copy and upload several batches of files (i.e. emulate several copying-calls in
      * a row without the copying-service being destroyed in between).
      */
     @MediumTest
     public void testCopyAndUploadSeveralMinidumpBatches() throws IOException {
-        final CrashFileManager fileManager =
-                new CrashFileManager(CrashReceiverService.getWebViewCrashDir());
+        final CrashFileManager fileManager = new CrashFileManager(
+                CrashReceiverService.getWebViewCrashDir(getInstrumentation().getTargetContext()));
         // Note that these minidump files are set up directly in the cache dir - not in the WebView
         // crash dir. This is to ensure the CrashFileManager doesn't see these minidumps without us
         // first copying them.
-        File firstMinidumpToCopy = new File(getExistingCacheDir(), "firstToCopy.dmp");
-        File secondMinidumpToCopy = new File(getExistingCacheDir(), "secondToCopy.dmp");
+        File firstMinidumpToCopy =
+                new File(getInstrumentation().getTargetContext().getCacheDir(), "firstToCopy.dmp");
+        File secondMinidumpToCopy =
+                new File(getInstrumentation().getTargetContext().getCacheDir(), "secondToCopy.dmp");
         setUpMinidumpFile(firstMinidumpToCopy, BOUNDARY, "browser");
         setUpMinidumpFile(secondMinidumpToCopy, BOUNDARY, "renderer");
         final String expectedFirstFileContent = readEntireFile(firstMinidumpToCopy);
         final String expectedSecondFileContent = readEntireFile(secondMinidumpToCopy);
 
         File[] uploadedFiles = copyAndUploadMinidumpsSync(fileManager,
                 new File[][] {{firstMinidumpToCopy}, {secondMinidumpToCopy}}, new int[] {0, 0});
 
         // CrashReceiverService will rename the minidumps to some globally unique file name
         // meaning that we have to check the contents of the minidump rather than the file
@@ skipping 36 matching lines @@
         for (int n = 0; n < minidumps.length; n++) {
             File[] currentMinidumps = minidumps[n];
             numMinidumps += currentMinidumps.length;
             fileDescriptors[n] = new ParcelFileDescriptor[currentMinidumps.length];
             for (int m = 0; m < currentMinidumps.length; m++) {
                 fileDescriptors[n][m] = ParcelFileDescriptor.open(
                         currentMinidumps[m], ParcelFileDescriptor.MODE_READ_ONLY);
                 assertTrue(currentMinidumps[m].delete());
             }
             crashReceiverService.performMinidumpCopyingSerially(
-                    uids[n] /* uid */, fileDescriptors[n], false /* scheduleUploads */);
+                    getInstrumentation().getTargetContext(), uids[n] /* uid */, fileDescriptors[n],
+                    false /* scheduleUploads */);
         }
 
         PlatformServiceBridge.injectInstance(new TestPlatformServiceBridge(true));
         final CrashReportingPermissionManager permManager =
                 new MockCrashReportingPermissionManager() {
                     { mIsEnabledForTests = true; }
                 };
         MinidumpUploader minidumpUploader = new TestMinidumpUploaderImpl(permManager);
 
         uploadMinidumpsSync(minidumpUploader, false /* expectReschedule */);
         // Ensure there are no minidumps left to upload.
         File[] nonUploadedMinidumps =
                 fileManager.getAllMinidumpFiles(MinidumpUploaderImpl.MAX_UPLOAD_TRIES_ALLOWED);
         assertEquals(0, nonUploadedMinidumps.length);
 
         File[] uploadedFiles = fileManager.getAllUploadedFiles();
         assertEquals(numMinidumps, uploadedFiles.length);
         return uploadedFiles;
     }
 
     private File createMinidumpFileInCrashDir(String name) throws IOException {
         File minidumpFile = new File(mCrashDir, name);
         setUpMinidumpFile(minidumpFile, BOUNDARY);
         return minidumpFile;
     }
 }