Land Recent QUIC Changes.

Minor change to QUIC's hybrid slow start to start the round at the first
closely spaced ack pair.

Merge internal change: 65018864
https://codereview.chromium.org/242663002/


Fixes bug where a revived packet's header was not being populated
correctly from the received FEC packet's header. Added tests to verify
that revived packet headers are correctly regenerated for varying
sequence number and connection id lengths. Moving closer towards FEC
correctness in code.

Bug fixes to FEC packet revival code, and additional tests for revived
packets.

Merge internal change: 65009931
https://codereview.chromium.org/242223003/


Remove mostly redundant FramerVisitorCapturingPublicReset from
net/quic/test_tools/quic_test_utils.h.

Use SimpleQuicFramer in QuicConnectionTest and remove
mostly redundant FramerVisitorCapturingFrames.

Merge internal change: 65008278, 65067000
https://codereview.chromium.org/241643004/


Changes found while sync'ing internal source code with chromium code.

- Minor comment change.
- Added using statement.

Merge internal change: 64933978
https://codereview.chromium.org/242643002/


Large fixes and simplifications to QUIC's HybridSlowStart to correctly
determine the start and end of rounds.

Previously the assumption was that the available window was 0 only at
the end of a sending burst, but in reality that's only accurate for the
first burst, so the resulting code did not work as intended and rounds
were likely cut very short.

Merge internal change: 64911496
https://codereview.chromium.org/242633002/


Add a bytes_spuriously_retransmitted, max_packet_size, and
congestion_window to QuicConnectionStats and populate the TcpStats with
cwnd and bytes_spuriously_retransmitted.

Merge internal change: 64890213
https://codereview.chromium.org/242533002/

R=rch@chromium.org

Review URL: https://codereview.chromium.org/243813002

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

4 files changed, 37 insertions, 171 deletions

diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index fed9edd..ace88a7 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -151,102 +151,6 @@ bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
   return true;
 }
 
