Update from https://crrev.com/316786

net/quic/quic_sent_packet_manager_test.cc

 // Copyright 2013 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_sent_packet_manager.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
@@ skipping 158 matching lines @@
     EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
         &manager_, new_sequence_number));
   }
 
   SerializedPacket CreateDataPacket(QuicPacketSequenceNumber sequence_number) {
     return CreatePacket(sequence_number, true);
   }
 
   SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
                                 bool retransmittable) {
-    packets_.push_back(QuicPacket::NewDataPacket(
-        nullptr, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
-        PACKET_6BYTE_SEQUENCE_NUMBER));
+    packets_.push_back(new QuicEncryptedPacket(nullptr, kDefaultLength));
     return SerializedPacket(
         sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER, packets_.back(), 0u,
         retransmittable ? new RetransmittableFrames() : nullptr);
   }
 
   SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
-    packets_.push_back(QuicPacket::NewFecPacket(
-        nullptr, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
-        PACKET_6BYTE_SEQUENCE_NUMBER));
-    return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
-                            packets_.back(), 0u, nullptr);
+    packets_.push_back(new QuicEncryptedPacket(nullptr, kDefaultLength));
+    SerializedPacket serialized(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
+                                packets_.back(), 0u, nullptr);
+    serialized.is_fec_packet = true;
+    return serialized;
   }
 
   void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
     EXPECT_CALL(*send_algorithm_,
                 OnPacketSent(_, BytesInFlight(), sequence_number, _, _))
                     .Times(1).WillOnce(Return(true));
     SerializedPacket packet(CreateDataPacket(sequence_number));
     manager_.OnPacketSent(&packet, 0, clock_.Now(),
                           packet.packet->length(), NOT_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA);
@@ skipping 46 matching lines @@
     const QuicSentPacketManager::PendingRetransmission pending =
         manager_.NextPendingRetransmission();
     SerializedPacket packet(
         CreatePacket(retransmission_sequence_number, false));
     manager_.OnPacketSent(&packet, pending.sequence_number, clock_.Now(),
                           kDefaultLength, pending.transmission_type,
                           HAS_RETRANSMITTABLE_DATA);
   }
 
   QuicSentPacketManager manager_;
-  vector<QuicPacket*> packets_;
+  vector<QuicEncryptedPacket*> packets_;
   MockClock clock_;
   QuicConnectionStats stats_;
   MockSendAlgorithm* send_algorithm_;
   scoped_ptr<MockNetworkChangeVisitor> network_change_visitor_;
 };
 
 TEST_F(QuicSentPacketManagerTest, IsUnacked) {
   VerifyUnackedPackets(nullptr, 0);
   SendDataPacket(1);
 
@@ skipping 879 matching lines @@
 TEST_F(QuicSentPacketManagerTest, NewRetransmissionTimeout) {
   ValueRestore<bool> old_flag(&FLAGS_quic_use_new_rto, true);
   QuicConfig client_config;
   QuicTagVector options;
   options.push_back(kNRTO);
   QuicSentPacketManagerPeer::SetIsServer(&manager_, false);
   client_config.SetConnectionOptionsToSend(options);
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _, _));
+  EXPECT_CALL(*send_algorithm_, PacingRate())
+      .WillRepeatedly(Return(QuicBandwidth::Zero()));
   manager_.SetFromConfig(client_config);
   EXPECT_TRUE(QuicSentPacketManagerPeer::GetUseNewRto(&manager_));
 
   // Send 100 packets.
   const size_t kNumSentPackets = 100;
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
@@ skipping 547 matching lines @@
 }
 
 TEST_F(QuicSentPacketManagerTest, NegotiateReceiveWindowFromOptions) {
   EXPECT_EQ(kDefaultSocketReceiveBuffer,
             QuicSentPacketManagerPeer::GetReceiveWindow(&manager_));
 
   // Try to set a size below the minimum and ensure it gets set to the min.
   QuicConfig client_config;
   QuicConfigPeer::SetReceivedSocketReceiveBuffer(&client_config, 1024);
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _, _));
+  EXPECT_CALL(*send_algorithm_, PacingRate())
+      .WillRepeatedly(Return(QuicBandwidth::Zero()));
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
   manager_.SetFromConfig(client_config);
 
   EXPECT_EQ(kMinSocketReceiveBuffer,
             QuicSentPacketManagerPeer::GetReceiveWindow(&manager_));
 
   // Ensure the smaller send window only allows 16 packets to be sent.
   for (QuicPacketSequenceNumber i = 1; i <= 16; ++i) {
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
@@ skipping 57 matching lines @@
 
   EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_));
   manager_.ResumeConnectionState(cached_network_params);
   EXPECT_EQ(kRttMs * kNumMicrosPerMilli,
             static_cast<uint64>(manager_.GetRttStats()->initial_rtt_us()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net