Land Recent QUIC Changes

net/quic/test_tools/quic_test_utils.h

 // 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.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <vector>
@@ skipping 33 matching lines @@
   // The constructor sets this up to return false by default.
   MOCK_METHOD1(OnProtocolVersionMismatch, bool(QuicVersionTag version));
   MOCK_METHOD0(OnPacket, void());
   MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header));
   MOCK_METHOD1(OnVersionNegotiationPacket,
                void(const QuicVersionNegotiationPacket& packet));
   MOCK_METHOD0(OnRevivedPacket, void());
   // The constructor sets this up to return true by default.
   MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header));
   MOCK_METHOD1(OnFecProtectedPayload, void(base::StringPiece payload));
-  MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame& frame));
-  MOCK_METHOD1(OnAckFrame, void(const QuicAckFrame& frame));
+  MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame));
+  MOCK_METHOD1(OnAckFrame, bool(const QuicAckFrame& frame));
   MOCK_METHOD1(OnCongestionFeedbackFrame,
-               void(const QuicCongestionFeedbackFrame& frame));
+               bool(const QuicCongestionFeedbackFrame& frame));
   MOCK_METHOD1(OnFecData, void(const QuicFecData& fec));
-  MOCK_METHOD1(OnRstStreamFrame, void(const QuicRstStreamFrame& frame));
+  MOCK_METHOD1(OnRstStreamFrame, bool(const QuicRstStreamFrame& frame));
   MOCK_METHOD1(OnConnectionCloseFrame,
-               void(const QuicConnectionCloseFrame& frame));
-  MOCK_METHOD1(OnGoAwayFrame, void(const QuicGoAwayFrame& frame));
+               bool(const QuicConnectionCloseFrame& frame));
+  MOCK_METHOD1(OnGoAwayFrame, bool(const QuicGoAwayFrame& frame));
   MOCK_METHOD0(OnPacketComplete, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFramerVisitor);
 };
 
 class NoOpFramerVisitor : public QuicFramerVisitorInterface {
  public:
   NoOpFramerVisitor() {}
 
   virtual void OnError(QuicFramer* framer) OVERRIDE {}
   virtual void OnPacket() OVERRIDE {}
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) OVERRIDE {}
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) OVERRIDE {}
   virtual void OnRevivedPacket() OVERRIDE {}
   virtual bool OnProtocolVersionMismatch(QuicVersionTag version) OVERRIDE;
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
   virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {}
-  virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE {}
-  virtual void OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE {}
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
+  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+  virtual bool OnCongestionFeedbackFrame(
+      const QuicCongestionFeedbackFrame& frame) OVERRIDE;
   virtual void OnFecData(const QuicFecData& fec) OVERRIDE {}
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {}
-  virtual void OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE {}
-  virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {}
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+  virtual bool OnConnectionCloseFrame(
+      const QuicConnectionCloseFrame& frame) OVERRIDE;
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
   virtual void OnPacketComplete() OVERRIDE {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
 };
 
 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
  public:
   FramerVisitorCapturingPublicReset();
   virtual ~FramerVisitorCapturingPublicReset();
@@ skipping 11 matching lines @@
 
 class FramerVisitorCapturingFrames : public NoOpFramerVisitor {
  public:
   FramerVisitorCapturingFrames();
   virtual ~FramerVisitorCapturingFrames();
 
   // NoOpFramerVisitor
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) OVERRIDE;
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
-  virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
-  virtual void OnCongestionFeedbackFrame(
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
+  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+  virtual bool OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) OVERRIDE;
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
-  virtual void OnConnectionCloseFrame(
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+  virtual bool OnConnectionCloseFrame(
       const QuicConnectionCloseFrame& frame) OVERRIDE;
-  virtual void OnGoAwayFrame(const QuicGoAwayFrame& 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_;
   }
   QuicAckFrame* ack() { return ack_.get(); }
   QuicCongestionFeedbackFrame* feedback() { return feedback_.get(); }
   QuicRstStreamFrame* rst() { return rst_.get(); }
   QuicConnectionCloseFrame* close() { return close_.get(); }
@@ skipping 178 matching lines @@
 
   virtual QuicPacketEntropyHash ReceivedEntropyHash(
       QuicPacketSequenceNumber sequence_number) const OVERRIDE;
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_