Move the async write handling from QuicChromiumClientStream to the Handle

net/quic/chromium/quic_chromium_client_stream.cc

 // 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.
 
 #include "net/quic/chromium/quic_chromium_client_stream.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
@@ skipping 55 matching lines @@
 
   int rv = stream_->Read(read_body_buffer_, read_body_buffer_len_);
   if (rv == ERR_IO_PENDING)
     return;  // Spurrious, likely because of trailers?
 
   read_body_buffer_ = nullptr;
   read_body_buffer_len_ = 0;
   ResetAndReturn(&read_body_callback_).Run(rv);
 }
 
+void QuicChromiumClientStream::Handle::OnCanWrite() {
+  if (!write_callback_)
+    return;
+
+  base::ResetAndReturn(&write_callback_).Run(OK);
+}
+
 void QuicChromiumClientStream::Handle::OnClose() {
   if (stream_)
     SaveState();
   stream_ = nullptr;
   if (delegate_) {
     auto* delegate = delegate_;
     delegate_ = nullptr;
     delegate->OnClose();
   }
 }
@@ skipping 51 matching lines @@
   return stream_->WriteHeaders(std::move(header_block), fin,
                                ack_notifier_delegate);
 }
 
 int QuicChromiumClientStream::Handle::WriteStreamData(
     base::StringPiece data,
     bool fin,
     const CompletionCallback& callback) {
   if (!stream_)
     return ERR_CONNECTION_CLOSED;
-  return stream_->WriteStreamData(data, fin, callback);
+
+  if (stream_->WriteStreamData(data, fin))
+    return OK;
+
+  write_callback_ = callback;
+  return ERR_IO_PENDING;
 }
 
 int QuicChromiumClientStream::Handle::WritevStreamData(
     const std::vector<scoped_refptr<IOBuffer>>& buffers,
     const std::vector<int>& lengths,
     bool fin,
     const CompletionCallback& callback) {
   if (!stream_)
     return ERR_CONNECTION_CLOSED;
-  return stream_->WritevStreamData(buffers, lengths, fin, callback);
+
+  if (stream_->WritevStreamData(buffers, lengths, fin))
+    return OK;
+
+  write_callback_ = callback;
+  return ERR_IO_PENDING;
 }
 
 int QuicChromiumClientStream::Handle::Read(IOBuffer* buf, int buf_len) {
   if (!stream_)
     return ERR_CONNECTION_CLOSED;
   return stream_->Read(buf, buf_len);
 }
 
 void QuicChromiumClientStream::Handle::OnFinRead() {
   if (stream_)
@@ skipping 211 matching lines @@
   if (handle_) {
     handle_->OnClose();
     handle_ = nullptr;
   }
   QuicStream::OnClose();
 }
 
 void QuicChromiumClientStream::OnCanWrite() {
   QuicStream::OnCanWrite();
 
-  if (!HasBufferedData() && !write_callback_.is_null()) {
-    base::ResetAndReturn(&write_callback_).Run(OK);
-  }
+  if (!HasBufferedData() && handle_)
+    handle_->OnCanWrite();
 }
 
 size_t QuicChromiumClientStream::WriteHeaders(
     SpdyHeaderBlock header_block,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (!session()->IsCryptoHandshakeConfirmed()) {
     auto entry = header_block.find(":method");
     DCHECK(entry != header_block.end());
     DCHECK_NE("POST", entry->second);
   }
   net_log_.AddEvent(
       NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
       base::Bind(&QuicRequestNetLogCallback, id(), &header_block,
                  QuicSpdyStream::priority()));
   size_t len = QuicSpdyStream::WriteHeaders(std::move(header_block), fin,
                                             std::move(ack_listener));
   initial_headers_sent_ = true;
   return len;
 }
 
 SpdyPriority QuicChromiumClientStream::priority() const {
   return initial_headers_sent_ ? QuicSpdyStream::priority()
                                : kV3HighestPriority;
 }
 
-int QuicChromiumClientStream::WriteStreamData(
-    QuicStringPiece data,
-    bool fin,
-    const CompletionCallback& callback) {
-  // We should not have data buffered.
+bool QuicChromiumClientStream::WriteStreamData(QuicStringPiece data, bool fin) {
+  // Must not be called when data is buffered.
   DCHECK(!HasBufferedData());
   // Writes the data, or buffers it.
   WriteOrBufferData(data, fin, nullptr);
-  if (!HasBufferedData()) {
-    return OK;
-  }
-
-  write_callback_ = callback;
-  return ERR_IO_PENDING;
+  return !HasBufferedData();  // Was all data written?
 }
 
-int QuicChromiumClientStream::WritevStreamData(
+bool QuicChromiumClientStream::WritevStreamData(
     const std::vector<scoped_refptr<IOBuffer>>& buffers,
     const std::vector<int>& lengths,
-    bool fin,
-    const CompletionCallback& callback) {
+    bool fin) {
   // Must not be called when data is buffered.
   DCHECK(!HasBufferedData());
   // Writes the data, or buffers it.
   for (size_t i = 0; i < buffers.size(); ++i) {
     bool is_fin = fin && (i == buffers.size() - 1);
     QuicStringPiece string_data(buffers[i]->data(), lengths[i]);
     WriteOrBufferData(string_data, is_fin, nullptr);
   }
-  if (!HasBufferedData()) {
-    return OK;
-  }
-
-  write_callback_ = callback;
-  return ERR_IO_PENDING;
+  return !HasBufferedData();  // Was all data written?
 }
 
 std::unique_ptr<QuicChromiumClientStream::Handle>
 QuicChromiumClientStream::CreateHandle(
     QuicChromiumClientStream::Delegate* delegate) {
   DCHECK(!handle_);
   auto handle = std::unique_ptr<QuicChromiumClientStream::Handle>(
       new QuicChromiumClientStream::Handle(this, delegate));
   handle_ = handle.get();
 
@@ skipping 108 matching lines @@
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 bool QuicChromiumClientStream::IsFirstStream() {
   return id() == kHeadersStreamId + 2;
 }
 
 }  // namespace net