Revert 171096

> Adding transmission times for every QUIC packet received in the AckFrame.
> Making the scheduler a strict mock for quic connection test.
> 
> Merge internal change: 39116450
> Merge internal change: 38802607
> 
> 
> Review URL: https://chromiumcodereview.appspot.com/11416155

TBR=rch@chromium.org
Review URL: https://codereview.chromium.org/11439003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@171103 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 13 insertions, 72 deletions

diff --git a/net/quic/quic_protocol.cc b/net/quic/quic_protocol.cc
index 6296446..878ffee 100644
--- a/net/quic/quic_protocol.cc
+++ b/net/quic/quic_protocol.cc
@@ -3,10 +3,8 @@
 // found in the LICENSE file.
 
 #include "net/quic/quic_protocol.h"
-#include "base/stl_util.h"
 
 using base::StringPiece;
-using std::map;
 using std::ostream;
 
 namespace net {
@@ -23,87 +21,30 @@ QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
       data(data) {
 }
 
-// TODO(ianswett): Initializing largest_received to 0 should not be necessary.
-ReceivedPacketInfo::ReceivedPacketInfo() : largest_received(0) {}
+ReceivedPacketInfo::ReceivedPacketInfo() {}
 
 ReceivedPacketInfo::~ReceivedPacketInfo() {}
 
-void ReceivedPacketInfo::RecordAck(QuicPacketSequenceNumber sequence_number,
-                                   QuicTime time) {
-  DCHECK(!ContainsAck(sequence_number));
-  received_packet_times[sequence_number] = time;
-  if (largest_received < sequence_number) {
-    largest_received = sequence_number;
-  }
-}
-
-bool ReceivedPacketInfo::ContainsAck(
-    QuicPacketSequenceNumber sequence_number) const {
-  return ContainsKey(received_packet_times, sequence_number);
-}
-
-void ReceivedPacketInfo::ClearAcksBefore(
-    QuicPacketSequenceNumber least_unacked) {
-  for (QuicPacketSequenceNumber i = received_packet_times.begin()->first;
-       i < least_unacked; ++i) {
-    received_packet_times.erase(i);
-  }
-}
-
 SentPacketInfo::SentPacketInfo() {}
 
 SentPacketInfo::~SentPacketInfo() {}
 
-QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_received,
-                           QuicTime time_received,
-                           QuicPacketSequenceNumber least_unacked) {
-  received_info.largest_received = largest_received;
-  for (QuicPacketSequenceNumber seq_num = 1;
-       seq_num <= largest_received; ++seq_num) {
-    received_info.RecordAck(seq_num, time_received);
-  }
-  sent_info.least_unacked = least_unacked;
-  congestion_info.type = kNone;
-}
-
 ostream& operator<<(ostream& os, const QuicAckFrame& s) {
-  os << "sent info { least_waiting: " << s.sent_info.least_unacked << " } "
-     << "received info { largest_received: "
-     << s.received_info.largest_received
-     << " received packets: [ ";
-  for (map<QuicPacketSequenceNumber, QuicTime>::const_iterator it =
-           s.received_info.received_packet_times.begin();
-       it != s.received_info.received_packet_times.end(); ++it) {
-    os << it->first << "@" << it->second.ToMilliseconds() << " ";
+  os << "largest_received: " << s.received_info.largest_received
+     << " time: " << s.received_info.time_received.ToMicroseconds()
+     << " missing: ";
+  for (SequenceSet::const_iterator it = s.received_info.missing_packets.begin();
+       it != s.received_info.missing_packets.end(); ++it) {
+    os << *it << " ";
   }
 
-  os << "] } congestion info { type: " << s.congestion_info.type;
-  switch (s.congestion_info.type) {
-    case kNone:
-      break;
-    case kInterArrival: {
-      const CongestionFeedbackMessageInterArrival& inter_arrival =
-          s.congestion_info.inter_arrival;
-      os << " accumulated_number_of_lost_packets: "
-         << inter_arrival.accumulated_number_of_lost_packets;
-      os << " offset_time: " << inter_arrival.offset_time;
-      os << " delta_time: " << inter_arrival.delta_time;
-      break;
-    }
-    case kFixRate: {
-      os << " bitrate_in_bytes_per_second: "
-         << s.congestion_info.fix_rate.bitrate_in_bytes_per_second;
-      break;
-    }
-    case kTCP: {
-      const CongestionFeedbackMessageTCP& tcp = s.congestion_info.tcp;
-      os << " accumulated_number_of_lost_packets: "
-         << tcp.accumulated_number_of_lost_packets;
-      os << " receive_window: " << tcp.receive_window;
-      break;
-    }
+  os << " least_waiting: " << s.sent_info.least_unacked
+     << " no_retransmit: ";
+  for (SequenceSet::const_iterator it = s.sent_info.non_retransmiting.begin();
+       it != s.sent_info.non_retransmiting.end(); ++it) {
+    os << *it << " ";
   }
-  os << " }\n";
+  os << "\n";
   return os;
 }