Enable Sdch in Cronet

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 "native_test_server.h"
 
+#include <string>
+
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/files/file_path.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/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/dns/host_resolver_impl.h"
+#include "net/dns/host_resolver_proc.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 echo_body_path[] = "/echo_body";
 const char echo_header_path[] = "/echo_header";
 const char echo_all_headers_path[] = "/echo_all_headers";
 const char echo_method_path[] = "/echo_method";
 const char redirect_to_echo_body_path[] = "/redirect_to_echo_body";
+const char fake_sdch_domain[] = "fake.sdch.domain";
+// Path that advertises a dictionary if client supports Sdch encoding.
+const char sdch_path[] = "/sdch";
+// Path that returns encoded response if client has the right dictionary.
+const char sdch_test_path[] = "/sdch/test";
 
 net::test_server::EmbeddedTestServer* g_test_server = nullptr;
 
-scoped_ptr<net::test_server::HttpResponse> UploadServerRequestHandler(
+// HostResolverProc that binds |fake_sdch_domain| to localhost
+class LocalHostResolverProc : public net::HostResolverProc {
+ public:
+  LocalHostResolverProc() : HostResolverProc(NULL) {}
+
+  int Resolve(const std::string& host,
+              net::AddressFamily address_family,
+              net::HostResolverFlags host_resolver_flags,
+              net::AddressList* addrlist,
+              int* os_error) override {
+    DCHECK(g_test_server);
+    if (host == fake_sdch_domain) {
+      *addrlist = net::AddressList();
+      net::IPAddressNumber localhost;
+      net::ParseIPLiteralToNumber("127.0.0.1", &localhost);
+      addrlist->push_back(net::IPEndPoint(localhost, 0));
+      return net::OK;
+    }
+    return ResolveUsingPrevious(host, address_family, host_resolver_flags,
+                                addrlist, os_error);
+  }
+
+ private:
+  ~LocalHostResolverProc() override {}
+};
+
+scoped_ptr<net::test_server::HttpResponse> NativeTestServerRequestHandler(
     const net::test_server::HttpRequest& request) {
   DCHECK(g_test_server);
   scoped_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse());
   response->set_content_type("text/plain");
 
   if (request.relative_url == echo_body_path) {
     if (request.has_content) {
       response->set_content(request.content);
     } else {
@@ skipping 22 matching lines @@
     response->set_content(request.method_string);
     return response.Pass();
   }
 
   if (request.relative_url == redirect_to_echo_body_path) {
     response->set_code(net::HTTP_TEMPORARY_REDIRECT);
     response->AddCustomHeader("Location", echo_body_path);
     return response.Pass();
   }
 
+  if (request.relative_url == sdch_path) {
+    auto it = request.headers.find("Accept-Encoding");
+    if (it != request.headers.end()) {
+      if (it->second.find("sdch") != std::string::npos)
+        response->AddCustomHeader("Get-Dictionary", "/sdch/dict/LeQxM80O");
+    }
+    response->set_content("The quick brown fox jumps over the lazy dog.\n");
+    return response.Pass();
+  }
+
+  if (StartsWithASCII(request.relative_url, sdch_test_path, true)) {
+    auto it = request.headers.find("Avail-Dictionary");
+    if (it != request.headers.end()) {
+      if (it->second == "LeQxM80O") {
+        response->AddCustomHeader("Content-Encoding", "sdch");
+        const unsigned char rawData[33] = {
+            0x59, 0x42, 0x36, 0x44, 0x58, 0x45, 0x2D, 0x68, 0x00, 0xD6, 0xC3,
+            0xC4, 0x53, 0x00, 0x05, 0x2E, 0x00, 0x0F, 0x2D, 0x00, 0x00, 0x05,
+            0x00, 0x87, 0xDE, 0xA4, 0xA0, 0x11, 0x73, 0x2C, 0x00, 0x02, 0x0A,
+        };
+        std::string data(rawData, rawData + 33);
+        response->set_content(data);
+      }
+    } else {
+      response->set_content("Sdch is not used.\n");
+    }
+    return response.Pass();
+  }
+
   // 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,
+    base::android::ScopedJavaGlobalRef<jobject>* callback) {
+  net::HostResolverImpl* resolver =
+      static_cast<net::HostResolverImpl*>(url_request_context->host_resolver());
+  resolver->set_proc_params_for_test(
+      net::HostResolverImpl::ProcTaskParams(new LocalHostResolverProc(), 1u));
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_NativeTestServer_onHostResolverProcRegistered(env, callback->obj());
+}
+
+void RegisterHostResolverProcOnNetworkThread(
+    CronetURLRequestContextAdapter* context_adapter,
+    base::android::ScopedJavaGlobalRef<jobject>* callback) {
+  net::URLRequestContext* context = context_adapter->GetURLRequestContext();
+  RegisterHostResolverProcHelper(context, callback);
+}
+
+void RegisterHostResolverProcOnNetworkThreadLegacyAPI(
+    URLRequestContextAdapter* context_adapter,
+    base::android::ScopedJavaGlobalRef<jobject>* callback) {
+  net::URLRequestContext* context = context_adapter->GetURLRequestContext();
+  RegisterHostResolverProcHelper(context, callback);
+}
+
 }  // namespace
 
 jboolean StartNativeTestServer(JNIEnv* env,
                                jclass jcaller,
                                jstring jtest_files_root) {
   // Shouldn't happen.
   if (g_test_server)
     return false;
   g_test_server = new net::test_server::EmbeddedTestServer();
   g_test_server->RegisterRequestHandler(
-      base::Bind(&UploadServerRequestHandler));
-  // Add a second handler for paths that UploadServerRequestHandler does not
+      base::Bind(&NativeTestServerRequestHandler));
+  // Add a second handler for paths that NativeTestServerRequestHandler does not
   // handle.
   base::FilePath test_files_root(
       base::android::ConvertJavaStringToUTF8(env, jtest_files_root));
   g_test_server->ServeFilesFromDirectory(test_files_root);
   return g_test_server->InitializeAndWaitUntilReady();
 }
 
