relnote: Call methods to handle QUIC frames immediately instead of

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>
@@ skipping 255 matching lines @@
       first_required_forward_secure_packet_(0),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       connection_id_(connection_id),
       peer_address_(address),
       migrating_peer_port_(0),
       last_packet_decrypted_(false),
       last_packet_revived_(false),
       last_size_(0),
       last_decrypted_packet_level_(ENCRYPTION_NONE),
+      should_last_packet_instigate_acks_(false),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       silent_close_enabled_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_packets_received_since_last_ack_sent_(0),
       stop_waiting_count_(0),
       delay_setting_retransmission_alarm_(false),
@@ skipping 409 matching lines @@
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnStreamFrame(frame);
   }
   if (frame.stream_id != kCryptoStreamId &&
       last_decrypted_packet_level_ == ENCRYPTION_NONE) {
     DLOG(WARNING) << ENDPOINT
                   << "Received an unencrypted data frame: closing connection";
     SendConnectionClose(QUIC_UNENCRYPTED_STREAM_DATA);
     return false;
   }
-  last_stream_frames_.push_back(frame);
-  return true;
+  if (FLAGS_quic_process_frames_inline) {
+    visitor_->OnStreamFrame(frame);
+    stats_.stream_bytes_received += frame.data.size();
+    should_last_packet_instigate_acks_ = true;
+  } else {
+    last_stream_frames_.push_back(frame);
+  }
+  return connected_;
 }
 
 bool QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnAckFrame(incoming_ack);
   }
   DVLOG(1) << ENDPOINT << "OnAckFrame: " << incoming_ack;
 
   if (last_header_.packet_sequence_number <= largest_seen_packet_with_ack_) {
     DVLOG(1) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
 
   if (!ValidateAckFrame(incoming_ack)) {
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
     return false;
   }
 
-  last_ack_frames_.push_back(incoming_ack);
+  if (FLAGS_quic_process_frames_inline) {
+    ProcessAckFrame(incoming_ack);
+    if (incoming_ack.is_truncated) {
+      should_last_packet_instigate_acks_ = true;
+    }
+    QuicPacketSequenceNumber least_acked = GetLeastUnacked();

[ramant (doing other things), 2015/07/17 23:08:31]

Hi Ryan and Ian,
  linux's safe iterator doesn't allow accessing incoming_ack.missing_packets if
it is empty. Thus added the check for empty (will port that change back to
internal source). 

[Ryan Hamilton, 2015/07/17 23:21:33]

Good point!

+    if (least_acked > 0 &&
+        (incoming_ack.missing_packets.empty() ||
+         least_acked > *incoming_ack.missing_packets.begin())) {
+      ++stop_waiting_count_;
+    } else {
+      stop_waiting_count_ = 0;
+    }
+  } else {
+    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;
   sent_packet_manager_.OnIncomingAck(incoming_ack,
                                      time_of_last_received_packet_);
   sent_entropy_manager_.ClearEntropyBefore(
       sent_packet_manager_.least_packet_awaited_by_peer() - 1);
 
@@ skipping 30 matching lines @@
 
   last_stop_waiting_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPingFrame(frame);
   }
-  last_ping_frames_.push_back(frame);
+  if (FLAGS_quic_process_frames_inline) {
+    should_last_packet_instigate_acks_ = true;
+  } else {
+    last_ping_frames_.push_back(frame);
+  }
   return true;
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.largest_observed > packet_generator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
                 << incoming_ack.largest_observed << " vs "
                 << packet_generator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
@@ skipping 78 matching lines @@
   }
 }
 
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Stream reset with error "
            << QuicUtils::StreamErrorToString(frame.error_code);
-  last_rst_frames_.push_back(frame);
+  if (FLAGS_quic_process_frames_inline) {
+    visitor_->OnRstStream(frame);
+    should_last_packet_instigate_acks_ = true;
+  } else {
+    last_rst_frames_.push_back(frame);
+  }
   return connected_;
 }
 
 bool QuicConnection::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnConnectionCloseFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Connection " << connection_id()
            << " closed with error "
            << QuicUtils::ErrorToString(frame.error_code)
            << " " << frame.error_details;
