Refactor QuicClientSession so that it owns the underlying socket

net/quic/quic_client_session.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/quic/quic_client_session.h"
 
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_stream_factory.h"
 #include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
 QuicClientSession::QuicClientSession(QuicConnection* connection,
-                                     QuicConnectionHelper* helper,
+                                     DatagramClientSocket* socket,
                                      QuicStreamFactory* stream_factory,
                                      const string& server_hostname,
                                      NetLog* net_log)
     : QuicSession(connection, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(crypto_stream_(this, server_hostname)),
-      helper_(helper),
       stream_factory_(stream_factory),
+      socket_(socket),
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
       read_pending_(false),
       num_total_streams_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
       logger_(net_log_) {
   connection->set_debug_visitor(&logger_);
   // TODO(rch): pass in full host port proxy pair
   net_log_.BeginEvent(
       NetLog::TYPE_QUIC_SESSION,
       NetLog::StringCallback("host", &server_hostname));
@@ skipping 63 matching lines @@
   if (!callback_.is_null()) {
     callback_.Run(error == QUIC_NO_ERROR ? OK : ERR_UNEXPECTED);
   }
 }
 
 void QuicClientSession::StartReading() {
   if (read_pending_) {
     return;
   }
   read_pending_ = true;
-  int rv = helper_->Read(read_buffer_, read_buffer_->size(),
+  int rv = socket_->Read(read_buffer_, read_buffer_->size(),
                          base::Bind(&QuicClientSession::OnReadComplete,
                                     weak_factory_.GetWeakPtr()));
   if (rv == ERR_IO_PENDING) {
     return;
   }
 
   // Data was read, process it.
   // Schedule the work through the message loop to avoid recursive
   // callbacks.
   MessageLoop::current()->PostTask(
@@ skipping 28 matching lines @@
 
 void QuicClientSession::OnReadComplete(int result) {
   read_pending_ = false;
   // TODO(rch): Inform the connection about the result.
   if (result > 0) {
     scoped_refptr<IOBufferWithSize> buffer(read_buffer_);
     read_buffer_ = new IOBufferWithSize(kMaxPacketSize);
     QuicEncryptedPacket packet(buffer->data(), result);
     IPEndPoint local_address;
     IPEndPoint peer_address;
-    helper_->GetLocalAddress(&local_address);
-    helper_->GetPeerAddress(&peer_address);
+    socket_->GetLocalAddress(&local_address);
+    socket_->GetPeerAddress(&peer_address);
     // ProcessUdpPacket might result in |this| being deleted, so we
     // use a weak pointer to be safe.
     connection()->ProcessUdpPacket(local_address, peer_address, packet);
     if (!connection()->connected()) {
       stream_factory_->OnSessionClose(this);
       return;
     }
     StartReading();
   }
 }
 
 }  // namespace net