Move the "wait for QUIC handshake confirmation" logic to QuicChromiumClientSession::StreamRequest

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 502 matching lines @@
   if (!callback_.is_null())
     DoCallback(GetResponseStatus());
 }
 
 bool QuicHttpStream::HasSendHeadersComplete() {
   return next_state_ > STATE_SEND_HEADERS_COMPLETE;
 }
 
 void QuicHttpStream::OnCryptoHandshakeConfirmed() {
   was_handshake_confirmed_ = true;
-  if (next_state_ == STATE_WAIT_FOR_CONFIRMATION_COMPLETE) {
-    // Post a task to avoid reentrant calls into the session.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&QuicHttpStream::OnIOComplete,
-                              weak_factory_.GetWeakPtr(), OK));
-  }
 }
 
 void QuicHttpStream::OnSuccessfulVersionNegotiation(
     const QuicVersion& version) {
   quic_version_ = version;
 }
 
 void QuicHttpStream::OnSessionClosed(int error, bool port_migration_detected) {
   session_error_ = error;
   port_migration_detected_ = port_migration_detected;
@@ skipping 40 matching lines @@
         CHECK_EQ(OK, rv);
         rv = DoRequestStream();
         break;
       case STATE_REQUEST_STREAM_COMPLETE:
         rv = DoRequestStreamComplete(rv);
         break;
       case STATE_SET_REQUEST_PRIORITY:
         CHECK_EQ(OK, rv);
         rv = DoSetRequestPriority();
         break;
-      case STATE_WAIT_FOR_CONFIRMATION:
-        CHECK_EQ(OK, rv);
-        rv = DoWaitForConfirmation();
-        break;
-      case STATE_WAIT_FOR_CONFIRMATION_COMPLETE:
-        rv = DoWaitForConfirmationComplete(rv);
-        break;
       case STATE_SEND_HEADERS:
         CHECK_EQ(OK, rv);
         rv = DoSendHeaders();
         break;
       case STATE_SEND_HEADERS_COMPLETE:
         rv = DoSendHeadersComplete(rv);
         break;
       case STATE_READ_REQUEST_BODY:
         CHECK_EQ(OK, rv);
         rv = DoReadRequestBody();
@@ skipping 16 matching lines @@
         break;
     }
   } while (next_state_ != STATE_NONE && next_state_ != STATE_OPEN &&
            rv != ERR_IO_PENDING);
 
   return rv;
 }
 
 int QuicHttpStream::DoRequestStream() {
   next_state_ = STATE_REQUEST_STREAM_COMPLETE;
-  stream_request_ = session_->CreateStreamRequest();
+  stream_request_ =
+      session_->CreateStreamRequest(request_info_->method == "POST");
   return stream_request_->StartRequest(
       base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
 }
 
 int QuicHttpStream::DoRequestStreamComplete(int rv) {
   DCHECK(rv == OK || !stream_);
   if (rv != OK) {
     session_error_ = rv;
     return GetResponseStatus();
   }
@@ skipping 15 matching lines @@
 
   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_WAIT_FOR_CONFIRMATION;
-  return OK;
-}
-
-int QuicHttpStream::DoWaitForConfirmation() {
-  next_state_ = STATE_WAIT_FOR_CONFIRMATION_COMPLETE;
-  if (!session_->IsCryptoHandshakeConfirmed() &&
-      request_info_->method == "POST") {
-    return ERR_IO_PENDING;
-  }
-  return OK;
-}
-
-int QuicHttpStream::DoWaitForConfirmationComplete(int rv) {
-  if (rv < 0)
-    return rv;
-
   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(
@@ skipping 195 matching lines @@
       quic_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