blob: 225149254b67cdcc6c63d5cf5d20cec685483fde [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// NOTE: This code is not shared between Google and Chrome.
#include "net/base/ip_endpoint.h"
#include "net/base/upload_data_stream.h"
#include "net/http/http_request_info.h"
#include "net/http/http_response_info.h"
#include "net/http/http_stream.h"
#include "net/quic/quic_data_stream.h"
namespace net {
class QuicClientSession;
// A client-initiated ReliableQuicStream. Instances of this class
// are owned by the QuicClientSession which created them.
class NET_EXPORT_PRIVATE QuicReliableClientStream : public QuicDataStream {
// Delegate handles protocol specific behavior of a quic stream.
class NET_EXPORT_PRIVATE Delegate {
Delegate() {}
// Called when data is received.
// Returns network error code. OK when it successfully receives data.
virtual int OnDataReceived(const char* data, int length) = 0;
// Called when the stream is closed by the peer.
virtual void OnClose(QuicErrorCode error) = 0;
// Called when the stream is closed because of an error.
virtual void OnError(int error) = 0;
// Returns true if sending of headers has completed.
virtual bool HasSendHeadersComplete() = 0;
virtual ~Delegate() {}
QuicReliableClientStream(QuicStreamId id,
QuicSession* session,
const BoundNetLog& net_log);
virtual ~QuicReliableClientStream();
// QuicDataStream
virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
virtual void OnClose() OVERRIDE;
virtual void OnCanWrite() OVERRIDE;
virtual QuicPriority EffectivePriority() const OVERRIDE;
// While the server's set_priority shouldn't be called externally, the creator
// of client-side streams should be able to set the priority.
using QuicDataStream::set_priority;
int WriteStreamData(base::StringPiece data,
bool fin,
const CompletionCallback& callback);
// Set new |delegate|. |delegate| must not be NULL.
// If this stream has already received data, OnDataReceived() will be
// called on the delegate.
void SetDelegate(Delegate* delegate);
Delegate* GetDelegate() { return delegate_; }
void OnError(int error);
// Returns true if the stream can possible write data. (The socket may
// turn out to be write blocked, of course). If the stream can not write,
// this method returns false, and |callback| will be invoked when
// it becomes writable.
bool CanWrite(const CompletionCallback& callback);
const BoundNetLog& net_log() const { return net_log_; }
using QuicDataStream::HasBufferedData;
BoundNetLog net_log_;
Delegate* delegate_;
CompletionCallback callback_;
} // namespace net