Home | History | Annotate | Download | only in spdy 
      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 
     17 namespace net {
     18 
     19 namespace test {
     20 
     21 // Delegate that calls Close() on |stream_| on OnClose. Used by tests
     22 // to make sure that such an action is harmless.
     23 class 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.
     45 class 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.
     89 class 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().
     96 class 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.
    111 class 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().
    124 class 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