Land Recent QUIC Changes.

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"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_sent_packet_manager.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
-#include "net/quic/test_tools/quic_test_writer.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
+#include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_server.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/http_message_test_utils.h"
 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
 #include "net/tools/quic/test_tools/quic_server_peer.h"
 #include "net/tools/quic/test_tools/quic_test_client.h"
 #include "net/tools/quic/test_tools/server_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using base::WaitableEvent;
 using net::test::QuicConnectionPeer;
 using net::test::QuicSessionPeer;
-using net::test::QuicTestWriter;
 using net::test::ReliableQuicStreamPeer;
 using net::tools::test::PacketDroppingTestWriter;
 using net::tools::test::QuicDispatcherPeer;
 using net::tools::test::QuicServerPeer;
 using std::ostream;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
@@ skipping 116 matching lines @@
     AddToCache("GET", "https://www.google.com/bar",
                "HTTP/1.1", "200", "OK", kBarResponseBody);
   }
 
   virtual ~EndToEndTest() {
     // TODO(rtenneti): port RecycleUnusedPort if needed.
     // RecycleUnusedPort(server_address_.port());
     QuicInMemoryCachePeer::ResetForTests();
   }
 
-  virtual QuicTestClient* CreateQuicClient(QuicTestWriter* writer) {
+  virtual QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
     QuicTestClient* client = new QuicTestClient(server_address_,
                                                 server_hostname_,
                                                 false,  // not secure
                                                 client_config_,
                                                 client_supported_versions_);
     client->UseWriter(writer);
     client->Connect();
     return client;
   }
 
   virtual bool Initialize() {
     // Start the server first, because CreateQuicClient() attempts
     // to connect to the server.
     StartServer();
     client_.reset(CreateQuicClient(client_writer_));
     QuicEpollConnectionHelper* helper =
         reinterpret_cast<QuicEpollConnectionHelper*>(
             QuicConnectionPeer::GetHelper(
                 client_->client()->session()->connection()));
     client_writer_->SetConnectionHelper(helper);
     return client_->client()->connected();
   }
 
   virtual void SetUp() {
-    // The ownership of these gets transferred to the QuicTestWriter and
-    // QuicDispatcher when Initialize() is executed.
+    // The ownership of these gets transferred to the QuicPacketWriterWrapper
+    // and QuicDispatcher when Initialize() is executed.
     client_writer_ = new PacketDroppingTestWriter();
     server_writer_ = new PacketDroppingTestWriter();
   }
 
   virtual void TearDown() {
     StopServer();
   }
 
   void StartServer() {
     server_thread_.reset(new ServerThread(server_address_, server_config_,
@@ skipping 590 matching lines @@
     // received for that stream.
     EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
   } else {
     // Check that the connection is always properly closed
     // from a stream being RST before headers are decompressed.
     EXPECT_EQ(QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED,
               client_->connection_error());
   }
 }
 
-class WrongAddressWriter : public QuicTestWriter {
+class WrongAddressWriter : public QuicPacketWriterWrapper {
  public:
   WrongAddressWriter() {
     IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.2", &ip));
     self_address_ = IPEndPoint(ip, 0);
   }
 
   virtual WriteResult WritePacket(
-      const char* buffer, size_t buf_len,
+      const char* buffer,
+      size_t buf_len,
       const IPAddressNumber& real_self_address,
       const IPEndPoint& peer_address,
       QuicBlockedWriterInterface* blocked_writer) OVERRIDE {
-    return writer()->WritePacket(buffer, buf_len, self_address_.address(),
-                                 peer_address, blocked_writer);
+    // Use wrong address!
+    return QuicPacketWriterWrapper::WritePacket(
+        buffer, buf_len, self_address_.address(), peer_address, blocked_writer);
   }
 
   virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
     return false;
   }
 
   IPEndPoint self_address_;
 };
 
 TEST_P(EndToEndTest, ConnectionMigration) {
@@ skipping 12 matching lines @@
   client_->SendSynchronousRequest("/bar");
 
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net