Refactoring: Create per-connection packet writers in QuicDispatcher.

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 <sys/epoll.h>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 143 matching lines @@
                                       congestion_control_tag));
         }
       }
     }
   }
   return params;
 }
 
 class ServerDelegate : public PacketDroppingTestWriter::Delegate {
  public:
-  explicit ServerDelegate(QuicDispatcher* dispatcher)
-      : dispatcher_(dispatcher) {}
+  ServerDelegate(TestWriterFactory* writer_factory,
+                 QuicDispatcher* dispatcher)
+      : writer_factory_(writer_factory),
+        dispatcher_(dispatcher) {}
   virtual ~ServerDelegate() {}
+  virtual void OnPacketSent(WriteResult result) override {
+    writer_factory_->OnPacketSent(result);
+  }
   virtual void OnCanWrite() OVERRIDE { dispatcher_->OnCanWrite(); }
  private:
+  TestWriterFactory* writer_factory_;
   QuicDispatcher* dispatcher_;
 };
 
 class ClientDelegate : public PacketDroppingTestWriter::Delegate {
  public:
   explicit ClientDelegate(QuicClient* client) : client_(client) {}
   virtual ~ClientDelegate() {}
+  virtual void OnPacketSent(WriteResult result) OVERRIDE {}
   virtual void OnCanWrite() OVERRIDE {
     EpollEvent event(EPOLLOUT, false);
     client_->OnEvent(client_->fd(), &event);
   }
  private:
   QuicClient* client_;
 };
 
 class EndToEndTest : public ::testing::TestWithParam<TestParams> {
  protected:
@@ skipping 133 matching lines @@
     client_writer_->Initialize(
         reinterpret_cast<QuicEpollConnectionHelper*>(
             QuicConnectionPeer::GetHelper(
                 client_->client()->session()->connection())),
         new ClientDelegate(client_->client()));
     return client_->client()->connected();
   }
 
   virtual void SetUp() OVERRIDE {
     // The ownership of these gets transferred to the QuicPacketWriterWrapper
-    // and QuicDispatcher when Initialize() is executed.
+    // and TestWriterFactory when Initialize() is executed.
     client_writer_ = new PacketDroppingTestWriter();
     server_writer_ = new PacketDroppingTestWriter();
   }
 
   virtual void TearDown() OVERRIDE {
     StopServer();
   }
 
   void StartServer() {
     server_thread_.reset(
         new ServerThread(
             new QuicServer(server_config_, server_supported_versions_),
             server_address_,
             strike_register_no_startup_period_));
     server_thread_->Initialize();
     server_address_ = IPEndPoint(server_address_.address(),
                                  server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
+    TestWriterFactory* packet_writer_factory = new TestWriterFactory();
+    QuicDispatcherPeer::SetPacketWriterFactory(dispatcher,
+                                               packet_writer_factory);
     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
     server_writer_->Initialize(
         QuicDispatcherPeer::GetHelper(dispatcher),
-        new ServerDelegate(dispatcher));
+        new ServerDelegate(packet_writer_factory, dispatcher));
     server_thread_->Start();
     server_started_ = true;
   }
 
   void StopServer() {
     if (!server_started_)
       return;
     if (server_thread_.get()) {
       server_thread_->Quit();
       server_thread_->Join();
@@ skipping 780 matching lines @@
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
   WrongAddressWriter* writer = new WrongAddressWriter();
 
   writer->set_writer(new QuicDefaultPacketWriter(client_->client()->fd()));
   QuicConnectionPeer::SetWriter(client_->client()->session()->connection(),
                                 writer,
-                                true  /* owns_writer */);
+                                /* owns_writer= */ true);
 
   client_->SendSynchronousRequest("/bar");
 
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 TEST_P(EndToEndTest, ConnectionMigrationClientPortChanged) {
   // Tests that the client's port can change during an established QUIC
   // connection, and that doing so does not result in the connection being
@@ skipping 215 matching lines @@
   QuicSession* session = dispatcher->session_map().begin()->second;
   EXPECT_EQ(0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(
       session).size());
   server_thread_->Resume();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net