Make some changes to the QuicInMemory server to clarify the interface.

net/quic/quic_end_to_end_unittest.cc

 // Copyright 2013 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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/elements_upload_data_stream.h"
@@ skipping 140 matching lines @@
       return;
     }
     if (server_thread_.get()) {
       server_thread_->Quit();
       server_thread_->Join();
     }
   }
 
   // Adds an entry to the cache used by the QUIC server to serve
   // responses.
-  void AddToCache(const StringPiece& method,
-                  const StringPiece& path,
-                  const StringPiece& version,
-                  const StringPiece& response_code,
-                  const StringPiece& response_detail,
-                  const StringPiece& body) {
+  void AddToCache(StringPiece path,
+                  int response_code,
+                  StringPiece response_detail,
+                  StringPiece body) {
     QuicInMemoryCache::GetInstance()->AddSimpleResponse(
-        method, path, version, response_code, response_detail, body);
+        "www.google.com", path, response_code, response_detail, body);
   }
 
   // Populates |request_body_| with |length_| ASCII bytes.
   void GenerateBody(size_t length) {
     request_body_.clear();
     request_body_.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       request_body_.append(1, static_cast<char>(32 + i % (126 - 32)));
     }
   }
@@ skipping 41 matching lines @@
   IPEndPoint server_address_;
   std::string server_hostname_;
   QuicConfig server_config_;
   bool server_started_;
   bool strike_register_no_startup_period_;
 };
 
 TEST_F(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
   std::string response(10 * 1024, 'x');
 
-  AddToCache("GET", request_.url.spec(),
-             "HTTP/1.1", "200", "OK",
-             response);
+  AddToCache(request_.url.PathForRequest(), 200, "OK", response);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
   consumer.Start(&request_, BoundNetLog());
 
   // Will terminate when the last consumer completes.
   base::MessageLoop::current()->Run();
 
   CheckResponse(consumer, "HTTP/1.1 200 OK", response);
 }
 
 // http://crbug.com/307284
 TEST_F(QuicEndToEndTest, DISABLED_LargePostWithNoPacketLoss) {
   InitializePostRequest(10 * 1024 * 1024);
 
-  AddToCache("POST", request_.url.spec(),
-             "HTTP/1.1", "200", "OK",
-             kResponseBody);
+  AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
   consumer.Start(&request_, BoundNetLog());
 
   // Will terminate when the last consumer completes.
   base::MessageLoop::current()->Run();
 
   CheckResponse(consumer, "HTTP/1.1 200 OK", kResponseBody);
 }
 
 TEST_F(QuicEndToEndTest, LargePostWithPacketLoss) {
   // FLAGS_fake_packet_loss_percentage = 30;
   InitializePostRequest(1024 * 1024);
 
   const char kResponseBody[] = "some really big response body";
-  AddToCache("POST", request_.url.spec(),
-             "HTTP/1.1", "200", "OK",
-             kResponseBody);
+  AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
   consumer.Start(&request_, BoundNetLog());
 
   // Will terminate when the last consumer completes.
   base::MessageLoop::current()->Run();
 
   CheckResponse(consumer, "HTTP/1.1 200 OK", kResponseBody);
 }
 
 TEST_F(QuicEndToEndTest, UberTest) {
   // FLAGS_fake_packet_loss_percentage = 30;
 
   const char kResponseBody[] = "some really big response body";
-  AddToCache("GET", request_.url.spec(),
-             "HTTP/1.1", "200", "OK",
-             kResponseBody);
+  AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   std::vector<TestTransactionConsumer*> consumers;
   size_t num_requests = 100;
   for (size_t i = 0; i < num_requests; ++i) {
       TestTransactionConsumer* consumer =
           new TestTransactionConsumer(DEFAULT_PRIORITY,
                                       transaction_factory_.get());
       consumers.push_back(consumer);
       consumer->Start(&request_, BoundNetLog());
   }
 
   // Will terminate when the last consumer completes.
   base::MessageLoop::current()->Run();
 
   for (size_t i = 0; i < num_requests; ++i) {
     CheckResponse(*consumers[i], "HTTP/1.1 200 OK", kResponseBody);
   }
   STLDeleteElements(&consumers);
 }
 
 }  // namespace test
 }  // namespace net