-  last_close_frames_.push_back(frame);
+  if (FLAGS_quic_process_frames_inline) {
+    CloseConnection(frame.error_code, true);
+  } else {
+    last_close_frames_.push_back(frame);
+  }
   return connected_;
 }
 
 bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnGoAwayFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Go away received with error "
            << QuicUtils::ErrorToString(frame.error_code)
            << " and reason:" << frame.reason_phrase;
-  last_goaway_frames_.push_back(frame);
+  if (FLAGS_quic_process_frames_inline) {
+    visitor_->OnGoAway(frame);
+    should_last_packet_instigate_acks_ = true;
+  } else {
+    last_goaway_frames_.push_back(frame);
+  }
   return connected_;
 }
 
 bool QuicConnection::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnWindowUpdateFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "WindowUpdate received for stream: "
            << frame.stream_id << " with byte offset: " << frame.byte_offset;
-  last_window_update_frames_.push_back(frame);
+  if (FLAGS_quic_process_frames_inline) {
+    visitor_->OnWindowUpdateFrame(frame);
+    should_last_packet_instigate_acks_ = true;
+  } else {
+    last_window_update_frames_.push_back(frame);
+  }
   return connected_;
 }
 
 bool QuicConnection::OnBlockedFrame(const QuicBlockedFrame& frame) {
   DCHECK(connected_);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnBlockedFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Blocked frame received for stream: "
            << frame.stream_id;
-  last_blocked_frames_.push_back(frame);
+  if (FLAGS_quic_process_frames_inline) {
+    visitor_->OnBlockedFrame(frame);
+    should_last_packet_instigate_acks_ = true;
+  } else {
+    last_blocked_frames_.push_back(frame);
+  }
   return connected_;
 }
 
 void QuicConnection::OnPacketComplete() {
   // Don't do anything if this packet closed the connection.
   if (!connected_) {
     ClearLastFrames();
     return;
   }
 
@@ skipping 20 matching lines @@
   // processing stream frames, since the processing may result in a response
   // packet with a bundled ack.
   if (last_packet_revived_) {
     received_packet_manager_.RecordPacketRevived(
         last_header_.packet_sequence_number);
   } else {
     received_packet_manager_.RecordPacketReceived(
         last_size_, last_header_, time_of_last_received_packet_);
   }
 
-  for (const QuicStreamFrame& frame : last_stream_frames_) {
-    visitor_->OnStreamFrame(frame);
-    stats_.stream_bytes_received += frame.data.size();
-    if (!connected_) {
+  if (!FLAGS_quic_process_frames_inline) {
+    for (const QuicStreamFrame& frame : last_stream_frames_) {
+      visitor_->OnStreamFrame(frame);
+      stats_.stream_bytes_received += frame.data.size();
+      if (!connected_) {
+        return;
+      }
+    }
+
+    // Process window updates, blocked, stream resets, acks, then stop waiting.
+    for (const QuicWindowUpdateFrame& frame : last_window_update_frames_) {
+      visitor_->OnWindowUpdateFrame(frame);
+      if (!connected_) {
+        return;
+      }
+    }
+    for (const QuicBlockedFrame& frame : last_blocked_frames_) {
+      visitor_->OnBlockedFrame(frame);
+      if (!connected_) {
+        return;
+      }
+    }
+    for (const QuicGoAwayFrame& frame : last_goaway_frames_) {
+      visitor_->OnGoAway(frame);
+      if (!connected_) {
+        return;
+      }
+    }
+    for (const QuicRstStreamFrame& frame : last_rst_frames_) {
+      visitor_->OnRstStream(frame);
+      if (!connected_) {
+        return;
+      }
+    }
+    for (const QuicAckFrame& frame : last_ack_frames_) {
+      ProcessAckFrame(frame);
+      if (!connected_) {
+        return;
+      }
+    }
+    if (!last_close_frames_.empty()) {
+      CloseConnection(last_close_frames_[0].error_code, true);
+      DCHECK(!connected_);
       return;
     }
   }
-
-  // Process window updates, blocked, stream resets, acks, then congestion
-  // feedback.
-  for (const QuicWindowUpdateFrame& frame : last_window_update_frames_) {
-    visitor_->OnWindowUpdateFrame(frame);
-    if (!connected_) {
-      return;
-    }
-  }
-  for (const QuicBlockedFrame& frame : last_blocked_frames_) {
-    visitor_->OnBlockedFrame(frame);
-    if (!connected_) {
-      return;
-    }
-  }
-  for (const QuicGoAwayFrame& frame : last_goaway_frames_) {
-    visitor_->OnGoAway(frame);
-    if (!connected_) {
-      return;
-    }
-  }
-  for (const QuicRstStreamFrame& frame : last_rst_frames_) {
-    visitor_->OnRstStream(frame);
-    if (!connected_) {
-      return;
-    }
-  }
-  for (const QuicAckFrame& frame : last_ack_frames_) {
-    ProcessAckFrame(frame);
-    if (!connected_) {
-      return;
-    }
-  }
+  // Continue to process stop waiting frames later, because the packet needs
+  // to be considered 'received' before the entropy can be updated.
   for (const QuicStopWaitingFrame& frame : last_stop_waiting_frames_) {
     ProcessStopWaitingFrame(frame);
     if (!connected_) {
       return;
     }
   }
-  if (!last_close_frames_.empty()) {
-    CloseConnection(last_close_frames_[0].error_code, true);
-    DCHECK(!connected_);
-    return;
-  }
 
   // If there are new missing packets to report, send an ack immediately.
   if (ShouldLastPacketInstigateAck() &&
       received_packet_manager_.HasNewMissingPackets()) {
     ack_queued_ = true;
     ack_alarm_->Cancel();
   }
 
   UpdateStopWaitingCount();
   ClearLastFrames();
@@ skipping 18 matching lines @@
       DVLOG(1) << "Ack timer set; next packet or timer will trigger ACK.";
     }
   }
 
   if (ack_queued_) {
     ack_alarm_->Cancel();
   }
 }
 
 void QuicConnection::ClearLastFrames() {
+  if (FLAGS_quic_process_frames_inline) {
+    should_last_packet_instigate_acks_ = false;
+    last_stop_waiting_frames_.clear();
+    return;
+  }
   last_stream_frames_.clear();
   last_ack_frames_.clear();
   last_stop_waiting_frames_.clear();
   last_rst_frames_.clear();
   last_goaway_frames_.clear();
   last_window_update_frames_.clear();
   last_blocked_frames_.clear();
   last_ping_frames_.clear();
   last_close_frames_.clear();
 }
