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
17namespace net {
18
19class QuicClientSession;
20
21// A client-initiated ReliableQuicStream.  Instances of this class
22// are owned by the QuicClientSession which created them.
23class 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 OnClose() 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