Change the interface of GetAlternativeServicesFor, always return the best Alt-Svc entry.

net/quic/test_tools/quic_test_packet_maker.cc

Index: net/quic/test_tools/quic_test_packet_maker.cc
diff --git a/net/quic/test_tools/quic_test_packet_maker.cc b/net/quic/test_tools/quic_test_packet_maker.cc
index 2119f25157a6648d111eee7d6fdad8fcf95e2791..ec461675db9d309d180d9f0353e5f8c6e9ac6f36 100644
--- a/net/quic/test_tools/quic_test_packet_maker.cc
+++ b/net/quic/test_tools/quic_test_packet_maker.cc
@@ -174,6 +174,16 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket(
     QuicPacketNumber largest_received,
     QuicPacketNumber least_unacked,
     bool send_feedback) {
+  return MakeAckPacket(packet_number, largest_received, least_unacked,
+                       least_unacked, send_feedback);
+}
+
+scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket(
+    QuicPacketNumber packet_number,
+    QuicPacketNumber largest_received,
+    QuicPacketNumber ack_least_unacked,
+    QuicPacketNumber stop_least_unacked,
+    bool send_feedback) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
@@ -186,7 +196,7 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket(
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.delta_time_largest_observed = QuicTime::Delta::Zero();
-  for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
+  for (QuicPacketNumber i = ack_least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
 
@@ -196,7 +206,7 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeAckPacket(
   frames.push_back(QuicFrame(&ack));
 
   QuicStopWaitingFrame stop_waiting;
-  stop_waiting.least_unacked = least_unacked;
+  stop_waiting.least_unacked = stop_least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
 
   scoped_ptr<QuicPacket> packet(
@@ -230,6 +240,20 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
     SpdyPriority priority,
     const SpdyHeaderBlock& headers,
     size_t* spdy_headers_frame_length) {
+  return MakeRequestHeadersPacket(packet_number, stream_id,
+                                  should_include_version, fin, priority,
+                                  headers, spdy_headers_frame_length, 0);
+}
+
+scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
+    QuicPacketNumber packet_number,
+    QuicStreamId stream_id,
+    bool should_include_version,
+    bool fin,
+    SpdyPriority priority,
+    const SpdyHeaderBlock& headers,
+    size_t* spdy_headers_frame_length,
+    QuicStreamOffset offset) {
   InitializeHeader(packet_number, should_include_version);
   scoped_ptr<SpdySerializedFrame> spdy_frame;
   if (spdy_request_framer_.protocol_version() == SPDY3) {
@@ -250,8 +274,9 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
     *spdy_headers_frame_length = spdy_frame->size();
   }
   QuicStreamFrame frame(
-      kHeadersStreamId, false, 0,
+      kHeadersStreamId, false, offset,
       base::StringPiece(spdy_frame->data(), spdy_frame->size()));
+
   return MakePacket(header_, QuicFrame(&frame));
 }
 
@@ -261,10 +286,11 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeRequestHeadersPacket(
     bool should_include_version,
     bool fin,
     SpdyPriority priority,
-    const SpdyHeaderBlock& headers) {
+    const SpdyHeaderBlock& headers,
+    QuicStreamOffset offset) {
   return MakeRequestHeadersPacket(packet_number, stream_id,
                                   should_include_version, fin, priority,
-                                  headers, nullptr);
+                                  headers, nullptr, offset);
 }
 
 scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
@@ -273,10 +299,11 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
     bool should_include_version,
     bool fin,
     const SpdyHeaderBlock& headers,
-    size_t* spdy_headers_frame_length) {
+    size_t* spdy_headers_frame_length,
+    QuicStreamOffset offset) {
   InitializeHeader(packet_number, should_include_version);
   scoped_ptr<SpdySerializedFrame> spdy_frame;
-  if (spdy_request_framer_.protocol_version() == SPDY3) {
+  if (spdy_response_framer_.protocol_version() == SPDY3) {
     SpdySynReplyIR syn_reply(stream_id);
     syn_reply.set_header_block(headers);
     syn_reply.set_fin(fin);
@@ -285,13 +312,13 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
     SpdyHeadersIR headers_frame(stream_id);
     headers_frame.set_header_block(headers);
     headers_frame.set_fin(fin);
-    spdy_frame.reset(spdy_request_framer_.SerializeFrame(headers_frame));
+    spdy_frame.reset(spdy_response_framer_.SerializeFrame(headers_frame));
   }
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame->size();
   }
   QuicStreamFrame frame(
-      kHeadersStreamId, false, 0,
+      kHeadersStreamId, false, offset,
       base::StringPiece(spdy_frame->data(), spdy_frame->size()));
   return MakePacket(header_, QuicFrame(&frame));
 }
@@ -301,9 +328,23 @@ scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
-    const SpdyHeaderBlock& headers) {
-  return MakeResponseHeadersPacket(
-      packet_number, stream_id, should_include_version, fin, headers, nullptr);
+    const SpdyHeaderBlock& headers,
+    size_t* spdy_headers_frame_length) {
+  return MakeResponseHeadersPacket(packet_number, stream_id,
+                                   should_include_version, fin, headers,
+                                   spdy_headers_frame_length, 0);
+}
+
+scoped_ptr<QuicEncryptedPacket> QuicTestPacketMaker::MakeResponseHeadersPacket(
+    QuicPacketNumber packet_number,
+    QuicStreamId stream_id,
+    bool should_include_version,
+    bool fin,
+    const SpdyHeaderBlock& headers,
+    QuicStreamOffset offset) {
+  return MakeResponseHeadersPacket(packet_number, stream_id,
+                                   should_include_version, fin, headers,
+                                   nullptr, offset);
 }
 
 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders(