net/quic/quic_reliable_client_stream.cc

   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 #include "net/quic/quic_reliable_client_stream.h"
   6
   7 #include "base/callback_helpers.h"
   8 #include "net/base/net_errors.h"
   9 #include "net/quic/quic_session.h"
  10 #include "net/quic/quic_write_blocked_list.h"
  11
  12 namespace net {
  13
  14 QuicReliableClientStream::QuicReliableClientStream(QuicStreamId id,
  15                                                    QuicSession* session,
  16                                                    const BoundNetLog& net_log)
  17     : QuicDataStream(id, session),
  18       net_log_(net_log),
  19       delegate_(nullptr) {
  20 }
  21
  22 QuicReliableClientStream::~QuicReliableClientStream() {
  23   if (delegate_)
  24     delegate_->OnClose(connection_error());
  25 }
  26
  27 uint32 QuicReliableClientStream::ProcessData(const char* data,
  28                                              uint32 data_len) {
  29   // TODO(rch): buffer data if we don't have a delegate.
  30   if (!delegate_) {
  31     DLOG(ERROR) << "Missing delegate";
  32     Reset(QUIC_STREAM_CANCELLED);
  33     return 0;
  34   }
  35
  36   int rv = delegate_->OnDataReceived(data, data_len);
  37   if (rv != OK) {
  38     DLOG(ERROR) << "Delegate refused data, rv: " << rv;
  39     Reset(QUIC_BAD_APPLICATION_PAYLOAD);
  40     return 0;
  41   }
  42   return data_len;
  43 }
  44
  45 void QuicReliableClientStream::OnClose() {
  46   if (delegate_) {
  47     delegate_->OnClose(connection_error());
  48     delegate_ = nullptr;
  49   }
  50   ReliableQuicStream::OnClose();
  51 }
  52
  53 void QuicReliableClientStream::OnCanWrite() {
  54   ReliableQuicStream::OnCanWrite();
  55
  56   if (!HasBufferedData() && !callback_.is_null()) {
  57     base::ResetAndReturn(&callback_).Run(OK);
  58   }
  59 }
  60
  61 QuicPriority QuicReliableClientStream::EffectivePriority() const {
  62   if (delegate_ && delegate_->HasSendHeadersComplete()) {
  63     return QuicDataStream::EffectivePriority();
  64   }
  65   return QuicWriteBlockedList::kHighestPriority;
  66 }
  67
  68 int QuicReliableClientStream::WriteStreamData(
  69     base::StringPiece data,
  70     bool fin,
  71     const CompletionCallback& callback) {
  72   // We should not have data buffered.
  73   DCHECK(!HasBufferedData());
  74   // Writes the data, or buffers it.
  75   WriteOrBufferData(data, fin, nullptr);
  76   if (!HasBufferedData()) {
  77     return OK;
  78   }
  79
  80   callback_ = callback;
  81   return ERR_IO_PENDING;
  82 }
  83
  84 void QuicReliableClientStream::SetDelegate(
  85     QuicReliableClientStream::Delegate* delegate) {
  86   DCHECK(!(delegate_ && delegate));
  87   delegate_ = delegate;
  88 }
  89
  90 void QuicReliableClientStream::OnError(int error) {
  91   if (delegate_) {
  92     QuicReliableClientStream::Delegate* delegate = delegate_;
  93     delegate_ = nullptr;
  94     delegate->OnError(error);
  95   }
  96 }
  97
  98 bool QuicReliableClientStream::CanWrite(const CompletionCallback& callback) {
  99   bool can_write =  session()->connection()->CanWrite(HAS_RETRANSMITTABLE_DATA);
 100   if (!can_write) {
 101     session()->MarkWriteBlocked(id(), EffectivePriority());
 102     DCHECK(callback_.is_null());
 103     callback_ = callback;
 104   }
 105   return can_write;
 106 }
 107
 108 }  // namespace net