-FramerVisitorCapturingFrames::FramerVisitorCapturingFrames() : frame_count_(0) {
-}
-
-FramerVisitorCapturingFrames::~FramerVisitorCapturingFrames() {
-  Reset();
-}
-
-void FramerVisitorCapturingFrames::Reset() {
-  STLDeleteElements(&stream_data_);
-  stream_frames_.clear();
-  frame_count_ = 0;
-  ack_.reset();
-  feedback_.reset();
-  rst_.reset();
-  close_.reset();
-  goaway_.reset();
-  version_negotiation_packet_.reset();
-}
-
-bool FramerVisitorCapturingFrames::OnPacketHeader(
-    const QuicPacketHeader& header) {
-  header_ = header;
-  frame_count_ = 0;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnStreamFrame(const QuicStreamFrame& frame) {
-  // Make a copy of the frame and store a copy of underlying string, since
-  // frame.data may not exist outside this callback.
-  stream_data_.push_back(frame.GetDataAsString());
-  QuicStreamFrame frame_copy = frame;
-  frame_copy.data.Clear();
-  frame_copy.data.Append(const_cast<char*>(stream_data_.back()->data()),
-                         stream_data_.back()->size());
-  stream_frames_.push_back(frame_copy);
-  ++frame_count_;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnAckFrame(const QuicAckFrame& frame) {
-  ack_.reset(new QuicAckFrame(frame));
-  ++frame_count_;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnCongestionFeedbackFrame(
-    const QuicCongestionFeedbackFrame& frame) {
-  feedback_.reset(new QuicCongestionFeedbackFrame(frame));
-  ++frame_count_;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnStopWaitingFrame(
-    const QuicStopWaitingFrame& frame) {
-  stop_waiting_.reset(new QuicStopWaitingFrame(frame));
-  ++frame_count_;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnRstStreamFrame(
-    const QuicRstStreamFrame& frame) {
-  rst_.reset(new QuicRstStreamFrame(frame));
-  ++frame_count_;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnConnectionCloseFrame(
-    const QuicConnectionCloseFrame& frame) {
-  close_.reset(new QuicConnectionCloseFrame(frame));
-  ++frame_count_;
-  return true;
-}
-
-bool FramerVisitorCapturingFrames::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
-  goaway_.reset(new QuicGoAwayFrame(frame));
-  ++frame_count_;
-  return true;
-}
-
-void FramerVisitorCapturingFrames::OnVersionNegotiationPacket(
-    const QuicVersionNegotiationPacket& packet) {
-  version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
-  frame_count_ = 0;
-}
-
-FramerVisitorCapturingPublicReset::FramerVisitorCapturingPublicReset() {
-}
-
-FramerVisitorCapturingPublicReset::~FramerVisitorCapturingPublicReset() {
-}
-
-void FramerVisitorCapturingPublicReset::OnPublicResetPacket(
-    const QuicPublicResetPacket& public_reset) {
-  public_reset_packet_ = public_reset;
-}
-
 MockConnectionVisitor::MockConnectionVisitor() {
 }
 
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index 6f10cd5..19e7d80 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -176,79 +176,6 @@ class NoOpFramerVisitor : public QuicFramerVisitorInterface {
   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
 };
 
-class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
- public:
-  FramerVisitorCapturingPublicReset();
-  virtual ~FramerVisitorCapturingPublicReset();
-
-  virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE;
-
-  const QuicPublicResetPacket public_reset_packet() {
-    return public_reset_packet_;
-  }
-
- private:
-  QuicPublicResetPacket public_reset_packet_;
-};
-
-class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
- public:
-  FramerVisitorCapturingFrames();
-  virtual ~FramerVisitorCapturingFrames();
-
-  // Reset the visitor to it's initial state.
-  void Reset();
-
-  // NoOpFramerVisitor
-  virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE;
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
-  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
-  virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE;
-  virtual bool OnStopWaitingFrame(
-      const QuicStopWaitingFrame& frame) OVERRIDE;
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
-  virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE;
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
-
-  size_t frame_count() const { return frame_count_; }
-  QuicPacketHeader* header() { return &header_; }
-  const std::vector<QuicStreamFrame>* stream_frames() const {
-    return &stream_frames_;
-  }
-  const std::vector<string*>& stream_data() const {
-    return stream_data_;
-  }
-  QuicAckFrame* ack() { return ack_.get(); }
-  QuicCongestionFeedbackFrame* feedback() { return feedback_.get(); }
-  QuicStopWaitingFrame* stop_waiting() { return stop_waiting_.get(); }
-  QuicRstStreamFrame* rst() { return rst_.get(); }
-  QuicConnectionCloseFrame* close() { return close_.get(); }
-  QuicGoAwayFrame* goaway() { return goaway_.get(); }
-  QuicVersionNegotiationPacket* version_negotiation_packet() {
-    return version_negotiation_packet_.get();
-  }
-
- private:
-  size_t frame_count_;
-  QuicPacketHeader header_;
-  std::vector<QuicStreamFrame> stream_frames_;
-  std::vector<std::string*> stream_data_;
-  scoped_ptr<QuicAckFrame> ack_;
-  scoped_ptr<QuicCongestionFeedbackFrame> feedback_;
-  scoped_ptr<QuicStopWaitingFrame> stop_waiting_;
-  scoped_ptr<QuicRstStreamFrame> rst_;
-  scoped_ptr<QuicConnectionCloseFrame> close_;
-  scoped_ptr<QuicGoAwayFrame> goaway_;
-  scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
-
-  DISALLOW_COPY_AND_ASSIGN(FramerVisitorCapturingFrames);
-};
-
 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
  public:
   MockConnectionVisitor();
diff --git a/net/quic/test_tools/simple_quic_framer.cc b/net/quic/test_tools/simple_quic_framer.cc
index 6c1efb1..4070409 100644
--- a/net/quic/test_tools/simple_quic_framer.cc
+++ b/net/quic/test_tools/simple_quic_framer.cc
@@ -36,9 +36,14 @@ class SimpleFramerVisitor : public QuicFramerVisitorInterface {
 
   virtual void OnPacket() OVERRIDE {}
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE {}
+      const QuicPublicResetPacket& packet) OVERRIDE {
+    public_reset_packet_.reset(new QuicPublicResetPacket(packet));
+  }
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE {}
+      const QuicVersionNegotiationPacket& packet) OVERRIDE {
+    version_negotiation_packet_.reset(
+        new QuicVersionNegotiationPacket(packet));
+  }
   virtual void OnRevivedPacket() OVERRIDE {}
 
   virtual bool OnUnauthenticatedPublicHeader(
@@ -143,12 +148,20 @@ class SimpleFramerVisitor : public QuicFramerVisitorInterface {
   const QuicFecData& fec_data() const {
     return fec_data_;
   }
+  const QuicVersionNegotiationPacket* version_negotiation_packet() const {
+    return version_negotiation_packet_.get();
+  }
+  const QuicPublicResetPacket* public_reset_packet() const {
+    return public_reset_packet_.get();
+  }
 
  private:
   QuicErrorCode error_;
   bool has_header_;
   QuicPacketHeader header_;
   QuicFecData fec_data_;
+  scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
+  scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
   string fec_redundancy_;
   vector<QuicAckFrame> ack_frames_;
   vector<QuicCongestionFeedbackFrame> feedback_frames_;
@@ -187,6 +200,11 @@ bool SimpleQuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   return framer_.ProcessPacket(packet);
 }
 
+void SimpleQuicFramer::Reset() {
+  visitor_.reset(new SimpleFramerVisitor);
+}
+
+
 const QuicPacketHeader& SimpleQuicFramer::header() const {
   return visitor_->header();
 }
@@ -195,6 +213,15 @@ const QuicFecData& SimpleQuicFramer::fec_data() const {
   return visitor_->fec_data();
 }
 
+const QuicVersionNegotiationPacket*
+SimpleQuicFramer::version_negotiation_packet() const {
+  return visitor_->version_negotiation_packet();
+}
+
+const QuicPublicResetPacket* SimpleQuicFramer::public_reset_packet() const {
+  return visitor_->public_reset_packet();
+}
+
 QuicFramer* SimpleQuicFramer::framer() {
   return &framer_;
 }
diff --git a/net/quic/test_tools/simple_quic_framer.h b/net/quic/test_tools/simple_quic_framer.h
index 6f4908a..d1ce744 100644
--- a/net/quic/test_tools/simple_quic_framer.h
+++ b/net/quic/test_tools/simple_quic_framer.h
@@ -35,6 +35,7 @@ class SimpleQuicFramer {
 
   bool ProcessPacket(const QuicEncryptedPacket& packet);
   bool ProcessPacket(const QuicPacket& packet);
+  void Reset();
 
   const QuicPacketHeader& header() const;
   size_t num_frames() const;
@@ -46,8 +47,15 @@ class SimpleQuicFramer {
   const std::vector<QuicRstStreamFrame>& rst_stream_frames() const;
   const std::vector<QuicStreamFrame>& stream_frames() const;
   const QuicFecData& fec_data() const;
+  const QuicVersionNegotiationPacket* version_negotiation_packet() const;
+  const QuicPublicResetPacket* public_reset_packet() const;
+
   QuicFramer* framer();
 
+  void SetSupportedVersions(const QuicVersionVector& versions) {
+    framer_.SetSupportedVersions(versions);
+  }
+
  private:
   QuicFramer framer_;
   scoped_ptr<SimpleFramerVisitor> visitor_;