Flatten GeneralLossAlgorithm into QuicSentPacketManager. Not flag protected.

net/quic/core/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/core/quic_sent_packet_manager.h"
 
 #include <memory>
-
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::vector;
 using testing::AnyNumber;
@@ skipping 508 matching lines @@
   ExpectAckAndLoss(true, 5, 2);
   EXPECT_CALL(debug_delegate, OnPacketLoss(2, LOSS_RETRANSMISSION, _));
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   VerifyUnackedPackets(nullptr, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_P(QuicSentPacketManagerTest, AckOriginalTransmission) {
-  MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm();
-  QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm);
+  auto loss_algorithm = base::MakeUnique<MockLossAlgorithm>();
+  QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
 
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
 
   // Ack original transmission, but that wasn't lost via fast retransmit,
   // so no call on OnSpuriousRetransmission is expected.
   {
     QuicAckFrame ack_frame = InitAckFrame(1);
     ExpectAck(1);
     EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _));
@@ skipping 790 matching lines @@
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(delay,
               QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
     delay = delay + delay;
     manager_.OnRetransmissionTimeout();
     RetransmitNextPacket(i + 2);
   }
 }
 
 TEST_P(QuicSentPacketManagerTest, GetLossDelay) {
-  MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm();
-  QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm);
+  auto loss_algorithm = base::MakeUnique<MockLossAlgorithm>();
+  QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
 
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillRepeatedly(Return(QuicTime::Zero()));
   SendDataPacket(1);
   SendDataPacket(2);
 
   // Handle an ack which causes the loss algorithm to be evaluated and
   // set the loss timeout.
   ExpectAck(2);
   EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _));
@@ skipping 202 matching lines @@
   // Send 5 packets, mark the first 4 for retransmission, and then cancel
   // them when 1 is acked.
   EXPECT_CALL(*send_algorithm_, PacingRate(_))
       .WillRepeatedly(Return(QuicBandwidth::Zero()));
   EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
       .WillOnce(Return(10 * kDefaultTCPMSS));
   const size_t kNumSentPackets = 5;
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
-  MockLossAlgorithm* loss_algorithm = new MockLossAlgorithm();
-  QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm);
+  auto loss_algorithm = base::MakeUnique<MockLossAlgorithm>();
+  QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
   EXPECT_CALL(*network_change_visitor_, OnCongestionChange());
   SendAlgorithmInterface::CongestionVector lost_packets;
   for (size_t i = 1; i < kNumSentPackets; ++i) {
     lost_packets.push_back(std::make_pair(i, kMaxPacketSize));
   }
   EXPECT_CALL(*loss_algorithm, DetectLosses(_, _, _, _, _))
       .WillOnce(SetArgPointee<4>(lost_packets));
   QuicAckFrame ack_frame = InitAckFrame(kNumSentPackets);
   NackPackets(1, kNumSentPackets, &ack_frame);
@@ skipping 125 matching lines @@
   ExpectAck(1);
   EXPECT_CALL(*network_change_visitor_,
               OnPathMtuIncreased(kDefaultLength + 100));
   QuicAckFrame ack_frame = InitAckFrame(1);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net