Update QuicTransportChannel to latest version of libquic

webrtc/p2p/quic/reliablequicstream_unittest.cc

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/p2p/quic/reliablequicstream.h"
 
 #include <string>
 
 #include "net/base/ip_address_number.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_session.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/p2p/quic/quicconnectionhelper.h"
 
 using cricket::QuicConnectionHelper;
 using cricket::ReliableQuicStream;
 
 using net::FecProtection;
-using net::IPAddressNumber;
+using net::IPAddress;
 using net::IPEndPoint;
+using net::PerPacketOptions;
 using net::Perspective;
 using net::QuicAckListenerInterface;
 using net::QuicConfig;
 using net::QuicConnection;
 using net::QuicConsumedData;
 using net::QuicCryptoStream;
 using net::QuicErrorCode;
 using net::QuicIOVector;
 using net::QuicPacketWriter;
 using net::QuicRstStreamErrorCode;
 using net::QuicSession;
 using net::QuicStreamId;
 using net::QuicStreamOffset;
 using net::SpdyPriority;
 
 using rtc::SR_SUCCESS;
 using rtc::SR_BLOCK;
 
+// Arbitrary number for a stream's write blocked priority.
+static const SpdyPriority kDefaultPriority = 3;
+
 // QuicSession that does not create streams and writes data from
 // ReliableQuicStream to a string.
 class MockQuicSession : public QuicSession {
  public:
   MockQuicSession(QuicConnection* connection,
                   const QuicConfig& config,
                   std::string* write_buffer)
       : QuicSession(connection, config), write_buffer_(write_buffer) {}
 
   // Writes outgoing data from ReliableQuicStream to a string.
@@ skipping 49 matching lines @@
 
 // Packet writer that does nothing. This is required for QuicConnection but
 // isn't used for writing data.
 class DummyPacketWriter : public QuicPacketWriter {
  public:
   DummyPacketWriter() {}
 
   // QuicPacketWriter overrides.
   virtual net::WriteResult WritePacket(const char* buffer,
                                        size_t buf_len,
-                                       const IPAddressNumber& self_address,
-                                       const IPEndPoint& peer_address) {
+                                       const IPAddress& self_address,
+                                       const IPEndPoint& peer_address,
+                                       PerPacketOptions* options) {
     return net::WriteResult(net::WRITE_STATUS_ERROR, 0);
   }
 
   bool IsWriteBlockedDataBuffered() const override { return false; }
 
   bool IsWriteBlocked() const override { return false; };
 
   void SetWritable() override {}
 
   net::QuicByteCount GetMaxPacketSize(
       const net::IPEndPoint& peer_address) const override {
     return 0;
   }
 };
 
-// QuicPacketWriter is not necessary, so this creates a packet writer that
-// doesn't do anything.
-class DummyPacketWriterFactory : public QuicConnection::PacketWriterFactory {
- public:
-  DummyPacketWriterFactory() {}
-
-  QuicPacketWriter* Create(QuicConnection* connection) const override {
-    return new DummyPacketWriter();
-  }
-};
-
 class ReliableQuicStreamTest : public ::testing::Test,
                                public sigslot::has_slots<> {
  public:
   ReliableQuicStreamTest() {}
 
   void CreateReliableQuicStream() {
     const net::QuicStreamId kStreamId = 5;
 
     // Arbitrary values for QuicConnection.
     QuicConnectionHelper* quic_helper =
         new QuicConnectionHelper(rtc::Thread::Current());
     Perspective perspective = Perspective::IS_SERVER;
-    net::IPAddressNumber ip(net::kIPv4AddressSize, 0);
+    net::IPAddress ip(0, 0, 0, 0);
 
-    bool owns_writer = false;
+    bool owns_writer = true;
 
     QuicConnection* connection = new QuicConnection(
-        0, IPEndPoint(ip, 0), quic_helper, DummyPacketWriterFactory(),
-        owns_writer, perspective, net::QuicSupportedVersions());
+        0, IPEndPoint(ip, 0), quic_helper, new DummyPacketWriter(), owns_writer,
+        perspective, net::QuicSupportedVersions());
 
     session_.reset(
         new MockQuicSession(connection, QuicConfig(), &write_buffer_));
     stream_.reset(new ReliableQuicStream(kStreamId, session_.get()));
     stream_->SignalDataReceived.connect(
         this, &ReliableQuicStreamTest::OnDataReceived);
     stream_->SignalClosed.connect(this, &ReliableQuicStreamTest::OnClosed);
 
-    session_->register_write_blocked_stream(stream_->id(), stream_->Priority());
+    session_->register_write_blocked_stream(stream_->id(), kDefaultPriority);
   }
 
   void OnDataReceived(QuicStreamId id, const char* data, size_t length) {
     ASSERT_EQ(id, stream_->id());
     read_buffer_.append(data, length);
   }
 
   void OnClosed(QuicStreamId id, QuicErrorCode err) { closed_ = true; }
 
  protected:
-  scoped_ptr<ReliableQuicStream> stream_;
-  scoped_ptr<MockQuicSession> session_;
+  rtc::scoped_ptr<ReliableQuicStream> stream_;
+  rtc::scoped_ptr<MockQuicSession> session_;
 
   // Data written by the ReliableQuicStream.
   std::string write_buffer_;
   // Data read by the ReliableQuicStream.
   std::string read_buffer_;
   // Whether the ReliableQuicStream is closed.
   bool closed_ = false;
 };
 
 // Write an entire string.
@@ skipping 50 matching lines @@
   EXPECT_EQ("Hello", read_buffer_);
 }
 
 // Test that closing the stream results in a callback.
 TEST_F(ReliableQuicStreamTest, CloseStream) {
   CreateReliableQuicStream();
   EXPECT_FALSE(closed_);
   stream_->OnClose();
   EXPECT_TRUE(closed_);
 }