// 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 <string>
#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 {
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();
// 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;
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.
// 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<MockableQuicClient> client_; // The actual client
QuicSpdyClientStream* stream_;
// 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_;
// proof_verifier_ points to a RecordingProofVerifier that is owned by
// client_.
ProofVerifier* proof_verifier_;
+
+ DISALLOW_COPY_AND_ASSIGN(QuicTestClient);
};
} // namespace test
} // namespace tools
} // namespace net
-#endif // NET_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
+#endif // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
projects / platform / framework / web / crosswalk.git / blobdiff