Fix CronetHttpURLConnectionTest#testServerHangsUp flake

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 <memory>
 #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/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_support_android.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "components/cronet/android/test/cronet_test_util.h"
 #include "jni/NativeTestServer_jni.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/url_util.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 "net/test/embedded_test_server/request_handler_util.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 kInfiniteResponsePath[] = "/infinite_response";
 // 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;
 
+// A HttpResponse that is never ending.
+class InfiniteResponse : public net::test_server::BasicHttpResponse {
+ public:
+  InfiniteResponse() {}
+
+  void SendResponse(
+      const net::test_server::SendBytesCallback& send,
+      const net::test_server::SendCompleteCallback& done) override {
+    // Use am arbitrarily large content length so that the client will be
+    // expecting data.
+    send.Run("HTTP/1.1 200 OK\r\nContent-Length:100000000\r\n\r\n",

[pauljensen, 2016/07/20 17:40:23]

Is there any way we can avoid this arbitrary number?  How about by simply not
specifying a Content-Length?

[xunjieli, 2016/07/20 17:46:18]

If we don't specify the Content-Length, client will just take whatever received
so far (before connection closed) as the right content. There won't be any error
generated.

[pauljensen, 2016/07/20 17:55:55]

10^8 isn't really that big relative to the size of RAM or processor speed on
many devices.  I could imagine this getting buffered somewhere or being
transfered really quickly.  Could we make this larger, like 10^18?

I don't think we should call this infinite if it has a definite content-length. 
I think when someone reads infinite they think without a content-length (e.g. a
streaming response).  Perhaps give it a content-length of 10^18 and call it
ExabyteResponse?

[xunjieli, 2016/07/20 18:42:02]

Done. Good point!

+             base::Bind(&InfiniteResponse::SendInfinite, send));
+  }
+
+ private:
+  // Keeps sending the word "echo" over and over again.
+  static void SendInfinite(const net::test_server::SendBytesCallback& send) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(send, "echo",
+                   base::Bind(&InfiniteResponse::SendInfinite, send)));
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(InfiniteResponse);
+};
+
 std::unique_ptr<net::test_server::RawHttpResponse> ConstructResponseBasedOnFile(
     const base::FilePath& file_path) {
   std::string file_contents;
   bool read_file = base::ReadFileToString(file_path, &file_contents);
   DCHECK(read_file);
   base::FilePath headers_path(
       file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
   std::string headers_contents;
   bool read_headers = base::ReadFileToString(headers_path, &headers_contents);
   DCHECK(read_headers);
@@ skipping 92 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 std::unique_ptr<net::test_server::BasicHttpResponse>();
 }
 
+std::unique_ptr<net::test_server::HttpResponse> HandleInfiniteRequest(
+    const net::test_server::HttpRequest& request) {
+  return base::WrapUnique(new InfiniteResponse);
+}
+
 }  // namespace
 
 jboolean StartNativeTestServer(JNIEnv* env,
                                const JavaParamRef<jclass>& jcaller,
                                const JavaParamRef<jstring>& jtest_files_root,
                                const JavaParamRef<jstring>& jtest_data_dir) {
   // Shouldn't happen.
   if (g_test_server)
     return false;
 
   base::FilePath test_data_dir(
       base::android::ConvertJavaStringToUTF8(env, jtest_data_dir));
   base::InitAndroidTestPaths(test_data_dir);
 
   g_test_server = new net::EmbeddedTestServer();
   g_test_server->RegisterRequestHandler(
       base::Bind(&NativeTestServerRequestHandler));
+  g_test_server->RegisterDefaultHandler(
+      base::Bind(&net::test_server::HandlePrefixedRequest,
+                 kInfiniteResponsePath, base::Bind(&HandleInfiniteRequest)));
   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();
 }
 
@@ skipping 61 matching lines @@
 }
 
 ScopedJavaLocalRef<jstring> GetSdchURL(JNIEnv* env,
                                        const JavaParamRef<jclass>& jcaller) {
   DCHECK(g_test_server);
   std::string url(base::StringPrintf("http://%s:%d", kFakeSdchDomain,
                                      g_test_server->port()));
   return base::android::ConvertUTF8ToJavaString(env, url);
 }
 
+ScopedJavaLocalRef<jstring> GetInfiniteResponseURL(
+    JNIEnv* env,
+    const JavaParamRef<jclass>& jcaller) {
+  DCHECK(g_test_server);
+  GURL url = g_test_server->GetURL(kInfiniteResponsePath);
+  return base::android::ConvertUTF8ToJavaString(env, url.spec());
+}
+
 ScopedJavaLocalRef<jstring> GetHostPort(JNIEnv* env,
                                         const JavaParamRef<jclass>& jcaller) {
   DCHECK(g_test_server);
   std::string host_port =
       net::HostPortPair::FromURL(g_test_server->base_url()).ToString();
   return base::android::ConvertUTF8ToJavaString(env, host_port);
 }
 
 jboolean IsDataReductionProxySupported(JNIEnv* env,
                                        const JavaParamRef<jclass>& jcaller) {
 #if defined(DATA_REDUCTION_PROXY_SUPPORT)
   return JNI_TRUE;
 #else
   return JNI_FALSE;
 #endif
 }
 
 bool RegisterNativeTestServer(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace cronet