Remove QUIC's ReceiveAlgorithmInterface now that it does nothing.

net/quic/congestion_control/tcp_cubic_sender_test.cc

 // Copyright (c) 2012 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 <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
-#include "net/quic/congestion_control/tcp_receiver.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::make_pair;
 using std::min;
 
 namespace net {
@@ skipping 36 matching lines @@
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
 };
 
 class TcpCubicSenderTest : public ::testing::Test {
  protected:
   TcpCubicSenderTest()
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
         sender_(new TcpCubicSenderPeer(&clock_, true,
                                        kMaxTcpCongestionWindow)),
-        receiver_(new TcpReceiver()),
         sequence_number_(1),
         acked_sequence_number_(0),
         bytes_in_flight_(0) {
     standard_packet_.bytes_sent = kDefaultTCPMSS;
   }
 
   int SendAvailableSendWindow() {
     // Send as long as TimeUntilSend returns Zero.
     int packets_sent = 0;
     bool can_send = sender_->TimeUntilSend(
@@ skipping 47 matching lines @@
     lost_packets.push_back(
         make_pair(sequence_number, standard_packet_));
     sender_->OnCongestionEvent(
         false, bytes_in_flight_, acked_packets, lost_packets);
     bytes_in_flight_ -= kDefaultTCPMSS;
   }
 
   const QuicTime::Delta one_ms_;
   MockClock clock_;
   scoped_ptr<TcpCubicSenderPeer> sender_;
-  scoped_ptr<TcpReceiver> receiver_;
   QuicPacketSequenceNumber sequence_number_;
   QuicPacketSequenceNumber acked_sequence_number_;
   QuicByteCount bytes_in_flight_;
   TransmissionInfo standard_packet_;
 };
 
 TEST_F(TcpCubicSenderTest, SimpleSender) {
   // At startup make sure we are at the default.
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   // At startup make sure we can send.
@@ skipping 609 matching lines @@
 
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
       (kMinCongestionWindowForBandwidthResumption - 1) * kMaxPacketSize);
   EXPECT_TRUE(sender_->ResumeConnectionState(cached_network_params));
   EXPECT_EQ(kMinCongestionWindowForBandwidthResumption,
             sender_->congestion_window());
 }
 
 }  // namespace test
 }  // namespace net