Make QuicSimpleServerStream supports multipart response body

net/tools/quic/quic_in_memory_cache.cc

 // Copyright (c) 2012 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 "net/tools/quic/quic_in_memory_cache.h"
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 54 matching lines @@
                                           StringPiece path,
                                           int response_code,
                                           StringPiece body) {
   SpdyHeaderBlock response_headers;
   response_headers[":status"] = IntToString(response_code);
   response_headers["content-length"] =
       IntToString(static_cast<int>(body.length()));
   AddResponse(host, path, response_headers, body);
 }
 
+void QuicInMemoryCache::AddBidirectionalResponse(
+    StringPiece host,
+    StringPiece path,
+    int response_code,
+    const std::vector<std::string>& body_chunks,
+    const SpdyHeaderBlock& response_trailers) {
+  SpdyHeaderBlock response_headers;
+  response_headers[":status"] = IntToString(response_code);
+  AddResponseImpl(host, path, BIDIRECTIONAL, response_headers, "", body_chunks,
+                  response_trailers);
+}
+
 void QuicInMemoryCache::AddSimpleResponseWithServerPushResources(
     StringPiece host,
     StringPiece path,
     int response_code,
     StringPiece body,
     list<ServerPushInfo> push_resources) {
   AddSimpleResponse(host, path, response_code, body);
   MaybeAddServerPushResources(host, path, push_resources);
 }
 
@@ skipping 115 matching lines @@
   STLDeleteValues(&responses_);
 }
 
 void QuicInMemoryCache::AddResponseImpl(
     StringPiece host,
     StringPiece path,
     SpecialResponseType response_type,
     const SpdyHeaderBlock& response_headers,
     StringPiece response_body,
     const SpdyHeaderBlock& response_trailers) {
+  std::vector<std::string> body_chunks;
+  AddResponseImpl(host, path, response_type, response_headers, response_body,
+                  body_chunks, response_trailers);
+}
+void QuicInMemoryCache::AddResponseImpl(
+    StringPiece host,
+    StringPiece path,
+    SpecialResponseType response_type,
+    const SpdyHeaderBlock& response_headers,
+    StringPiece response_body,
+    const std::vector<std::string>& body_chunks,
+    const SpdyHeaderBlock& response_trailers) {
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
   string key = GetKey(host, path);
   if (ContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
   Response* new_response = new Response();
   new_response->set_response_type(response_type);
   new_response->set_headers(response_headers);
-  new_response->set_body(response_body);
+  if (response_type != BIDIRECTIONAL) {
+    CHECK(body_chunks.empty());
+    new_response->set_body(response_body);
+  } else {
+    new_response->SetBodyChunks(body_chunks);
+  }
   new_response->set_trailers(response_trailers);
   responses_[key] = new_response;
 }
 
 string QuicInMemoryCache::GetKey(StringPiece host, StringPiece path) const {
   return host.as_string() + path.as_string();
 }
 
 void QuicInMemoryCache::MaybeAddServerPushResources(
     StringPiece request_host,
@@ skipping 31 matching lines @@
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     ServerPushInfo push_resource = it->second;
     if (push_resource.request_url.spec() == resource.request_url.spec()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net