Use 64kb read buffer in CRNHttpProtocolHandler on iOS.

components/grpc_support/test/quic_test_server.cc

 // Copyright 2016 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/grpc_support/test/quic_test_server.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 22 matching lines @@
 const char kHelloPath[] = "/hello.txt";
 const char kHelloBodyValue[] = "Hello from QUIC Server";
 const char kHelloStatus[] = "200";
 
 const char kHelloHeaderName[] = "hello_header";
 const char kHelloHeaderValue[] = "hello header value";
 
 const char kHelloTrailerName[] = "hello_trailer";
 const char kHelloTrailerValue[] = "hello trailer value";
 
+const char kTestServerSimpleUrl[] = "https://test.example.com/simple.txt";
+const char kSimplePath[] = "/simple.txt";
+const char kSimpleBodyValue[] = "Simple Hello from QUIC Server";
+const char kSimpleStatus[] = "200";
+
+const char kSimpleHeaderName[] = "hello_header";
+const char kSimpleHeaderValue[] = "hello header value";
+
 base::Thread* g_quic_server_thread = nullptr;
 net::QuicHttpResponseCache* g_quic_response_cache = nullptr;
 net::QuicSimpleServer* g_quic_server = nullptr;
 int g_quic_server_port = 0;
 
 void SetupQuicHttpResponseCache() {
   net::SpdyHeaderBlock headers;
   headers[kHelloHeaderName] = kHelloHeaderValue;
   headers[kStatusHeader] =  kHelloStatus;
   net::SpdyHeaderBlock trailers;
   trailers[kHelloTrailerName] = kHelloTrailerValue;
   g_quic_response_cache = new net::QuicHttpResponseCache();
   g_quic_response_cache->AddResponse(base::StringPrintf("%s", kTestServerHost),
                                       kHelloPath, std::move(headers),
                                       kHelloBodyValue, std::move(trailers));
+  headers[kSimpleHeaderName] = kSimpleHeaderValue;
+  headers[kStatusHeader] = kSimpleStatus;
+  g_quic_response_cache->AddResponse(base::StringPrintf("%s", kTestServerHost),
+                                     kSimplePath, std::move(headers),
+                                     kSimpleBodyValue);
 }
 
 void StartQuicServerOnServerThread(const base::FilePath& test_files_root,
                                    base::WaitableEvent* server_started_event) {
   DCHECK(g_quic_server_thread->task_runner()->BelongsToCurrentThread());
   DCHECK(!g_quic_server);
 
   net::QuicConfig config;
   // Set up server certs.
   base::FilePath directory;
   directory = test_files_root;
   std::unique_ptr<net::ProofSourceChromium> proof_source(
       new net::ProofSourceChromium());
   CHECK(proof_source->Initialize(
       directory.AppendASCII("quic_test.example.com.crt"),
       directory.AppendASCII("quic_test.example.com.key.pkcs8"),
       directory.AppendASCII("quic_test.example.com.key.sct")));
-
   SetupQuicHttpResponseCache();
 
   g_quic_server = new net::QuicSimpleServer(
       std::move(proof_source), config,
       net::QuicCryptoServerConfig::ConfigOptions(), net::AllSupportedVersions(),
       g_quic_response_cache);
 
   // Start listening on an unbound port.
   int rv = g_quic_server->Listen(
       net::IPEndPoint(net::IPAddress::IPv4AllZeros(), 0));
   CHECK_GE(rv, 0) << "Quic server fails to start";
   g_quic_server_port = g_quic_server->server_address().port();
-
   server_started_event->Signal();
 }
 
 void ShutdownOnServerThread(base::WaitableEvent* server_stopped_event) {
   DCHECK(g_quic_server_thread->task_runner()->BelongsToCurrentThread());
   g_quic_server->Shutdown();
   delete g_quic_server;
   g_quic_server = nullptr;
   delete g_quic_response_cache;
   g_quic_response_cache = nullptr;
@@ skipping 32 matching lines @@
   server_stopped_event.Wait();
   delete g_quic_server_thread;
   g_quic_server_thread = nullptr;
 }
 
 int GetQuicTestServerPort() {
   return g_quic_server_port;
 }
 
 }  // namespace grpc_support