Inline the members of QUIC's ReceivedPacketInfo into QuicAckFrame now

net/quic/quic_connection.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 "net/quic/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 531 matching lines @@
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
     return false;
   }
 
   last_ack_frames_.push_back(incoming_ack);
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
-  received_packet_manager_.UpdatePacketInformationReceivedByPeer(
-      incoming_ack.received_info);
+  received_packet_manager_.UpdatePacketInformationReceivedByPeer(incoming_ack);
 
   sent_entropy_manager_.ClearEntropyBefore(
       received_packet_manager_.least_packet_awaited_by_peer() - 1);
 
-  sent_packet_manager_.OnIncomingAck(incoming_ack.received_info,
+  sent_packet_manager_.OnIncomingAck(incoming_ack,
                                      time_of_last_received_packet_);
   if (sent_packet_manager_.HasPendingRetransmissions()) {
     WriteIfNotBlocked();
   }
 
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
   retransmission_alarm_->Cancel();
   QuicTime retransmission_time =
       sent_packet_manager_.GetRetransmissionTime();
@@ skipping 44 matching lines @@
 
 bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnPingFrame(frame);
   }
   return true;
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
-  if (incoming_ack.received_info.largest_observed >
-      packet_generator_.sequence_number()) {
+  if (incoming_ack.largest_observed > packet_generator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
-                << incoming_ack.received_info.largest_observed << " vs "
+                << incoming_ack.largest_observed << " vs "
                 << packet_generator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
-  if (incoming_ack.received_info.largest_observed <
+  if (incoming_ack.largest_observed <
           received_packet_manager_.peer_largest_observed_packet()) {
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
-                << incoming_ack.received_info.largest_observed << " vs "
+                << incoming_ack.largest_observed << " vs "
                 << received_packet_manager_.peer_largest_observed_packet();
     // A new ack has a diminished largest_observed value.  Error out.
     // If this was an old packet, we wouldn't even have checked.
     return false;
   }
 
-  if (!incoming_ack.received_info.missing_packets.empty() &&
-      *incoming_ack.received_info.missing_packets.rbegin() >
-      incoming_ack.received_info.largest_observed) {
+  if (!incoming_ack.missing_packets.empty() &&
+      *incoming_ack.missing_packets.rbegin() > incoming_ack.largest_observed) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
-                << *incoming_ack.received_info.missing_packets.rbegin()
+                << *incoming_ack.missing_packets.rbegin()
                 << " which is greater than largest observed: "
-                << incoming_ack.received_info.largest_observed;
+                << incoming_ack.largest_observed;
     return false;
   }
 
-  if (!incoming_ack.received_info.missing_packets.empty() &&
-      *incoming_ack.received_info.missing_packets.begin() <
+  if (!incoming_ack.missing_packets.empty() &&
+      *incoming_ack.missing_packets.begin() <
       received_packet_manager_.least_packet_awaited_by_peer()) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
-                << *incoming_ack.received_info.missing_packets.begin()
+                << *incoming_ack.missing_packets.begin()
                 << " which is smaller than least_packet_awaited_by_peer_: "
                 << received_packet_manager_.least_packet_awaited_by_peer();
     return false;
   }
 
   if (!sent_entropy_manager_.IsValidEntropy(
-          incoming_ack.received_info.largest_observed,
-          incoming_ack.received_info.missing_packets,
-          incoming_ack.received_info.entropy_hash)) {
+          incoming_ack.largest_observed,
+          incoming_ack.missing_packets,
+          incoming_ack.entropy_hash)) {
     DLOG(ERROR) << ENDPOINT << "Peer sent invalid entropy.";
     return false;
   }
 
   for (SequenceNumberSet::const_iterator iter =
-           incoming_ack.received_info.revived_packets.begin();
-       iter != incoming_ack.received_info.revived_packets.end(); ++iter) {
-    if (!ContainsKey(incoming_ack.received_info.missing_packets, *iter)) {
+           incoming_ack.revived_packets.begin();
+       iter != incoming_ack.revived_packets.end(); ++iter) {
+    if (!ContainsKey(incoming_ack.missing_packets, *iter)) {
       DLOG(ERROR) << ENDPOINT
                   << "Peer specified revived packet which was not missing.";
       return false;
     }
   }
   return true;
 }
 
 bool QuicConnection::ValidateStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
@@ skipping 204 matching lines @@
   last_blocked_frames_.clear();
   last_rst_frames_.clear();
   last_ack_frames_.clear();
   last_stop_waiting_frames_.clear();
   last_congestion_frames_.clear();
 }
 
 QuicAckFrame* QuicConnection::CreateAckFrame() {
   QuicAckFrame* outgoing_ack = new QuicAckFrame();
   received_packet_manager_.UpdateReceivedPacketInfo(
-      &(outgoing_ack->received_info), clock_->ApproximateNow());
+      outgoing_ack, clock_->ApproximateNow());
   DVLOG(1) << ENDPOINT << "Creating ack frame: " << *outgoing_ack;
   return outgoing_ack;
 }
 
 QuicCongestionFeedbackFrame* QuicConnection::CreateFeedbackFrame() {
   return new QuicCongestionFeedbackFrame(outgoing_congestion_feedback_);
 }
 
 QuicStopWaitingFrame* QuicConnection::CreateStopWaitingFrame() {
   QuicStopWaitingFrame stop_waiting;
   UpdateStopWaiting(&stop_waiting);
   return new QuicStopWaitingFrame(stop_waiting);
 }
 
 bool QuicConnection::ShouldLastPacketInstigateAck() const {
   if (!last_stream_frames_.empty() ||
       !last_goaway_frames_.empty() ||
       !last_rst_frames_.empty() ||
       !last_window_update_frames_.empty() ||
       !last_blocked_frames_.empty()) {
     return true;
   }
 
-  if (!last_ack_frames_.empty() &&
-      last_ack_frames_.back().received_info.is_truncated) {
+  if (!last_ack_frames_.empty() && last_ack_frames_.back().is_truncated) {
     return true;
   }
   return false;
 }
 
 void QuicConnection::UpdateStopWaitingCount() {
   if (last_ack_frames_.empty()) {
     return;
   }
 
   // If the peer is still waiting for a packet that we are no longer planning to
   // send, send an ack to raise the high water mark.
-  if (!last_ack_frames_.back().received_info.missing_packets.empty() &&
-      GetLeastUnacked() >
-          *last_ack_frames_.back().received_info.missing_packets.begin()) {
+  if (!last_ack_frames_.back().missing_packets.empty() &&
+      GetLeastUnacked() > *last_ack_frames_.back().missing_packets.begin()) {
     ++stop_waiting_count_;
   } else {
     stop_waiting_count_ = 0;
   }
 }
 
 QuicPacketSequenceNumber QuicConnection::GetLeastUnacked() const {
   return sent_packet_manager_.HasUnackedPackets() ?
       sent_packet_manager_.GetLeastUnackedSentPacket() :
       packet_generator_.sequence_number() + 1;
@@ skipping 1027 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net