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

net/tools/quic/end_to_end_test.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 <stddef.h>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 194 matching lines @@
     client_config_.SetInitialStreamFlowControlWindowToSend(
         2 * kInitialStreamFlowControlWindowForTest);
     client_config_.SetInitialSessionFlowControlWindowToSend(
         2 * kInitialSessionFlowControlWindowForTest);
     server_config_.SetInitialStreamFlowControlWindowToSend(
         3 * kInitialStreamFlowControlWindowForTest);
     server_config_.SetInitialSessionFlowControlWindowToSend(
         3 * kInitialSessionFlowControlWindowForTest);
 
     QuicInMemoryCachePeer::ResetForTests();
-    AddToCache("GET", "https://www.google.com/foo",
-               "HTTP/1.1", "200", "OK", kFooResponseBody);
-    AddToCache("GET", "https://www.google.com/bar",
-               "HTTP/1.1", "200", "OK", kBarResponseBody);
+    AddToCache("/foo", 200, "OK", kFooResponseBody);
+    AddToCache("/bar", 200, "OK", kBarResponseBody);
   }
 
   ~EndToEndTest() override {
     // TODO(rtenneti): port RecycleUnusedPort if needed.
     // RecycleUnusedPort(server_address_.port());
     QuicInMemoryCachePeer::ResetForTests();
   }
 
   QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
     QuicTestClient* client = new QuicTestClient(
@@ skipping 107 matching lines @@
 
   void StopServer() {
     if (!server_started_)
       return;
     if (server_thread_.get()) {
       server_thread_->Quit();
       server_thread_->Join();
     }
   }
 
-  void AddToCache(StringPiece method,
-                  StringPiece path,
-                  StringPiece version,
-                  StringPiece response_code,
+  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);
   }
 
   void SetPacketLossPercentage(int32 loss) {
     // TODO(rtenneti): enable when we can do random packet loss tests in
     // chrome's tree.
     if (loss != 0 && loss != 100)
       return;
     client_writer_->set_fake_packet_loss_percentage(loss);
     server_writer_->set_fake_packet_loss_percentage(loss);
   }
@@ skipping 131 matching lines @@
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
   client2->SendData("eep", true);
   client2->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client2->response_body());
   EXPECT_EQ(200u, client2->response_headers()->parsed_response_code());
 }
 
 TEST_P(EndToEndTest, RequestOverMultiplePackets) {
   // Send a large enough request to guarantee fragmentation.
-  string huge_request =
-      "https://www.google.com/some/path?query=" + string(kMaxPacketSize, '.');
-  AddToCache("GET", huge_request, "HTTP/1.1", "200", "OK", kBarResponseBody);
+  string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.');
+  AddToCache(huge_request, 200, "OK", kBarResponseBody);
 
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_P(EndToEndTest, MultiplePacketsRandomOrder) {
   // Send a large enough request to guarantee fragmentation.
-  string huge_request =
-      "https://www.google.com/some/path?query=" + string(kMaxPacketSize, '.');
-  AddToCache("GET", huge_request, "HTTP/1.1", "200", "OK", kBarResponseBody);
+  string huge_request = "/some/path?query=" + string(kMaxPacketSize, '.');
+  AddToCache(huge_request, 200, "OK", kBarResponseBody);
 
   ASSERT_TRUE(Initialize());
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(50);
 
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_P(EndToEndTest, PostMissingBytes) {
@@ skipping 531 matching lines @@
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 TEST_P(EndToEndTest, MaxStreamsUberTest) {
   SetPacketLossPercentage(1);
   ASSERT_TRUE(Initialize());
   string large_body;
   GenerateBody(&large_body, 10240);
   int max_streams = 100;
 
-  AddToCache("GET", "/large_response", "HTTP/1.1", "200", "OK", large_body);;
+  AddToCache("/large_response", 200, "OK", large_body);;
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
   SetPacketLossPercentage(10);
 
   for (int i = 0; i < max_streams; ++i) {
     EXPECT_LT(0, client_->SendRequest("/large_response"));
   }
 
   // WaitForEvents waits 50ms and returns true if there are outstanding
   // requests.
   while (client_->client()->WaitForEvents() == true) {
   }
 }
 
 TEST_P(EndToEndTest, StreamCancelErrorTest) {
   ASSERT_TRUE(Initialize());
   string small_body;
   GenerateBody(&small_body, 256);
 
-  AddToCache("GET", "/small_response", "HTTP/1.1", "200", "OK", small_body);
+  AddToCache("/small_response", 200, "OK", small_body);
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   QuicSession* session = client_->client()->session();
   // Lose the request.
   SetPacketLossPercentage(100);
   EXPECT_LT(0, client_->SendRequest("/small_response"));
   client_->client()->WaitForEvents();
   // Transmit the cancel, and ensure the connection is torn down properly.
   SetPacketLossPercentage(0);
@@ skipping 297 matching lines @@
     // Waits for up to 50 ms.
     client_->client()->WaitForEvents();
   }
   server_thread_->Resume();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net