Remove QuicChromiumClientStream::Delegate in favor of async methods.

net/quic/chromium/quic_http_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_http_stream.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
@@ skipping 46 matching lines @@
       response_status_(ERR_UNEXPECTED),
       response_headers_received_(false),
       trailing_headers_received_(false),
       headers_bytes_received_(0),
       headers_bytes_sent_(0),
       closed_stream_received_bytes_(0),
       closed_stream_sent_bytes_(0),
       closed_is_first_stream_(false),
       user_buffer_len_(0),
       session_error_(ERR_UNEXPECTED),
-      quic_connection_error_(QUIC_NO_ERROR),
-      quic_stream_error_(QUIC_STREAM_NO_ERROR),
       found_promise_(false),
       push_handle_(nullptr),
       in_loop_(false),
       weak_factory_(this) {}
 
 QuicHttpStream::~QuicHttpStream() {
   CHECK(!in_loop_);
   Close(false);
 }
 
@@ skipping 21 matching lines @@
     return true;
   }
   // Now compare the client request for matching.
   return vary_data.MatchesRequest(client_request_info,
                                   *promise_response_info.headers.get());
 }
 
 void QuicHttpStream::OnRendezvousResult(QuicSpdyStream* stream) {
   push_handle_ = nullptr;
   if (stream) {
-    stream_ =
-        static_cast<QuicChromiumClientStream*>(stream)->CreateHandle(this);
+    stream_ = static_cast<QuicChromiumClientStream*>(stream)->CreateHandle();
   }
 
   // callback_ should only be non-null in the case of asynchronous
   // rendezvous; i.e. |Try()| returned QUIC_PENDING.
   if (callback_.is_null())
     return;
 
   DCHECK_EQ(STATE_HANDLE_PROMISE_COMPLETE, next_state_);
   if (!stream) {
     // rendezvous has failed so proceed as with a non-push request.
@@ skipping 64 matching lines @@
         base::Bind(&NetLogQuicPushStreamCallback, promised->id(),
                    &request_info_->url));
     return OK;
   }
 
   next_state_ = STATE_REQUEST_STREAM;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
-  return rv;
+  return MapStreamError(rv);
 }
 
 int QuicHttpStream::DoHandlePromise() {
   QuicAsyncStatus push_status = quic_session()->GetPushPromiseIndex()->Try(
       request_headers_, this, &this->push_handle_);
 
   switch (push_status) {
     case QUIC_FAILURE:
       // Push rendezvous failed.
       next_state_ = STATE_REQUEST_STREAM;
@@ skipping 91 matching lines @@
     next_state_ = STATE_HANDLE_PROMISE;
   } else {
     found_promise_ = false;
     next_state_ = STATE_REQUEST_STREAM;
   }
   rv = DoLoop(OK);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
-  return rv > 0 ? OK : rv;
+  return rv > 0 ? OK : MapStreamError(rv);
 }
 
 int QuicHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   CHECK(!callback.is_null());
 
-  if (stream_ == nullptr)
-    return GetResponseStatus();
-
   int rv = stream_->ReadInitialHeaders(
       &response_header_block_,
       base::Bind(&QuicHttpStream::OnReadResponseHeadersComplete,
                  weak_factory_.GetWeakPtr()));
 
   if (rv == ERR_IO_PENDING) {
     // Still waiting for the response, return IO_PENDING.
     CHECK(callback_.is_null());
     callback_ = callback;
     return ERR_IO_PENDING;
   }
 
   if (rv < 0)
