Cancel a promised stream if it is for a request with a body in QuicHttpStream.

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 99 matching lines @@
   if (stream) {
     stream_ = static_cast<QuicChromiumClientStream*>(stream);
     stream_->SetDelegate(this);
   }
 
   // callback_ should only be non-null in the case of asynchronous
   // rendezvous; i.e. |Try()| returned QUIC_PENDING.
   if (callback_.is_null())
     return;
 
-  if (stream) {
-    next_state_ = STATE_HANDLE_PROMISE_COMPLETE;
-  } else {
+  DCHECK_EQ(STATE_HANDLE_PROMISE_COMPLETE, next_state_);
+  if (!stream) {
     // rendezvous has failed so proceed as with a non-push request.
     next_state_ = STATE_REQUEST_STREAM;
   }
 
   OnIOComplete(OK);
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
@@ skipping 34 matching lines @@
   }
 
   next_state_ = STATE_REQUEST_STREAM;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
-bool QuicHttpStream::CancelPromiseIfHasBody() {
-  if (!request_body_stream_)
-    return false;
-
-  // A request with a body is ineligble for push.
-  this->push_handle_->Cancel();
-  this->push_handle_ = nullptr;
-  return true;
-}
-
 int QuicHttpStream::DoHandlePromise() {
   QuicAsyncStatus push_status = session_->push_promise_index()->Try(
       request_headers_, this, &this->push_handle_);
 
   switch (push_status) {
     case QUIC_FAILURE:
       // Push rendezvous failed.
       next_state_ = STATE_REQUEST_STREAM;
       break;
     case QUIC_SUCCESS:
       next_state_ = STATE_HANDLE_PROMISE_COMPLETE;
       break;
     case QUIC_PENDING:
-      if (!CancelPromiseIfHasBody()) {
-        next_state_ = STATE_HANDLE_PROMISE_COMPLETE;
-        // Have a promise but the promised stream doesn't exist yet.
-        // Still have to do validation before accepting the promised
-        // stream for sure.
-        return ERR_IO_PENDING;
-      }
-      next_state_ = STATE_REQUEST_STREAM;
+      next_state_ = STATE_HANDLE_PROMISE_COMPLETE;
+      return ERR_IO_PENDING;
   }
   return OK;
 }
 
 int QuicHttpStream::DoHandlePromiseComplete(int rv) {
   if (rv != OK)
     return rv;
 
-  if (CancelPromiseIfHasBody()) {
-    next_state_ = STATE_REQUEST_STREAM;
-    return OK;
-  }
-
   next_state_ = STATE_OPEN;
   stream_net_log_.AddEvent(
       NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
       base::Bind(&NetLogQuicPushStreamCallback, stream_->id(),
                  &request_info_->url));
   session_->net_log().AddEvent(
       NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
       base::Bind(&NetLogQuicPushStreamCallback, stream_->id(),
                  &request_info_->url));
   return OK;
@@ skipping 21 matching lines @@
                                     : ERR_QUIC_HANDSHAKE_FAILED;
   }
 
   // Store the serialized request headers.
   CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                    /*direct=*/true, &request_headers_);
 
   // Store the request body.
   request_body_stream_ = request_info_->upload_data_stream;
   if (request_body_stream_) {
+    // A request with a body is ineligible for push, so reset the
+    // promised stream and request a new stream.
+    if (found_promise_) {
+      found_promise_ = false;
+      std::string url(request_info_->url.spec());
+      QuicClientPromisedInfo* promised =
+          session_->push_promise_index()->GetPromised(url);
+      if (promised != nullptr) {
+        session_->ResetPromised(promised->id(), QUIC_STREAM_CANCELLED);
+      }
+    }
+
     // TODO(rch): Can we be more precise about when to allocate
     // raw_request_body_buf_. Removed the following check. DoReadRequestBody()
     // was being called even if we didn't yet allocate raw_request_body_buf_.
     //   && (request_body_stream_->size() ||
     //       request_body_stream_->is_chunked()))
     // Use 10 packets as the body buffer size to give enough space to
     // help ensure we don't often send out partial packets.
     raw_request_body_buf_ =
         new IOBufferWithSize(static_cast<size_t>(10 * kMaxPacketSize));
     // The request body buffer is empty at first.
     request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), 0);
   }
 
   // Store the response info.
   response_info_ = response;
 
   int rv;
 
   if (found_promise_) {
-    // TODO(rch): If this request has a body, instead of waiting for the pushed
-    // headers to arrive before canceling the push we could cancel the pushed
-    // stream now and go straight to STATE_REQUEST_STREAM.
     next_state_ = STATE_HANDLE_PROMISE;
   } else {
     next_state_ = STATE_SET_REQUEST_PRIORITY;
   }
   rv = DoLoop(OK);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv > 0 ? OK : rv;
@@ skipping 550 matching lines @@
   closed_is_first_stream_ = stream_->IsFirstStream();
   stream_ = nullptr;
 
   // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
   // read.
   if (request_body_stream_)
     request_body_stream_->Reset();
 }
 
 }  // namespace net