X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fnet%2Ftools%2Fquic%2Ftest_tools%2Fquic_test_client.h;h=837f1549e95e901437e88f775816b2e9441a428d;hb=004985e17e624662a4c85c76a7654039dc83f028;hp=7a0ab82d537bfaea2d09aa0626240f2eba46cb2a;hpb=2f108dbacb161091e42a3479f4e171339b7e7623;p=platform%2Fframework%2Fweb%2Fcrosswalk.git diff --git a/src/net/tools/quic/test_tools/quic_test_client.h b/src/net/tools/quic/test_tools/quic_test_client.h index 7a0ab82..837f154 100644 --- a/src/net/tools/quic/test_tools/quic_test_client.h +++ b/src/net/tools/quic/test_tools/quic_test_client.h @@ -2,22 +2,24 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_ -#define NET_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_ +#ifndef NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_ +#define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_ #include #include "base/basictypes.h" #include "base/memory/scoped_ptr.h" +#include "net/base/ip_endpoint.h" #include "net/quic/quic_framer.h" #include "net/quic/quic_packet_creator.h" #include "net/quic/quic_protocol.h" +#include "net/tools/balsa/balsa_frame.h" #include "net/tools/quic/quic_client.h" +#include "net/tools/quic/test_tools/simple_client.h" namespace net { class ProofVerifier; -class QuicSessionKey; namespace tools { @@ -28,21 +30,50 @@ namespace test { class HTTPMessage; class MockableQuicClient; -// A toy QUIC client used for testing. -class QuicTestClient : public QuicDataStream::Visitor { +// A quic client which allows mocking out writes. +class MockableQuicClient : public QuicClient { + public: + MockableQuicClient(IPEndPoint server_address, + const QuicServerId& server_id, + const QuicVersionVector& supported_versions, + uint32 initial_flow_control_window); + + MockableQuicClient(IPEndPoint server_address, + const QuicServerId& server_id, + const QuicConfig& config, + const QuicVersionVector& supported_versions, + uint32 initial_flow_control_window); + + virtual ~MockableQuicClient() OVERRIDE; + virtual QuicPacketWriter* CreateQuicPacketWriter() OVERRIDE; + virtual QuicConnectionId GenerateConnectionId() OVERRIDE; + void UseWriter(QuicPacketWriterWrapper* writer); + void UseConnectionId(QuicConnectionId connection_id); + + private: + QuicConnectionId override_connection_id_; // ConnectionId to use, if nonzero + QuicPacketWriterWrapper* test_writer_; + + DISALLOW_COPY_AND_ASSIGN(MockableQuicClient); +}; + +// A toy QUIC client used for testing, mostly following the SimpleClient APIs. +class QuicTestClient : public SimpleClient, + public QuicDataStream::Visitor { public: QuicTestClient(IPEndPoint server_address, - const QuicSessionKey& server_key, + const string& server_hostname, const QuicVersionVector& supported_versions); QuicTestClient(IPEndPoint server_address, - const QuicSessionKey& server_key, + const string& server_hostname, bool secure, const QuicVersionVector& supported_versions); QuicTestClient(IPEndPoint server_address, - const QuicSessionKey& server_key, + const string& server_hostname, bool secure, const QuicConfig& config, - const QuicVersionVector& supported_versions); + const QuicVersionVector& supported_versions, + uint32 client_initial_flow_control_receive_window); virtual ~QuicTestClient(); @@ -51,39 +82,50 @@ class QuicTestClient : public QuicDataStream::Visitor { // name is recorded and available with |cert_common_name()|. void ExpectCertificates(bool on); - // Clears any outstanding state and sends a simple GET of 'uri' to the - // server. Returns 0 if the request failed and no bytes were written. - ssize_t SendRequest(const string& uri); - ssize_t SendMessage(const HTTPMessage& message); - - string SendCustomSynchronousRequest(const HTTPMessage& message); - string SendSynchronousRequest(const string& uri); - // Wraps data in a quic packet and sends it. ssize_t SendData(string data, bool last_data); QuicPacketCreator::Options* options(); - void WaitForResponse(); - - void Connect(); - void ResetConnection(); - void Disconnect(); - IPEndPoint LocalSocketAddress() const; - void ClearPerRequestState(); - void WaitForResponseForMs(int timeout_ms); - void WaitForInitialResponseForMs(int timeout_ms); - ssize_t Send(const void *buffer, size_t size); - bool response_complete() const { return response_complete_; } - bool response_headers_complete() const; - const BalsaHeaders* response_headers() const; - int response_size() const; - int response_header_size() const { return response_header_size_; } - int response_body_size() const { return response_body_size_; } - size_t bytes_read() const; - size_t bytes_written() const; - bool buffer_body() const { return buffer_body_; } - void set_buffer_body(bool buffer_body) { buffer_body_ = buffer_body; } + // From SimpleClient + // Clears any outstanding state and sends a simple GET of 'uri' to the + // server. Returns 0 if the request failed and no bytes were written. + virtual ssize_t SendRequest(const string& uri) OVERRIDE; + virtual ssize_t SendMessage(const HTTPMessage& message) OVERRIDE; + virtual string SendCustomSynchronousRequest( + const HTTPMessage& message) OVERRIDE; + virtual string SendSynchronousRequest(const string& uri) OVERRIDE; + virtual void Connect() OVERRIDE; + virtual void ResetConnection() OVERRIDE; + virtual void Disconnect() OVERRIDE; + virtual IPEndPoint LocalSocketAddress() const OVERRIDE; + virtual void ClearPerRequestState() OVERRIDE; + virtual void WaitForResponseForMs(int timeout_ms) OVERRIDE; + virtual void WaitForInitialResponseForMs(int timeout_ms) OVERRIDE; + virtual ssize_t Send(const void *buffer, size_t size) OVERRIDE; + virtual bool response_complete() const OVERRIDE; + virtual bool response_headers_complete() const OVERRIDE; + virtual const BalsaHeaders* response_headers() const OVERRIDE; + virtual int64 response_size() const OVERRIDE; + virtual int response_header_size() const OVERRIDE; + virtual int64 response_body_size() const OVERRIDE; + virtual size_t bytes_read() const OVERRIDE; + virtual size_t bytes_written() const OVERRIDE; + virtual bool buffer_body() const OVERRIDE; + virtual void set_buffer_body(bool buffer_body) OVERRIDE; + virtual bool ServerInLameDuckMode() const OVERRIDE; + virtual const string& response_body() OVERRIDE; + virtual bool connected() const OVERRIDE; + // These functions are all unimplemented functions from SimpleClient, and log + // DFATAL if called by users of SimpleClient. + virtual ssize_t SendAndWaitForResponse(const void *buffer, + size_t size) OVERRIDE; + virtual void Bind(IPEndPoint* local_address) OVERRIDE; + virtual string SerializeMessage(const HTTPMessage& message) OVERRIDE; + virtual IPAddressNumber bind_to_address() const OVERRIDE; + virtual void set_bind_to_address(IPAddressNumber address) OVERRIDE; + virtual const IPEndPoint& address() const OVERRIDE; + virtual size_t requests_sent() const OVERRIDE; // From QuicDataStream::Visitor virtual void OnClose(QuicDataStream* stream) OVERRIDE; @@ -101,7 +143,7 @@ class QuicTestClient : public QuicDataStream::Visitor { QuicRstStreamErrorCode stream_error() { return stream_error_; } QuicErrorCode connection_error(); - QuicClient* client(); + MockableQuicClient* client(); // cert_common_name returns the common name value of the server's certificate, // or the empty string if no certificate was presented. @@ -110,23 +152,20 @@ class QuicTestClient : public QuicDataStream::Visitor { // Get the server config map. QuicTagValueMap GetServerConfig() const; - const string& response_body() {return response_;} - bool connected() const; - void set_auto_reconnect(bool reconnect) { auto_reconnect_ = reconnect; } void set_priority(QuicPriority priority) { priority_ = priority; } void WaitForWriteToFlush(); - private: - void Initialize(IPEndPoint address, - const QuicSessionKey& server_key, - bool secure); + protected: + QuicTestClient(); + + void Initialize(bool secure); + + void set_client(MockableQuicClient* client) { client_.reset(client); } - IPEndPoint server_address_; - IPEndPoint client_address_; - QuicSessionKey server_key_; + private: scoped_ptr client_; // The actual client QuicSpdyClientStream* stream_; @@ -142,7 +181,7 @@ class QuicTestClient : public QuicDataStream::Visitor { // The number of uncompressed HTTP header bytes received. int response_header_size_; // The number of HTTP body bytes received. - int response_body_size_; + int64 response_body_size_; // True if we tried to connect already since the last call to Disconnect(). bool connect_attempted_; bool secure_; @@ -156,6 +195,8 @@ class QuicTestClient : public QuicDataStream::Visitor { // proof_verifier_ points to a RecordingProofVerifier that is owned by // client_. ProofVerifier* proof_verifier_; + + DISALLOW_COPY_AND_ASSIGN(QuicTestClient); }; } // namespace test @@ -163,4 +204,4 @@ class QuicTestClient : public QuicDataStream::Visitor { } // namespace tools } // namespace net -#endif // NET_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_ +#endif // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_