-    return rv;
+    return MapStreamError(rv);
 
   // Check if we already have the response headers. If so, return synchronously.
   if (response_headers_received_)
     return OK;
 
   headers_bytes_received_ += rv;
   return ProcessResponseHeaders(response_header_block_);
 }
 
 int QuicHttpStream::ReadResponseBody(IOBuffer* buf,
                                      int buf_len,
                                      const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   CHECK(!callback.is_null());
   CHECK(!user_buffer_.get());
   CHECK_EQ(0, user_buffer_len_);
 
   // Invalidate HttpRequestInfo pointer. This is to allow the stream to be
   // shared across multiple transactions which might require this
   // stream to outlive the request_info_'s owner.
   // Only allowed when Read state machine starts. It is safe to reset it at
   // this point since request_info_->upload_data_stream is also not needed
   // anymore.
   request_info_ = nullptr;
 
   // If the stream is already closed, there is no body to read.
-  if (!stream_)
+  if (stream_->IsDoneReading())
     return GetResponseStatus();
 
   int rv = stream_->ReadBody(buf, buf_len,
                              base::Bind(&QuicHttpStream::OnReadBodyComplete,
                                         weak_factory_.GetWeakPtr()));
   if (rv == ERR_IO_PENDING) {
     callback_ = callback;
     user_buffer_ = buf;
     user_buffer_len_ = buf_len;
     return ERR_IO_PENDING;
   }
 
   if (rv < 0)
-    return rv;
+    return MapStreamError(rv);
 
   return HandleReadComplete(rv);
 }
 
 void QuicHttpStream::Close(bool /*not_reusable*/) {
   session_error_ = ERR_ABORTED;
   SaveResponseStatus();
   // Note: the not_reusable flag has no meaning for QUIC streams.
-  if (stream_) {
-    stream_->ClearDelegate();
+  if (stream_)
     stream_->Reset(QUIC_STREAM_CANCELLED);
-  }
   ResetStream();
 }
 
 bool QuicHttpStream::IsResponseBodyComplete() const {
-  return next_state_ == STATE_OPEN && !stream_;
+  return next_state_ == STATE_OPEN && stream_->IsDoneReading();
 }
 
 bool QuicHttpStream::IsConnectionReused() const {
   // TODO(rch): do something smarter here.
   return stream_ && stream_->id() > 1;
 }
 
 int64_t QuicHttpStream::GetTotalReceivedBytes() const {
   // TODO(sclittle): Currently, this only includes headers and response body
   // bytes. Change this to include QUIC overhead as well.
@@ skipping 38 matching lines @@
   alternative_service->protocol = kProtoQUIC;
   alternative_service->host = quic_session()->server_id().host();
   alternative_service->port = quic_session()->server_id().port();
   return true;
 }
 
 void QuicHttpStream::PopulateNetErrorDetails(NetErrorDetails* details) {
   details->connection_info =
       ConnectionInfoFromQuicVersion(quic_session()->GetQuicVersion());
   quic_session()->PopulateNetErrorDetails(details);
-  if (quic_session()->IsCryptoHandshakeConfirmed())
-    details->quic_connection_error = quic_connection_error_;
+  if (quic_session()->IsCryptoHandshakeConfirmed() && stream_)
+    details->quic_connection_error = stream_->connection_error();
 }
 
 void QuicHttpStream::SetPriority(RequestPriority priority) {
   priority_ = priority;
 }
 
 void QuicHttpStream::OnReadResponseHeadersComplete(int rv) {
   DCHECK(callback_);
   DCHECK(!response_headers_received_);
   if (rv > 0) {
     headers_bytes_received_ += rv;
     rv = ProcessResponseHeaders(response_header_block_);
   }
   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
     DoCallback(rv);
   }
 }
 
 void QuicHttpStream::ReadTrailingHeaders() {
-  if (!stream_)
-    return;
-
   int rv = stream_->ReadTrailingHeaders(
       &trailing_header_block_,
       base::Bind(&QuicHttpStream::OnReadTrailingHeadersComplete,
                  weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING)
     OnReadTrailingHeadersComplete(rv);
 }
 
 void QuicHttpStream::OnReadTrailingHeadersComplete(int rv) {
   DCHECK(response_headers_received_);
   if (rv > 0)
     headers_bytes_received_ += rv;
 
   // QuicHttpStream ignores trailers.
   if (stream_->IsDoneReading()) {
     // Close the read side. If the write side has been closed, this will
     // invoke QuicHttpStream::OnClose to reset the stream.
     stream_->OnFinRead();
     SetResponseStatus(OK);
   }
 }
 
-void QuicHttpStream::OnClose() {
-  quic_connection_error_ = stream_->connection_error();
-  quic_stream_error_ = stream_->stream_error();
-  SaveResponseStatus();
-
-  ResetStream();
-  // If already in DoLoop(), |callback_| will be handled when DoLoop() exits.
-  if (in_loop_)
-    return;
-
-  if (!callback_.is_null()) {
-    DoCallback(GetResponseStatus());
-  }
-}
-
-void QuicHttpStream::OnError(int error) {
-  ResetStream();
-  session_error_ = error;
-  SaveResponseStatus();
-  if (in_loop_) {
-    // If already in DoLoop(), |callback_| will be handled when DoLoop() exits.
-    return;
-  }
-  if (!callback_.is_null())
-    DoCallback(GetResponseStatus());
-}
-
 void QuicHttpStream::OnIOComplete(int rv) {
   rv = DoLoop(rv);
 
   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
     DoCallback(rv);
   }
 }
 
 void QuicHttpStream::DoCallback(int rv) {
   CHECK_NE(rv, ERR_IO_PENDING);
   CHECK(!callback_.is_null());
   CHECK(!in_loop_);
 
   // The client callback can do anything, including destroying this class,
   // so any pending callback must be issued after everything else is done.
-  base::ResetAndReturn(&callback_).Run(rv);
+  base::ResetAndReturn(&callback_).Run(MapStreamError(rv));
 }
 
 int QuicHttpStream::DoLoop(int rv) {
   CHECK(!in_loop_);
   base::AutoReset<bool> auto_reset_in_loop(&in_loop_, true);
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_HANDLE_PROMISE:
@@ skipping 56 matching lines @@
       base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
 int QuicHttpStream::DoRequestStreamComplete(int rv) {
   DCHECK(rv == OK || !stream_);
   if (rv != OK) {
     session_error_ = rv;
     return GetResponseStatus();
   }
 
-  stream_ = quic_session()->ReleaseStream(this);
+  stream_ = quic_session()->ReleaseStream();
   if (request_info_->load_flags & LOAD_DISABLE_CONNECTION_MIGRATION) {
     stream_->DisableConnectionMigration();
   }
 
   if (response_info_) {
     // This happens in the case of a asynchronous push rendezvous
     // that ultimately fails (e.g. vary failure).  |response_info_|
     // non-null implies that |DoRequestStream()| was called via
     // |SendRequest()|.
     next_state_ = STATE_SET_REQUEST_PRIORITY;
   }
 
   return OK;
 }
 
 int QuicHttpStream::DoSetRequestPriority() {
   // Set priority according to request
   DCHECK(stream_);
   DCHECK(response_info_);
   SpdyPriority priority = ConvertRequestPriorityToQuicPriority(priority_);
   stream_->SetPriority(priority);
   next_state_ = STATE_SEND_HEADERS;
   return OK;
 }
 
 int QuicHttpStream::DoSendHeaders() {
-  if (!stream_)
-    return GetResponseStatus();
-
   // Log the actual request with the URL Request's net log.
   stream_net_log_.AddEvent(
       NetLogEventType::HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
       base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
                  priority_));
   bool has_upload_data = request_body_stream_ != nullptr;
 
   next_state_ = STATE_SEND_HEADERS_COMPLETE;
   size_t frame_len = stream_->WriteHeaders(std::move(request_headers_),
                                            !has_upload_data, nullptr);
   headers_bytes_sent_ += frame_len;
 
   request_headers_ = SpdyHeaderBlock();
   return static_cast<int>(frame_len);
 }
 
 int QuicHttpStream::DoSendHeadersComplete(int rv) {
   if (rv < 0)
     return rv;
 
-  // If the stream is already closed, don't read the request body.
-  if (!stream_)
-    return GetResponseStatus();
-
   next_state_ = request_body_stream_ ? STATE_READ_REQUEST_BODY : STATE_OPEN;
 
   return OK;
 }
 
 int QuicHttpStream::DoReadRequestBody() {
   next_state_ = STATE_READ_REQUEST_BODY_COMPLETE;
   return request_body_stream_->Read(
       raw_request_body_buf_.get(), raw_request_body_buf_->size(),
       base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
 int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
-  // If the stream is already closed, don't continue.
-  if (!stream_)
-    return GetResponseStatus();
-
   // |rv| is the result of read from the request body from the last call to
   // DoSendBody().
   if (rv < 0) {
-    stream_->ClearDelegate();
     stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);
     ResetStream();
     return rv;
   }
 
   request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv);
   if (rv == 0) {  // Reached the end.
     DCHECK(request_body_stream_->IsEOF());
   }
 
   next_state_ = STATE_SEND_BODY;
   return OK;
 }
 
 int QuicHttpStream::DoSendBody() {
-  if (!stream_)
-    return GetResponseStatus();
-
   CHECK(request_body_stream_);
   CHECK(request_body_buf_.get());
   const bool eof = request_body_stream_->IsEOF();
   int len = request_body_buf_->BytesRemaining();
   if (len > 0 || eof) {
     next_state_ = STATE_SEND_BODY_COMPLETE;
     QuicStringPiece data(request_body_buf_->data(), len);
     return stream_->WriteStreamData(
         data, eof,
         base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
   }
 
   next_state_ = STATE_OPEN;
   return OK;
 }
 
 int QuicHttpStream::DoSendBodyComplete(int rv) {
   if (rv < 0)
     return rv;
 
-  // If the stream is already closed, don't continue.
-  if (!stream_)
-    return GetResponseStatus();
-
   request_body_buf_->DidConsume(request_body_buf_->BytesRemaining());
 
   if (!request_body_stream_->IsEOF()) {
     next_state_ = STATE_READ_REQUEST_BODY;
     return OK;
   }
 
   next_state_ = STATE_OPEN;
   return OK;
 }
@@ skipping 22 matching lines @@
   response_headers_received_ = true;
 
   // Populate |connect_timing_| when response headers are received. This should
   // take care of 0-RTT where request is sent before handshake is confirmed.
   connect_timing_ = quic_session()->GetConnectTiming();
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&QuicHttpStream::ReadTrailingHeaders,
                             weak_factory_.GetWeakPtr()));
 
