Implement QuicChannel and QuicChannelFactory

net/quic/p2p/quic_p2p_session_test.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 "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
@@ skipping 13 matching lines @@
 
 namespace {
 
 const char kTestSharedKey[] = "Shared key exchanged out of bound.";
 
 class FakeP2PDatagramSocket : public Socket {
  public:
   FakeP2PDatagramSocket() : weak_factory_(this) {}
   ~FakeP2PDatagramSocket() override {}
 
+  base::WeakPtr<FakeP2PDatagramSocket> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
   void ConnectWith(FakeP2PDatagramSocket* peer_socket) {
-    peer_socket_ = peer_socket->weak_factory_.GetWeakPtr();
-    peer_socket->peer_socket_ = weak_factory_.GetWeakPtr();
+    peer_socket_ = peer_socket->GetWeakPtr();
+    peer_socket->peer_socket_ = GetWeakPtr();
   }
 
   void SetReadError(int error) {
     read_error_ = error;
     if (!read_callback_.is_null()) {
       base::ResetAndReturn(&read_callback_).Run(error);
     }
   }
 
   void SetWriteError(int error) { write_error_ = error; }
@@ skipping 162 matching lines @@
                      net::QuicRandom::GetInstance()) {
     // Simulate out-of-bound config handshake.
     CryptoHandshakeMessage hello_message;
     config_.ToHandshakeMessage(&hello_message);
     std::string error_detail;
     EXPECT_EQ(QUIC_NO_ERROR,
               config_.ProcessPeerHello(hello_message, CLIENT, &error_detail));
   }
 
   void CreateSessions() {
-    socket1_ = new FakeP2PDatagramSocket();
-    socket2_ = new FakeP2PDatagramSocket();
-    socket1_->ConnectWith(socket2_);
+    scoped_ptr<FakeP2PDatagramSocket> socket1(new FakeP2PDatagramSocket());
+    scoped_ptr<FakeP2PDatagramSocket> socket2(new FakeP2PDatagramSocket());
+    socket1->ConnectWith(socket2.get());
+
+    socket1_ = socket1->GetWeakPtr();
+    socket2_ = socket2->GetWeakPtr();
 
     QuicP2PCryptoConfig crypto_config(kTestSharedKey);
 
-    session1_ = CreateP2PSession(make_scoped_ptr(socket1_), crypto_config,
-                                 Perspective::IS_SERVER);
-    session2_ = CreateP2PSession(make_scoped_ptr(socket2_), crypto_config,
-                                 Perspective::IS_CLIENT);
+    session1_ =
+        CreateP2PSession(socket1.Pass(), crypto_config, Perspective::IS_SERVER);
+    session2_ =
+        CreateP2PSession(socket2.Pass(), crypto_config, Perspective::IS_CLIENT);
   }
 
   scoped_ptr<QuicP2PSession> CreateP2PSession(scoped_ptr<Socket> socket,
                                               QuicP2PCryptoConfig crypto_config,
                                               Perspective perspective) {
     DefaultPacketWriterFactory writer_factory(socket.get());
     net::IPAddressNumber ip(net::kIPv4AddressSize, 0);
     scoped_ptr<QuicConnection> quic_connection1(
         new QuicConnection(0, net::IPEndPoint(ip, 0), &quic_helper_,
                            writer_factory, true /* owns_writer */, perspective,
                            true /* is_secuire */, QuicSupportedVersions()));
 
     scoped_ptr<QuicP2PSession> result(new QuicP2PSession(
         config_, crypto_config, quic_connection1.Pass(), socket.Pass()));
     result->Initialize();
     return result.Pass();
   }
 
   void TestStreamConnection(QuicP2PSession* from_session,
                             QuicP2PSession* to_session,
                             QuicStreamId expected_stream_id);
 
   QuicClock quic_clock_;
   QuicConnectionHelper quic_helper_;
   QuicConfig config_;
 
-  FakeP2PDatagramSocket* socket1_;
+  base::WeakPtr<FakeP2PDatagramSocket> socket1_;
   scoped_ptr<QuicP2PSession> session1_;
 
-  FakeP2PDatagramSocket* socket2_;
+  base::WeakPtr<FakeP2PDatagramSocket> socket2_;
   scoped_ptr<QuicP2PSession> session2_;
 };
 
 void QuicP2PSessionTest::OnWriteResult(int result) {
   EXPECT_EQ(OK, result);
 }
 
 void QuicP2PSessionTest::TestStreamConnection(QuicP2PSession* from_session,
                                               QuicP2PSession* to_session,
                                               QuicStreamId expected_stream_id) {
@@ skipping 42 matching lines @@
 TEST_F(QuicP2PSessionTest, ClientToServer) {
   CreateSessions();
   TestStreamConnection(session2_.get(), session1_.get(), 3);
 }
 
 TEST_F(QuicP2PSessionTest, ServerToClient) {
   CreateSessions();
   TestStreamConnection(session1_.get(), session2_.get(), 2);
 }
 
+TEST_F(QuicP2PSessionTest, DestroySocketWhenClosed) {
+  CreateSessions();
+
+  // The socket must be destroyed when connection is closed.
+  EXPECT_TRUE(socket1_);
+  session1_->connection()->CloseConnection(net::QUIC_NO_ERROR, false);
+  EXPECT_FALSE(socket1_);
+}
+
 TEST_F(QuicP2PSessionTest, TransportWriteError) {
   CreateSessions();
 
   TestP2PSessionDelegate session_delegate;
   session1_->SetDelegate(&session_delegate);
 
   QuicP2PStream* stream = session1_->CreateOutgoingDynamicStream();
   EXPECT_TRUE(stream);
   TestP2PStreamDelegate stream_delegate;
   stream->SetDelegate(&stream_delegate);
   EXPECT_EQ(2U, stream->id());
 
   socket1_->SetWriteError(ERR_INTERNET_DISCONNECTED);
 
   const char kTestMessage[] = "Hi";
   stream->Write(
       std::string(kTestMessage),
       base::Bind(&QuicP2PSessionTest::OnWriteResult, base::Unretained(this)));
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(stream_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_WRITE_ERROR, stream_delegate.error());
   EXPECT_TRUE(session_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_WRITE_ERROR, session_delegate.error());
+
+  // Verify that the socket was destroyed.
+  EXPECT_FALSE(socket1_);
 }
 
 TEST_F(QuicP2PSessionTest, TransportReceiveError) {
   CreateSessions();
 
   TestP2PSessionDelegate session_delegate;
   session1_->SetDelegate(&session_delegate);
 
   QuicP2PStream* stream = session1_->CreateOutgoingDynamicStream();
   EXPECT_TRUE(stream);
   TestP2PStreamDelegate stream_delegate;
   stream->SetDelegate(&stream_delegate);
   EXPECT_EQ(2U, stream->id());
 
   socket1_->SetReadError(ERR_INTERNET_DISCONNECTED);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(stream_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_READ_ERROR, stream_delegate.error());
   EXPECT_TRUE(session_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_READ_ERROR, session_delegate.error());
+
+  // Verify that the socket was destroyed.
+  EXPECT_FALSE(socket1_);
 }
 
 }  // namespace net