[Cronet] Get Cronet performance test running again

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.chromium.base.PathUtils;
+
 import org.json.JSONException;
 import org.json.JSONObject;
 
 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;
 import java.net.URLConnection;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Runs networking benchmarks and saves results to a file.
  */
 public class CronetPerfTestActivity extends Activity {
+    private static final String PRIVATE_DATA_DIRECTORY_SUFFIX = "cronet_perf_test";
     // Benchmark configuration passed down from host via Intent data.
     // Call getConfig*(key) to extract individual configuration values.
     private Uri mConfig;
     // Functions that retrieve individual benchmark configuration values.
     private String getConfigString(String key) {
         return mConfig.getQueryParameter(key);
     }
     private int getConfigInt(String key) {
         return Integer.parseInt(mConfig.getQueryParameter(key));
     }
@@ skipping 102 matching lines @@
                     // When measuring a large upload, only download a small amount so download time
                     // isn't significant.
                     resource = getConfigString(
                             direction == Direction.UP ? "SMALL_RESOURCE" : "LARGE_RESOURCE");
                     mIterations = getConfigInt("LARGE_ITERATIONS");
                     mLength = getConfigInt("LARGE_RESOURCE_SIZE");
                     break;
                 default:
                     throw new IllegalArgumentException("Unknown size: " + size);
             }
+            final String scheme;
+            final String host;
             final int port;
             switch (protocol) {
                 case HTTP:
+                    scheme = "http";
+                    host = getConfigString("HOST_IP");
                     port = getConfigInt("HTTP_PORT");
                     break;
                 case QUIC:
+                    scheme = "https";
+                    host = getConfigString("HOST");
                     port = getConfigInt("QUIC_PORT");
                     break;
                 default:
                     throw new IllegalArgumentException("Unknown protocol: " + protocol);
             }
             try {
-                mUrl = new URL("http", getConfigString("HOST"), port, resource);
+                mUrl = new URL(scheme, host, port, resource);
             } catch (MalformedURLException e) {
-                throw new IllegalArgumentException("Bad URL: " + getConfigString("HOST") + ":"
-                        + port + "/" + resource);
+                throw new IllegalArgumentException(
+                        "Bad URL: " + host + ":" + port + "/" + resource);
             }
             final CronetEngine.Builder cronetEngineBuilder =
                     new CronetEngine.Builder(CronetPerfTestActivity.this);
+            cronetEngineBuilder.setLibraryName("cronet_tests");
             if (mProtocol == Protocol.QUIC) {
                 cronetEngineBuilder.enableQUIC(true);
-                cronetEngineBuilder.addQuicHint(getConfigString("HOST"), getConfigInt("QUIC_PORT"),
-                        getConfigInt("QUIC_PORT"));
+                cronetEngineBuilder.addQuicHint(host, port, port);
+                cronetEngineBuilder.setMockCertVerifierForTesting(
+                        MockCertVerifier.createMockCertVerifier(
+                                new String[] {getConfigString("QUIC_CERT_FILE")}));
+            }
+
+            try {
+                JSONObject quicParams = new JSONObject().put("host_whitelist", host);
+                JSONObject experimentalOptions = new JSONObject().put("QUIC", quicParams);
+                cronetEngineBuilder.setExperimentalOptions(experimentalOptions.toString());
+            } catch (JSONException e) {
+                throw new IllegalStateException("JSON failed: " + e);
             }
             mCronetEngine = cronetEngineBuilder.build();
+            CronetTestUtil.registerHostResolverProc(mCronetEngine, getConfigString("HOST_IP"));
             mName = buildBenchmarkName(mode, direction, protocol, concurrency, mIterations);
             mConcurrency = concurrency;
             mResults = results;
             mBufferSize = mLength > getConfigInt("MAX_BUFFER_SIZE")
                     ? getConfigInt("MAX_BUFFER_SIZE")
                     : mLength;
             mUseNetworkThread = getConfigBoolean("CRONET_ASYNC_USE_NETWORK_THREAD");
         }
 
         private void startTimer() {
@@ skipping 178 matching lines @@
                 }
 
                 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;
 
                 Callback(ByteBuffer buffer, Runnable completionCallback) {
                     mBuffer = buffer;
                     mCompletionCallback = completionCallback;
                 }
 
                 @Override
                 public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
                     mBuffer.clear();
                     request.readNew(mBuffer);
                 }
 
                 @Override
                 public void onRedirectReceived(
                         UrlRequest request, UrlResponseInfo info, String newLocationUrl) {
                     request.followRedirect();
                 }
 
                 @Override
                 public void onReadCompleted(
                         UrlRequest request, UrlResponseInfo info, ByteBuffer byteBuffer) {
+                    mBytesReceived += byteBuffer.position();
                     mBuffer.clear();
                     request.readNew(mBuffer);
                 }
 
                 @Override
                 public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
+                    if (info.getHttpStatusCode() != 200 || mBytesReceived != mLength) {
+                        System.out.println("Failed: response code: " + info.getHttpStatusCode()
+                                + " bytes: " + mBytesReceived);
+                        mFailed = true;
+                    }
                     mCompletionCallback.run();
                 }
 
                 @Override
                 public void onFailed(
                         UrlRequest request, UrlResponseInfo info, UrlRequestException e) {
                     System.out.println("Async request failed with " + e);
                     mFailed = true;
                 }
             }
@@ skipping 152 matching lines @@
                 }
             }
             finish();
             return null;
         }
     }
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX, this);
         mConfig = getIntent().getData();
         // Execute benchmarks on another thread to avoid networking on main thread.
         new BenchmarkTask().execute();
     }
 }