+  if (stream_->IsDoneReading()) {
+    session_error_ = OK;
+    SaveResponseStatus();
+    stream_->OnFinRead();
+  }
+
   return OK;
 }
 
 void QuicHttpStream::OnReadBodyComplete(int rv) {
   CHECK(callback_);
   user_buffer_ = nullptr;
   user_buffer_len_ = 0;
   rv = HandleReadComplete(rv);
   DoCallback(rv);
 }
 
 int QuicHttpStream::HandleReadComplete(int rv) {
   if (stream_->IsDoneReading()) {
-    stream_->ClearDelegate();
     stream_->OnFinRead();
     SetResponseStatus(OK);
     ResetStream();
   }
   return rv;
 }
 
 void QuicHttpStream::ResetStream() {
   if (push_handle_) {
     push_handle_->Cancel();
     push_handle_ = nullptr;
   }
 
   // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
   // read.
   if (request_body_stream_)
     request_body_stream_->Reset();
 
   if (!stream_)
     return;
+
   DCHECK_LE(stream_->NumBytesConsumed(), stream_->stream_bytes_read());
   // Only count the uniquely received bytes.
   closed_stream_received_bytes_ = stream_->NumBytesConsumed();
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
   closed_is_first_stream_ = stream_->IsFirstStream();
-  stream_->ClearDelegate();
-  stream_ = nullptr;
+}
+
+int QuicHttpStream::MapStreamError(int rv) {
+  if (rv == ERR_QUIC_PROTOCOL_ERROR &&
+      !quic_session()->IsCryptoHandshakeConfirmed()) {
+    return ERR_QUIC_HANDSHAKE_FAILED;
+  }
+  return rv;
 }
 
 int QuicHttpStream::GetResponseStatus() {
   SaveResponseStatus();
   return response_status_;
 }
 
 void QuicHttpStream::SaveResponseStatus() {
   if (!has_response_status_)
     SetResponseStatus(ComputeResponseStatus());
@@ skipping 16 matching lines @@
   if (session_error_ != ERR_UNEXPECTED)
     return session_error_;
 
   // If |response_info_| is null then the request has not been sent, so
   // return ERR_CONNECTION_CLOSED to permit HttpNetworkTransaction to
   // retry the request.
   if (!response_info_)
     return ERR_CONNECTION_CLOSED;
 
   // Explicit stream error are always fatal.
-  if (quic_stream_error_ != QUIC_STREAM_NO_ERROR &&
-      quic_stream_error_ != QUIC_STREAM_CONNECTION_ERROR) {
+  if (stream_->stream_error() != QUIC_STREAM_NO_ERROR &&
+      stream_->stream_error() != QUIC_STREAM_CONNECTION_ERROR) {
     return ERR_QUIC_PROTOCOL_ERROR;
   }
 
-  DCHECK_NE(QUIC_HANDSHAKE_TIMEOUT, quic_connection_error_);
-
   return ERR_QUIC_PROTOCOL_ERROR;
 }
 
 }  // namespace net