Reland "Move PathUtils to use ContextUtils."

components/cronet/android/test/javaperftests/src/org/chromium/net/CronetPerfTestActivity.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.net;
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Debug;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
+import org.chromium.base.ContextUtils;
 import org.chromium.base.PathUtils;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ skipping 297 matching lines @@
                 } catch (IOException e) {
                     System.out.println("Cronet HttpURLConnection failed with " + e);
                     return false;
                 }
             }
         }
 
         // GET or POST to one particular URL using Cronet's asynchronous API
         private class CronetAsyncFetchTask implements Callable<Boolean> {
             // A message-queue for asynchronous tasks to post back to.
-            private final LinkedBlockingQueue<Runnable> mWorkQueue =
-                    new LinkedBlockingQueue<Runnable>();
+            private final LinkedBlockingQueue<Runnable> mWorkQueue = new LinkedBlockingQueue<>();
             private final WorkQueueExecutor mWorkQueueExecutor = new WorkQueueExecutor();
 
             private int mRemainingRequests;
             private int mConcurrentFetchersDone;
             private boolean mFailed;
 
             CronetAsyncFetchTask() {
                 mRemainingRequests = mIterations;
                 mConcurrentFetchersDone = 0;
                 mFailed = false;
             }
 
             private void initiateRequest(final ByteBuffer buffer) {
                 if (mRemainingRequests == 0) {
                     mConcurrentFetchersDone++;
                     if (mUseNetworkThread) {
                         // Post empty task so message loop exit condition is retested.
                         postToWorkQueue(new Runnable() {
+                            @Override
                             public void run() {}
                         });
                     }
                     return;
                 }
                 mRemainingRequests--;
                 final Runnable completionCallback = new Runnable() {
+                    @Override
                     public void run() {
                         initiateRequest(buffer);
                     }
                 };
                 final UrlRequest.Builder builder = new UrlRequest.Builder(mUrl.toString(),
                         new Callback(buffer, completionCallback), mWorkQueueExecutor,
                         mCronetEngine);
                 if (mDirection == Direction.UP) {
                     builder.setUploadDataProvider(new Uploader(buffer), mWorkQueueExecutor);
                     builder.addHeader("Content-Type", "application/octet-stream");
                 }
                 builder.build().start();
             }
 
             private class Uploader extends UploadDataProvider {
                 private final ByteBuffer mBuffer;
                 private int mRemainingBytes;
 
                 Uploader(ByteBuffer buffer) {
                     mBuffer = buffer;
                     mRemainingBytes = mLength;
                 }
 
+                @Override
                 public long getLength() {
                     return mLength;
                 }
 
+                @Override
                 public void read(UploadDataSink uploadDataSink, ByteBuffer byteBuffer) {
                     mBuffer.clear();
                     // Don't post more than |mLength|.
                     if (mRemainingBytes < mBuffer.limit()) {
                         mBuffer.limit(mRemainingBytes);
                     }
                     // Don't overflow |byteBuffer|.
                     if (byteBuffer.remaining() < mBuffer.limit()) {
                         mBuffer.limit(byteBuffer.remaining());
                     }
                     byteBuffer.put(mBuffer);
                     mRemainingBytes -= mBuffer.position();
                     uploadDataSink.onReadSucceeded(false);
                 }
 
+                @Override
                 public void rewind(UploadDataSink uploadDataSink) {
                     uploadDataSink.onRewindError(new Exception("no rewinding"));
                 }
             }
 
             private class Callback extends UrlRequest.Callback {
                 private final ByteBuffer mBuffer;
                 private final Runnable mCompletionCallback;
                 private int mBytesReceived;
 
@@ skipping 76 matching lines @@
                 }
                 return !mFailed;
             }
         }
 
         /**
          * Executes the benchmark, times how long it takes, and records time in |mResults|.
          */
         public void run() {
             final ExecutorService executor = Executors.newFixedThreadPool(mConcurrency);
-            final List<Callable<Boolean>> tasks = new ArrayList<Callable<Boolean>>(mIterations);
+            final List<Callable<Boolean>> tasks = new ArrayList<>(mIterations);
             startLogging();
             // Prepare list of tasks to run.
             switch (mMode) {
                 case SYSTEM_HUC:
                     for (int i = 0; i < mIterations; i++) {
                         tasks.add(new SystemHttpURLConnectionFetchTask());
                     }
                     break;
                 case CRONET_HUC: {
                     for (int i = 0; i < mIterations; i++) {
                         tasks.add(new CronetHttpURLConnectionFetchTask());
                     }
                     break;
                 }
                 case CRONET_ASYNC:
                     tasks.add(new CronetAsyncFetchTask());
                     break;
                 default:
                     throw new IllegalArgumentException("Unknown mode: " + mMode);
             }
             // Execute tasks.
             boolean success = true;
-            List<Future<Boolean>> futures = new ArrayList<Future<Boolean>>();
+            List<Future<Boolean>> futures = new ArrayList<>();
             try {
                 startTimer();
                 // If possible execute directly to lessen impact of thread-pool overhead.
                 if (tasks.size() == 1 || mConcurrency == 1) {
                     for (int i = 0; i < tasks.size(); i++) {
                         if (!tasks.get(i).call()) {
                             success = false;
                         }
                     }
                 } else {
@@ skipping 74 matching lines @@
                 }
             }
             finish();
             return null;
         }
     }
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX, this);
+        // Initializing application context here due to lack of custom CronetPerfTestApplication.
+        ContextUtils.initApplicationContext(getApplicationContext());
+        PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX);
         mConfig = getIntent().getData();
         // Execute benchmarks on another thread to avoid networking on main thread.
         new BenchmarkTask().execute();
     }
 }