[Cronet] Get Cronet performance test running again

components/cronet/android/test/native_test_server.cc

 // Copyright 2014 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.
 
 #include "components/cronet/android/test/native_test_server.h"
 
 #include <string>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/path_utils.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "components/cronet/android/cronet_url_request_context_adapter.h"
-#include "components/cronet/android/url_request_context_adapter.h"
 #include "jni/NativeTestServer_jni.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/url_util.h"
-#include "net/dns/host_resolver_impl.h"
-#include "net/dns/mock_host_resolver.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "url/gurl.h"
 
 namespace cronet {
 
 namespace {
 
 const char kEchoBodyPath[] = "/echo_body";
 const char kEchoHeaderPath[] = "/echo_header";
 const char kEchoAllHeadersPath[] = "/echo_all_headers";
 const char kEchoMethodPath[] = "/echo_method";
 const char kRedirectToEchoBodyPath[] = "/redirect_to_echo_body";
-const char kFakeSdchDomain[] = "fake.sdch.domain";
-// Host used in QuicTestServer. This must match the certificate used
-// (quic_test.example.com.crt and quic_test.example.com.key.pkcs8), and
-// the file served (
-// components/cronet/android/test/assets/test/quic_data/simple.txt).
-const char kFakeQuicDomain[] = "test.example.com";
 // Path that advertises the dictionary passed in query params if client
 // supports Sdch encoding. E.g. /sdch/index?q=LeQxM80O will make the server
 // responds with "Get-Dictionary: /sdch/dict/LeQxM80O".
 const char kSdchPath[] = "/sdch/index";
 // Path that returns encoded response if client has the right dictionary.
 const char kSdchTestPath[] = "/sdch/test";
 // Path where dictionaries are stored.
 const char kSdchDictPath[] = "/sdch/dict/";
 
 net::EmbeddedTestServer* g_test_server = nullptr;
@@ skipping 103 matching lines @@
         new net::test_server::BasicHttpResponse());
     response->set_content_type("text/plain");
     response->set_content("Sdch is not used.\n");
     return std::move(response);
   }
 
   // Unhandled requests result in the Embedded test server sending a 404.
   return scoped_ptr<net::test_server::BasicHttpResponse>();
 }
 
-void RegisterHostResolverProcHelper(
-    net::URLRequestContext* url_request_context) {
-  net::HostResolverImpl* resolver =
-      static_cast<net::HostResolverImpl*>(url_request_context->host_resolver());
-  scoped_refptr<net::RuleBasedHostResolverProc> proc =
-      new net::RuleBasedHostResolverProc(NULL);
-  proc->AddRule(kFakeSdchDomain, "127.0.0.1");
-  proc->AddRule(kFakeQuicDomain, "127.0.0.1");
-  resolver->set_proc_params_for_test(
-      net::HostResolverImpl::ProcTaskParams(proc.get(), 1u));
-  JNIEnv* env = base::android::AttachCurrentThread();
-  Java_NativeTestServer_onHostResolverProcRegistered(env);
-}
-
-void RegisterHostResolverProcOnNetworkThread(
-    CronetURLRequestContextAdapter* context_adapter) {
-  RegisterHostResolverProcHelper(context_adapter->GetURLRequestContext());
-}
-
-// TODO(xunjieli): Delete this once legacy API is removed.
-void RegisterHostResolverProcOnNetworkThreadLegacyAPI(
-    URLRequestContextAdapter* context_adapter) {
-  RegisterHostResolverProcHelper(context_adapter->GetURLRequestContext());
-}
-
 }  // namespace
 
 jboolean StartNativeTestServer(JNIEnv* env,
                                const JavaParamRef<jclass>& jcaller,
                                const JavaParamRef<jstring>& jtest_files_root) {
   // Shouldn't happen.
   if (g_test_server)
     return false;
   g_test_server = new net::EmbeddedTestServer();
   g_test_server->RegisterRequestHandler(
       base::Bind(&NativeTestServerRequestHandler));
   g_test_server->RegisterRequestHandler(base::Bind(&SdchRequestHandler));
   base::FilePath test_files_root(
       base::android::ConvertJavaStringToUTF8(env, jtest_files_root));
 
   // Add a third handler for paths that NativeTestServerRequestHandler does not
   // handle.
   g_test_server->ServeFilesFromDirectory(test_files_root);
   return g_test_server->Start();
 }
 
-void RegisterHostResolverProc(JNIEnv* env,
-                              const JavaParamRef<jclass>& jcaller,
-                              jlong jadapter,
-                              jboolean jlegacy_api) {
-  if (jlegacy_api == JNI_TRUE) {
-    URLRequestContextAdapter* context_adapter =
-        reinterpret_cast<URLRequestContextAdapter*>(jadapter);
-    context_adapter->PostTaskToNetworkThread(
-        FROM_HERE, base::Bind(&RegisterHostResolverProcOnNetworkThreadLegacyAPI,
-                              base::Unretained(context_adapter)));
-  } else {
-    CronetURLRequestContextAdapter* context_adapter =
-        reinterpret_cast<CronetURLRequestContextAdapter*>(jadapter);
-    context_adapter->PostTaskToNetworkThread(
-        FROM_HERE, base::Bind(&RegisterHostResolverProcOnNetworkThread,
-                              base::Unretained(context_adapter)));
-  }
-}
-
 void ShutdownNativeTestServer(JNIEnv* env,
                               const JavaParamRef<jclass>& jcaller) {
   if (!g_test_server)
     return;
   delete g_test_server;
   g_test_server = NULL;
 }
 
 ScopedJavaLocalRef<jstring> GetEchoBodyURL(
     JNIEnv* env,
@@ skipping 73 matching lines @@
 #else
   return JNI_FALSE;
 #endif
 }
 
 bool RegisterNativeTestServer(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace cronet