[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")}));
             }
             mCronetEngine = cronetEngineBuilder.build();
+            long urlRequestContextAdapter =
+                    ((CronetUrlRequestContext) mCronetEngine).getUrlRequestContextAdapter();
+            NativeTestServer.registerHostResolverProc(

[mef, 2015/12/29 17:27:45]

registerHostResolverProc doesn't really have anything to do with
NativeTestServer apart from historical location.
I wonder whether it belongs to CronetTestUtil or somesuch?

[pauljensen, 2016/01/21 03:51:50]

Done.

+                    urlRequestContextAdapter, false, 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 377 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();
     }
 }