+void RegisterHostResolverProc(JNIEnv* env,
+                              jclass jcaller,
+                              jlong jadapter,
+                              jboolean jlegacy_api) {
+  DCHECK(!g_test_server);
+  base::android::ScopedJavaGlobalRef<jobject>* callback =
+      new base::android::ScopedJavaGlobalRef<jobject>();
+  callback->Reset(env, jcaller);
+  if (jlegacy_api == JNI_TRUE) {
+    URLRequestContextAdapter* context_adapter =
+        reinterpret_cast<URLRequestContextAdapter*>(jadapter);
+    context_adapter->PostTaskToNetworkThread(
+        FROM_HERE,
+        base::Bind(&RegisterHostResolverProcOnNetworkThreadLegacyAPI,
+                   base::Unretained(context_adapter), base::Owned(callback)));
+  } else {
+    CronetURLRequestContextAdapter* context_adapter =
+        reinterpret_cast<CronetURLRequestContextAdapter*>(jadapter);
+    context_adapter->PostTaskToNetworkThread(
+        FROM_HERE,
+        base::Bind(&RegisterHostResolverProcOnNetworkThread,
+                   base::Unretained(context_adapter), base::Owned(callback)));
+  }
+}
+
 void ShutdownNativeTestServer(JNIEnv* env, jclass jcaller) {
   if (!g_test_server)
     return;
   delete g_test_server;
   g_test_server = NULL;
 }
 
 jstring GetEchoBodyURL(JNIEnv* env, jclass jcaller) {
   DCHECK(g_test_server);
   GURL url = g_test_server->GetURL(echo_body_path);
@@ skipping 28 matching lines @@
   return base::android::ConvertUTF8ToJavaString(env, url.spec()).Release();
 }
 
 jstring GetFileURL(JNIEnv* env, jclass jcaller, jstring jfile_path) {
   DCHECK(g_test_server);
   std::string file = base::android::ConvertJavaStringToUTF8(env, jfile_path);
   GURL url = g_test_server->GetURL(file);
   return base::android::ConvertUTF8ToJavaString(env, url.spec()).Release();
 }
 
+jstring GetSdchURL(JNIEnv* env, jclass jcaller) {
+  DCHECK(g_test_server);
+  std::string url(base::StringPrintf("http://%s:%d", fake_sdch_domain,
+                                     g_test_server->port()));
+  return base::android::ConvertUTF8ToJavaString(env, url).Release();
+}
+
 bool RegisterNativeTestServer(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace cronet