Implement QuicChannel and QuicChannelFactory

net/quic/p2p/quic_p2p_session.cc

 // Copyright 2015 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/p2p/quic_p2p_session.h"
 
 #include "base/callback_helpers.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/p2p/quic_p2p_crypto_stream.h"
@@ skipping 49 matching lines @@
   QuicP2PStream* stream = new QuicP2PStream(GetNextStreamId(), this);
   if (stream) {
     ActivateStream(stream);
   }
   return stream;
 }
 
 void QuicP2PSession::OnConnectionClosed(QuicErrorCode error, bool from_peer) {
   QuicSession::OnConnectionClosed(error, from_peer);
 
+  socket_.reset();
+
   if (delegate_) {
     Delegate* delegate = delegate_;
     delegate_ = nullptr;
     delegate->OnConnectionClosed(error);
   }
 }
 
 void QuicP2PSession::DoReadLoop(int result) {
   while (error() == net::QUIC_NO_ERROR) {
     switch (read_state_) {
@@ skipping 11 matching lines @@
 
     if (result < 0)
       break;
   }
 }
 
 int QuicP2PSession::DoRead() {
   DCHECK_EQ(read_state_, READ_STATE_DO_READ);
   read_state_ = READ_STATE_DO_READ_COMPLETE;
 
+  if (!socket_) {
+    return net::ERR_SOCKET_NOT_CONNECTED;
+  }
+
   return socket_->Read(
       read_buffer_.get(), kMaxPacketSize,
       base::Bind(&QuicP2PSession::DoReadLoop, base::Unretained(this)));
 }
 
 int QuicP2PSession::DoReadComplete(int result) {
   DCHECK_EQ(read_state_, READ_STATE_DO_READ_COMPLETE);
   read_state_ = READ_STATE_DO_READ;
 
   if (result <= 0) {
     connection()->CloseConnection(net::QUIC_PACKET_READ_ERROR, false);
     return result;
   }
 
   QuicEncryptedPacket packet(read_buffer_->data(), result);
   connection()->ProcessUdpPacket(connection()->self_address(),
                                  connection()->peer_address(), packet);
   return OK;
 }
 
 }  // namespace net