@@ skipping 22 matching lines @@
 }
 
 void QuicConnection::PopulateStopWaitingFrame(
     QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.GetCumulativeEntropy(
       stop_waiting->least_unacked - 1);
 }
 
 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() ||
-      !last_ping_frames_.empty()) {
+  if (FLAGS_quic_process_frames_inline && should_last_packet_instigate_acks_) {
     return true;
   }
+  if (!FLAGS_quic_process_frames_inline) {
+    if (!last_stream_frames_.empty() || !last_goaway_frames_.empty() ||
+        !last_rst_frames_.empty() || !last_window_update_frames_.empty() ||
+        !last_blocked_frames_.empty() || !last_ping_frames_.empty()) {
+      return true;
+    }
 
-  if (!last_ack_frames_.empty() && last_ack_frames_.back().is_truncated) {
-    return true;
+    if (!last_ack_frames_.empty() && last_ack_frames_.back().is_truncated) {
+      return true;
+    }
   }
   // Always send an ack every 20 packets in order to allow the peer to discard
   // information from the SentPacketManager and provide an RTT measurement.
   if (num_packets_received_since_last_ack_sent_ >=
           kMaxPacketsReceivedBeforeAckSend) {
     return true;
   }
   return false;
 }
 
@@ skipping 1201 matching lines @@
       sequence_number_of_last_sent_packet_ + packets_between_mtu_probes_ + 1;
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 }  // namespace net