Use 64kb read buffer in CRNHttpProtocolHandler on iOS.

components/cronet/ios/test/test_server.cc

Index: components/cronet/ios/test/test_server.cc
diff --git a/components/cronet/ios/test/test_server.cc b/components/cronet/ios/test/test_server.cc
index 1d549a079fb2768e82d1586ac6a53fe7891c3e5e..f4ac2baa948f0094bc87cfe4154c2fa1e0b86b9e 100644
--- a/components/cronet/ios/test/test_server.cc
+++ b/components/cronet/ios/test/test_server.cc
@@ -7,7 +7,9 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
@@ -17,8 +19,11 @@ namespace {
 
 const char kEchoHeaderPath[] = "/EchoHeader?";
 const char kSetCookiePath[] = "/SetCookie?";
+const char kBigDataPath[] = "/BigData?";
 
 std::unique_ptr<net::EmbeddedTestServer> g_test_server;
+base::LazyInstance<std::string>::Leaky g_big_data_body =

[kapishnikov, 2017/04/19 16:14:16]

Why should g_big_data_body be global? Why can't we generate the response locally
at the time of the request? What if there are two concurrent requests with
different request data lengths?

[mef, 2017/04/19 17:39:09]

I would like to avoid allocation of big chunks of memory for every response as I
would expect that it could affect results. 
Looking a little deeper it seems like RawHttpResponse should work a little
better for this.

[kapishnikov, 2017/04/19 18:19:01]

That makes sense.

[mef, 2017/04/19 19:04:48]

Acknowledged.

+    LAZY_INSTANCE_INITIALIZER;
 
 std::unique_ptr<net::test_server::HttpResponse> EchoHeaderInRequest(
     const net::test_server::HttpRequest& request) {
@@ -36,6 +41,21 @@ std::unique_ptr<net::test_server::HttpResponse> EchoHeaderInRequest(
   return std::move(http_response);
 }
 
+std::unique_ptr<net::test_server::HttpResponse> ReturnBigDataInResponse(
+    const net::test_server::HttpRequest& request) {
+  std::string data_size_str;
+  DCHECK(base::StartsWith(request.relative_url, kBigDataPath,
+                          base::CompareCase::INSENSITIVE_ASCII));
+
+  data_size_str = request.relative_url.substr(strlen(kBigDataPath));
+  int64_t data_size;
+  DCHECK(base::StringToInt64(base::StringPiece(data_size_str), &data_size));

[kapishnikov, 2017/04/19 16:14:17]

Two questions here:
1) DCHECK is going to be removed in the release version, so the call to
StringToInt64 will also be removed. I think we should make the test functional
regardless of the debug or release variant.
2) What is the benefit of using DCHECK instead of CHECK in the test code in
general?

[mef, 2017/04/19 17:39:09]

FWIW this code didn't affect functionality, just checking that prepared response
body matches the expectation.
I don't think there is one, just a force of habit.

[kapishnikov, 2017/04/19 18:19:01]

I think the check was a good thing because it could help to detect a situation
when there is another parallel request that requests data with a different size.
What if we keep the code as it was and substitute DCHECK with CHECK?

+  DCHECK(data_size == static_cast<int64_t>(g_big_data_body.Get().size()));
+  auto http_response = base::MakeUnique<net::test_server::BasicHttpResponse>();
+  http_response->set_content(g_big_data_body.Get());
+  return std::move(http_response);
+}
+
 std::unique_ptr<net::test_server::HttpResponse> SetAndEchoCookieInResponse(
     const net::test_server::HttpRequest& request) {
   std::string cookie_line;
@@ -58,6 +78,10 @@ std::unique_ptr<net::test_server::HttpResponse> CronetTestRequestHandler(
                        base::CompareCase::INSENSITIVE_ASCII)) {
     return SetAndEchoCookieInResponse(request);
   }
+  if (base::StartsWith(request.relative_url, kBigDataPath,
+                       base::CompareCase::INSENSITIVE_ASCII)) {
+    return ReturnBigDataInResponse(request);
+  }
   return base::MakeUnique<net::test_server::BasicHttpResponse>();
 }
 
@@ -90,4 +114,11 @@ std::string TestServer::GetSetCookieURL(const std::string& cookie_line) {
   return g_test_server->GetURL(kSetCookiePath + cookie_line).spec();
 }
 
+std::string TestServer::GetBigDataURL(long data_size) {
+  DCHECK(g_test_server);
+  g_big_data_body.Get() = std::string(data_size, 'c');
+  return g_test_server->GetURL(kBigDataPath + base::Int64ToString(data_size))
+      .spec();
+}
+
 }  // namespace cronet