Revert 165858 - Add QuicStream and friends to QUIC code.

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 "net/quic/congestion_control/quic_send_scheduler.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_framer.h"
-#include "net/quic/quic_session.h"
-#include "net/quic/test_tools/mock_clock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace net {
 
 namespace test {
 
 void CompareCharArraysWithHexError(const std::string& description,
                                    const char* actual,
                                    const int actual_len,
                                    const char* expected,
@@ skipping 36 matching lines @@
   virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
   virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {}
   virtual void OnAckFrame(const QuicAckFrame& 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 OnPacketComplete() OVERRIDE {}
 };
 
+
 class FramerVisitorCapturingAcks : public NoOpFramerVisitor {
  public:
   // NoOpFramerVisitor
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
   virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
 
   QuicPacketHeader* header() { return &header_; }
   QuicAckFrame* frame() { return &frame_; }
  private:
   QuicPacketHeader header_;
   QuicAckFrame frame_;
 };
 
 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
  public:
   MockConnectionVisitor();
-  virtual ~MockConnectionVisitor();
+  ~MockConnectionVisitor();
   MOCK_METHOD4(OnPacket, bool(const IPEndPoint& self_address,
                               const IPEndPoint& peer_address,
                               const QuicPacketHeader& header,
                               const std::vector<QuicStreamFrame>& frame));
   MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
   MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
   MOCK_METHOD1(OnAck, void(AckedPackets acked_packets));
 };
 
 class MockScheduler : public QuicSendScheduler {
  public:
   MockScheduler();
   virtual ~MockScheduler();
 
   MOCK_METHOD1(TimeUntilSend, int(bool));
   MOCK_METHOD1(OnIncomingAckFrame, void(const QuicAckFrame&));
   MOCK_METHOD3(SentPacket, void(QuicPacketSequenceNumber, size_t, bool));
 };
 
-class MockHelper : public QuicConnectionHelperInterface {
- public:
-  MockHelper();
-  virtual ~MockHelper();
-
-  MOCK_METHOD1(SetConnection, void(QuicConnection* connection));
-  QuicClock* GetClock();
-  MOCK_METHOD4(WritePacketToWire, int(QuicPacketSequenceNumber number,
-                                      const QuicEncryptedPacket& packet,
-                                      bool resend,
-                                      int* error));
-  MOCK_METHOD2(SetResendAlarm, void(QuicPacketSequenceNumber sequence_number,
-                                    uint64 delay_in_us));
-  MOCK_METHOD1(SetSendAlarm, void(uint64 delay_in_us));
-  MOCK_METHOD1(SetTimeoutAlarm, void(uint64 delay_in_us));
-  MOCK_METHOD0(IsSendAlarmSet, bool());
-  MOCK_METHOD0(UnregisterSendAlarmIfRegistered, void());
- private:
-  MockClock clock_;
-};
-
-class MockConnection : public QuicConnection {
- public:
-  MockConnection(QuicGuid guid, IPEndPoint address);
-  virtual ~MockConnection();
-
-  MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address,
-                                      const IPEndPoint& peer_address,
-                                      const QuicEncryptedPacket& packet));
-  MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
-
-  MOCK_METHOD3(SendRstStream, void(QuicStreamId id,
-                                   QuicErrorCode error,
-                                   QuicStreamOffset offset));
-
-  MOCK_METHOD0(OnCanWrite, bool());
-};
-
-class PacketSavingConnection : public MockConnection {
- public:
-  PacketSavingConnection(QuicGuid guid, IPEndPoint address);
-  virtual ~PacketSavingConnection();
-
-  virtual bool SendPacket(QuicPacketSequenceNumber number,
-                          QuicPacket* packet,
-                          bool resend,
-                          bool force) OVERRIDE;
-
-  std::vector<QuicPacket*> packets_;
-};
-
-class MockSession : public QuicSession {
- public:
-  MockSession(QuicConnection* connection, bool is_server);
-  ~MockSession();
-
-  MOCK_METHOD4(OnPacket, bool(const IPEndPoint& seld_address,
-                              const IPEndPoint& peer_address,
-                              const QuicPacketHeader& header,
-                              const std::vector<QuicStreamFrame>& frame));
-  MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
-  MOCK_METHOD1(CreateIncomingReliableStream,
-               ReliableQuicStream*(QuicStreamId id));
-  MOCK_METHOD0(GetCryptoStream, QuicCryptoStream*());
-  MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
-  MOCK_METHOD3(WriteData,
-               void(QuicStreamId id, base::StringPiece data, bool fin));
-  MOCK_METHOD4(WriteData, int(QuicStreamId id, base::StringPiece data,
-                              QuicStreamOffset offset, bool fin));
-  MOCK_METHOD0(IsHandshakeComplete, bool());
-};
-
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_