Move the logic for delaying 0-RTT QUIC POST from the QuicStreamFactory

net/quic/bidirectional_stream_quic_impl.cc

 // Copyright 2016 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/bidirectional_stream_quic_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/timer/timer.h"
@@ skipping 15 matching lines @@
       response_status_(OK),
       negotiated_protocol_(kProtoUnknown),
       read_buffer_len_(0),
       headers_bytes_received_(0),
       headers_bytes_sent_(0),
       closed_stream_received_bytes_(0),
       closed_stream_sent_bytes_(0),
       has_sent_headers_(false),
       has_received_headers_(false),
       send_request_headers_automatically_(true),
+      waiting_for_confirmation_(false),
       weak_factory_(this) {
   DCHECK(session_);
   session_->AddObserver(this);
 }
 
 BidirectionalStreamQuicImpl::~BidirectionalStreamQuicImpl() {
   Cancel();
   if (session_)
     session_->RemoveObserver(this);
 }
@@ skipping 228 matching lines @@
 void BidirectionalStreamQuicImpl::OnError(int error) {
   NotifyError(error);
 }
 
 bool BidirectionalStreamQuicImpl::HasSendHeadersComplete() {
   return has_sent_headers_;
 }
 
 void BidirectionalStreamQuicImpl::OnCryptoHandshakeConfirmed() {
   was_handshake_confirmed_ = true;
+  if (waiting_for_confirmation_)
+    NotifyStreamReady();
 }
 
 void BidirectionalStreamQuicImpl::OnSessionClosed(
     int error,
     bool /*port_migration_detected*/) {
   DCHECK_NE(OK, error);
   session_.reset();
   NotifyError(error);
 }
 
 void BidirectionalStreamQuicImpl::OnStreamReady(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   DCHECK(rv == OK || !stream_);
   if (rv == OK) {
     stream_->SetDelegate(this);
-    if (send_request_headers_automatically_) {
-      SendRequestHeaders();
+    if (!was_handshake_confirmed_ && request_info_->method == "POST") {
+      waiting_for_confirmation_ = true;
+      return;
     }
-    if (delegate_)
-      delegate_->OnStreamReady(has_sent_headers_);
+    NotifyStreamReady();
   } else {
     NotifyError(rv);
   }
 }
 
 void BidirectionalStreamQuicImpl::OnSendDataComplete(int rv) {
   DCHECK(rv == OK || !stream_);
   if (rv == OK) {
     if (delegate_)
       delegate_->OnDataSent();
@@ skipping 11 matching lines @@
     response_status_ = error;
     BidirectionalStreamImpl::Delegate* delegate = delegate_;
     delegate_ = nullptr;
     // Cancel any pending callback.
     weak_factory_.InvalidateWeakPtrs();
     delegate->OnFailed(error);
     // |this| might be destroyed at this point.
   }
 }
 
+void BidirectionalStreamQuicImpl::NotifyStreamReady() {
+  if (send_request_headers_automatically_) {
+    SendRequestHeaders();
+  }
+  if (delegate_)
+    delegate_->OnStreamReady(has_sent_headers_);
+}
+
 void BidirectionalStreamQuicImpl::ResetStream() {
   if (!stream_)
     return;
   closed_stream_received_bytes_ = stream_->stream_bytes_read();
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
   stream_->SetDelegate(nullptr);
   stream_ = nullptr;
 }
 
 }  // namespace net