1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef NET_SPDY_SPDY_STREAM_TEST_UTIL_H_ 6#define NET_SPDY_SPDY_STREAM_TEST_UTIL_H_ 7 8#include "base/compiler_specific.h" 9#include "base/memory/ref_counted.h" 10#include "base/memory/scoped_ptr.h" 11#include "base/strings/string_piece.h" 12#include "net/base/io_buffer.h" 13#include "net/base/test_completion_callback.h" 14#include "net/spdy/spdy_read_queue.h" 15#include "net/spdy/spdy_stream.h" 16 17namespace net { 18 19namespace test { 20 21// Delegate that calls Close() on |stream_| on OnClose. Used by tests 22// to make sure that such an action is harmless. 23class ClosingDelegate : public SpdyStream::Delegate { 24 public: 25 explicit ClosingDelegate(const base::WeakPtr<SpdyStream>& stream); 26 virtual ~ClosingDelegate(); 27 28 // SpdyStream::Delegate implementation. 29 virtual void OnRequestHeadersSent() OVERRIDE; 30 virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated( 31 const SpdyHeaderBlock& response_headers) OVERRIDE; 32 virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE; 33 virtual void OnDataSent() OVERRIDE; 34 virtual void OnClose(int status) OVERRIDE; 35 36 // Returns whether or not the stream is closed. 37 bool StreamIsClosed() const { return !stream_.get(); } 38 39 private: 40 base::WeakPtr<SpdyStream> stream_; 41}; 42 43// Base class with shared functionality for test delegate 44// implementations below. 45class StreamDelegateBase : public SpdyStream::Delegate { 46 public: 47 explicit StreamDelegateBase(const base::WeakPtr<SpdyStream>& stream); 48 virtual ~StreamDelegateBase(); 49 50 virtual void OnRequestHeadersSent() OVERRIDE; 51 virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated( 52 const SpdyHeaderBlock& response_headers) OVERRIDE; 53 virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE; 54 virtual void OnDataSent() OVERRIDE; 55 virtual void OnClose(int status) OVERRIDE; 56 57 // Waits for the stream to be closed and returns the status passed 58 // to OnClose(). 59 int WaitForClose(); 60 61 // Drains all data from the underlying read queue and returns it as 62 // a string. 63 std::string TakeReceivedData(); 64 65 // Returns whether or not the stream is closed. 66 bool StreamIsClosed() const { return !stream_.get(); } 67 68 // Returns the stream's ID. If called when the stream is closed, 69 // returns the stream's ID when it was open. 70 SpdyStreamId stream_id() const { return stream_id_; } 71 72 std::string GetResponseHeaderValue(const std::string& name) const; 73 bool send_headers_completed() const { return send_headers_completed_; } 74 75 protected: 76 const base::WeakPtr<SpdyStream>& stream() { return stream_; } 77 78 private: 79 base::WeakPtr<SpdyStream> stream_; 80 SpdyStreamId stream_id_; 81 TestCompletionCallback callback_; 82 bool send_headers_completed_; 83 SpdyHeaderBlock response_headers_; 84 SpdyReadQueue received_data_queue_; 85}; 86 87// Test delegate that does nothing. Used to capture data about the 88// stream, e.g. its id when it was open. 89class StreamDelegateDoNothing : public StreamDelegateBase { 90 public: 91 StreamDelegateDoNothing(const base::WeakPtr<SpdyStream>& stream); 92 virtual ~StreamDelegateDoNothing(); 93}; 94 95// Test delegate that sends data immediately in OnResponseHeadersUpdated(). 96class StreamDelegateSendImmediate : public StreamDelegateBase { 97 public: 98 // |data| can be NULL. 99 StreamDelegateSendImmediate(const base::WeakPtr<SpdyStream>& stream, 100 base::StringPiece data); 101 virtual ~StreamDelegateSendImmediate(); 102 103 virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated( 104 const SpdyHeaderBlock& response_headers) OVERRIDE; 105 106 private: 107 base::StringPiece data_; 108}; 109 110// Test delegate that sends body data. 111class StreamDelegateWithBody : public StreamDelegateBase { 112 public: 113 StreamDelegateWithBody(const base::WeakPtr<SpdyStream>& stream, 114 base::StringPiece data); 115 virtual ~StreamDelegateWithBody(); 116 117 virtual void OnRequestHeadersSent() OVERRIDE; 118 119 private: 120 scoped_refptr<StringIOBuffer> buf_; 121}; 122 123// Test delegate that closes stream in OnResponseHeadersUpdated(). 124class StreamDelegateCloseOnHeaders : public StreamDelegateBase { 125 public: 126 StreamDelegateCloseOnHeaders(const base::WeakPtr<SpdyStream>& stream); 127 virtual ~StreamDelegateCloseOnHeaders(); 128 129 virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated( 130 const SpdyHeaderBlock& response_headers) OVERRIDE; 131}; 132 133} // namespace test 134 135} // namespace net 136 137#endif // NET_SPDY_SPDY_STREAM_TEST_UTIL_H_ 138