Factor out ServerThread from the QUIC EndToEndTest in order to reuse in

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/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 
 using base::FilePath;
 using base::StringPiece;
 using std::string;
 
 // Specifies the directory used during QuicInMemoryCache
 // construction to seed the cache. Cache directory can be
 // generated using `wget -p --save-headers <url>
 
 namespace net {
@@ skipping 66 matching lines @@
 
 const QuicInMemoryCache::Response* QuicInMemoryCache::GetResponse(
     const BalsaHeaders& request_headers) const {
   ResponseMap::const_iterator it = responses_.find(GetKey(request_headers));
   if (it == responses_.end()) {
     return NULL;
   }
   return it->second;
 }
 
+void QuicInMemoryCache::AddOrVerifyResponse(StringPiece method,
+                                            StringPiece path,
+                                            StringPiece version,
+                                            StringPiece response_code,
+                                            StringPiece response_detail,
+                                            StringPiece body) {
+  BalsaHeaders request_headers, response_headers;
+  request_headers.SetRequestFirstlineFromStringPieces(method,
+                                                      path,
+                                                      version);
+  response_headers.SetRequestFirstlineFromStringPieces(version,
+                                                       response_code,
+                                                       response_detail);
+  response_headers.AppendHeader("content-length",
+                                base::IntToString(body.length()));
+
+  // Check if response already exists and matches.
+  const QuicInMemoryCache::Response* cached_response =
+      GetResponse(request_headers);
+  if (cached_response == NULL) {
+    AddResponse(request_headers, response_headers, body);
+    return;
+  }
+  string cached_response_headers_str, response_headers_str;
+  cached_response->headers().DumpToString(&cached_response_headers_str);
+  response_headers.DumpToString(&response_headers_str);
+  CHECK_EQ(cached_response_headers_str, response_headers_str);
+  CHECK_EQ(cached_response->body(), body);
+}
+
 void QuicInMemoryCache::AddResponse(const BalsaHeaders& request_headers,
                                     const BalsaHeaders& response_headers,
                                     StringPiece response_body) {
   LOG(INFO) << "Adding response for: " << GetKey(request_headers);
   if (ContainsKey(responses_, GetKey(request_headers))) {
     LOG(DFATAL) << "Response for given request already exists!";
   }
   Response* new_response = new Response();
   new_response->set_headers(response_headers);
   new_response->set_body(response_body);
@@ skipping 110 matching lines @@
   } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "https://")) {
     uri.remove_prefix(8);
   } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "http://")) {
     uri.remove_prefix(7);
   }
   return host.as_string() + uri.as_string();
 }
 
 }  // namespace tools
 }  // namespace net