Home | History | Annotate | Download | only in quic 
      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 // NOTE: This code is not shared between Google and Chrome.
      6 
      7 #ifndef NET_QUIC_QUIC_RELIABLE_CLIENT_STREAM_H_
      8 #define NET_QUIC_QUIC_RELIABLE_CLIENT_STREAM_H_
      9 
     10 #include "net/base/ip_endpoint.h"
     11 #include "net/base/upload_data_stream.h"
     12 #include "net/http/http_request_info.h"
     13 #include "net/http/http_response_info.h"
     14 #include "net/http/http_stream.h"
     15 #include "net/quic/quic_data_stream.h"
     16 
     17 namespace net {
     18 
     19 class QuicClientSession;
     20 
     21 // A client-initiated ReliableQuicStream.  Instances of this class
     22 // are owned by the QuicClientSession which created them.
     23 class NET_EXPORT_PRIVATE QuicReliableClientStream : public QuicDataStream {
     24  public:
     25   // Delegate handles protocol specific behavior of a quic stream.
     26   class NET_EXPORT_PRIVATE Delegate {
     27    public:
     28     Delegate() {}
     29 
     30     // Called when data is received.
     31     // Returns network error code. OK when it successfully receives data.
     32     virtual int OnDataReceived(const char* data, int length) = 0;
     33 
     34     // Called when the stream is closed by the peer.
     35     virtual void OnClose(QuicErrorCode error) = 0;
     36 
     37     // Called when the stream is closed because of an error.
     38     virtual void OnError(int error) = 0;
     39 
     40     // Returns true if sending of headers has completed.
     41     virtual bool HasSendHeadersComplete() = 0;
     42 
     43    protected:
     44     virtual ~Delegate() {}
     45 
     46    private:
     47     DISALLOW_COPY_AND_ASSIGN(Delegate);
     48   };
     49 
     50   QuicReliableClientStream(QuicStreamId id,
     51                            QuicSession* session,
     52                            const BoundNetLog& net_log);
     53 
     54   virtual ~QuicReliableClientStream();
     55 
     56   // QuicDataStream
     57   virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
     58   virtual void OnFinRead() OVERRIDE;
     59   virtual void OnCanWrite() OVERRIDE;
     60   virtual QuicPriority EffectivePriority() const OVERRIDE;
     61 
     62   // While the server's set_priority shouldn't be called externally, the creator
     63   // of client-side streams should be able to set the priority.
     64   using QuicDataStream::set_priority;
     65 
     66   int WriteStreamData(base::StringPiece data,
     67                       bool fin,
     68                       const CompletionCallback& callback);
     69   // Set new |delegate|. |delegate| must not be NULL.
     70   // If this stream has already received data, OnDataReceived() will be
     71   // called on the delegate.
     72   void SetDelegate(Delegate* delegate);
     73   Delegate* GetDelegate() { return delegate_; }
     74   void OnError(int error);
     75 
     76   // Returns true if the stream can possible write data.  (The socket may
     77   // turn out to be write blocked, of course).  If the stream can not write,
     78   // this method returns false, and |callback| will be invoked when
     79   // it becomes writable.
     80   bool CanWrite(const CompletionCallback& callback);
     81 
     82   const BoundNetLog& net_log() const { return net_log_; }
     83 
     84   using QuicDataStream::HasBufferedData;
     85 
     86  private:
     87   BoundNetLog net_log_;
     88   Delegate* delegate_;
     89 
     90   CompletionCallback callback_;
     91 
     92   DISALLOW_COPY_AND_ASSIGN(QuicReliableClientStream);
     93 };
     94 
     95 }  // namespace net
     96 
     97 #endif  // NET_QUIC_QUIC_RELIABLE_CLIENT_STREAM_H_
     98