Land Recent QUIC Changes.

net/quic/test_tools/simple_quic_framer.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/test_tools/simple_quic_framer.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
@@ skipping 62 matching lines @@
     ack_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) OVERRIDE {
     feedback_frames_.push_back(frame);
     return true;
   }
 
+  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
+    stop_waiting_frames_.push_back(frame);
+    return true;
+  }
+
   virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
     fec_data_ = fec;
     fec_redundancy_ = fec_data_.redundancy.as_string();
     fec_data_.redundancy = fec_redundancy_;
   }
 
   virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
     rst_stream_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnConnectionCloseFrame(
       const QuicConnectionCloseFrame& frame) OVERRIDE {
     connection_close_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
     goaway_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame)
-      OVERRIDE {
+  virtual bool OnWindowUpdateFrame(
+      const QuicWindowUpdateFrame& frame) OVERRIDE {
     window_update_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
     blocked_frames_.push_back(frame);
     return true;
   }
 
   virtual void OnPacketComplete() OVERRIDE {}
 
   const QuicPacketHeader& header() const { return header_; }
   const vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
   const vector<QuicConnectionCloseFrame>& connection_close_frames() const {
     return connection_close_frames_;
   }
   const vector<QuicCongestionFeedbackFrame>& feedback_frames() const {
     return feedback_frames_;
   }
   const vector<QuicGoAwayFrame>& goaway_frames() const {
     return goaway_frames_;
   }
   const vector<QuicRstStreamFrame>& rst_stream_frames() const {
     return rst_stream_frames_;
   }
   const vector<QuicStreamFrame>& stream_frames() const {
     return stream_frames_;
   }
+  const vector<QuicStopWaitingFrame>& stop_waiting_frames() const {
+    return stop_waiting_frames_;
+  }
   const vector<QuicWindowUpdateFrame>& window_update_frames() const {
     return window_update_frames_;
   }
   const vector<QuicBlockedFrame>& blocked_frames() const {
     return blocked_frames_;
   }
   const QuicFecData& fec_data() const {
     return fec_data_;
   }
 
  private:
   QuicErrorCode error_;
   bool has_header_;
   QuicPacketHeader header_;
   QuicFecData fec_data_;
   string fec_redundancy_;
   vector<QuicAckFrame> ack_frames_;
   vector<QuicCongestionFeedbackFrame> feedback_frames_;
+  vector<QuicStopWaitingFrame> stop_waiting_frames_;
   vector<QuicStreamFrame> stream_frames_;
   vector<QuicRstStreamFrame> rst_stream_frames_;
   vector<QuicGoAwayFrame> goaway_frames_;
   vector<QuicConnectionCloseFrame> connection_close_frames_;
   vector<QuicWindowUpdateFrame> window_update_frames_;
   vector<QuicBlockedFrame> blocked_frames_;
   vector<string*> stream_data_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleFramerVisitor);
 };
@@ skipping 28 matching lines @@
 const QuicFecData& SimpleQuicFramer::fec_data() const {
   return visitor_->fec_data();
 }
 
 QuicFramer* SimpleQuicFramer::framer() {
   return &framer_;
 }
 
 size_t SimpleQuicFramer::num_frames() const {
   return ack_frames().size() +
+      feedback_frames().size() +
+      goaway_frames().size() +
+      rst_stream_frames().size() +
+      stop_waiting_frames().size() +
       stream_frames().size() +
-      feedback_frames().size() +
-      rst_stream_frames().size() +
-      goaway_frames().size() +
       connection_close_frames().size();
 }
 
 const vector<QuicAckFrame>& SimpleQuicFramer::ack_frames() const {
   return visitor_->ack_frames();
 }
 
+const vector<QuicStopWaitingFrame>&
+SimpleQuicFramer::stop_waiting_frames() const {
+  return visitor_->stop_waiting_frames();
+}
+
 const vector<QuicStreamFrame>& SimpleQuicFramer::stream_frames() const {
   return visitor_->stream_frames();
 }
 
 const vector<QuicRstStreamFrame>& SimpleQuicFramer::rst_stream_frames() const {
   return visitor_->rst_stream_frames();
 }
 
 const vector<QuicCongestionFeedbackFrame>&
 SimpleQuicFramer::feedback_frames() const {
   return visitor_->feedback_frames();
 }
 
 const vector<QuicGoAwayFrame>&
 SimpleQuicFramer::goaway_frames() const {
   return visitor_->goaway_frames();
 }
 
 const vector<QuicConnectionCloseFrame>&
 SimpleQuicFramer::connection_close_frames() const {
   return visitor_->connection_close_frames();
 }
 
 }  // namespace test
 }  // namespace net