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