Cleanup QuicHttpStream to be a bit more consistent with net coding conventions.

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 93 matching lines @@
   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);
     stream_->SetDelegate(this);
   }
-  // callback_ should be non-null in the case of asynchronous
+
+  // callback_ should only be non-null in the case of asynchronous
   // rendezvous; i.e. |Try()| returned QUIC_PENDING.
-  if (!callback_.is_null()) {
-    if (stream) {
-      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));
-      DoCallback(OK);
-      return;
-    }
+  if (callback_.is_null())
+    return;
+
+  if (stream) {
+    next_state_ = STATE_HANDLE_PROMISE_COMPLETE;
+  } else {
     // rendezvous has failed so proceed as with a non-push request.
     next_state_ = STATE_REQUEST_STREAM;
-    OnIOComplete(OK);
   }
+
+  OnIOComplete(OK);
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   DCHECK(!stream_);
   if (!session_)
     return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
@@ skipping 29 matching lines @@
   }
 
   next_state_ = STATE_REQUEST_STREAM;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
-void QuicHttpStream::OnStreamReady(int rv) {
-  DCHECK(rv == OK || !stream_);
-  if (rv == OK) {
-    stream_->SetDelegate(this);
-    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 |DoStreamRequest()| was called via
-      // |SendRequest()|.
-      next_state_ = STATE_SET_REQUEST_PRIORITY;
-      rv = DoLoop(OK);
-    }
-  } else if (!was_handshake_confirmed_) {
-    rv = ERR_QUIC_HANDSHAKE_FAILED;
-  }
-  if (rv != ERR_IO_PENDING) {
-    DoCallback(rv);
-  }
-}
-
 bool QuicHttpStream::CancelPromiseIfHasBody() {
   if (!request_body_stream_)
     return false;
-  // Method type or request with body ineligble for push.
+
+  // A request with a body is ineligble for push.
   this->push_handle_->Cancel();
   this->push_handle_ = nullptr;
-  next_state_ = STATE_REQUEST_STREAM;
   return true;
 }
 
-int QuicHttpStream::HandlePromise() {
+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_OPEN;
-      if (!CancelPromiseIfHasBody()) {
-        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));
-        // Avoid the call to |DoLoop()| below, which would reset
-        // next_state_ to STATE_NONE.
-        return OK;
-      }
-
+      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;
       }
-      break;
+      next_state_ = STATE_REQUEST_STREAM;
   }
-  return DoLoop(OK);
+  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;
 }
 
 int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   CHECK(!request_body_stream_);
   CHECK(!response_info_);
   CHECK(callback_.is_null());
   CHECK(!callback.is_null());
   CHECK(response);
@@ skipping 30 matching lines @@
     // 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_) {
-    rv = HandlePromise();
+    // 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);
   }
+  rv = DoLoop(OK);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv > 0 ? OK : rv;
 }
 
 UploadProgress QuicHttpStream::GetUploadProgress() const {
   if (!request_body_stream_)
     return UploadProgress();
@@ skipping 268 matching lines @@
   base::ResetAndReturn(&callback_).Run(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:
+        CHECK_EQ(OK, rv);
+        rv = DoHandlePromise();
+        break;
+      case STATE_HANDLE_PROMISE_COMPLETE:
+        CHECK_EQ(OK, rv);
+        rv = DoHandlePromiseComplete(rv);
+        break;
       case STATE_REQUEST_STREAM:
-        rv = DoStreamRequest();
+        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:
@@ skipping 23 matching lines @@
       default:
         NOTREACHED() << "next_state_: " << next_state_;
         break;
     }
   } while (next_state_ != STATE_NONE && next_state_ != STATE_OPEN &&
            rv != ERR_IO_PENDING);
 
   return rv;
 }
 
-int QuicHttpStream::DoStreamRequest() {
-  int rv = stream_request_.StartRequest(
+int QuicHttpStream::DoRequestStream() {
+  next_state_ = STATE_REQUEST_STREAM_COMPLETE;
+  return stream_request_.StartRequest(
       session_, &stream_,
-      base::Bind(&QuicHttpStream::OnStreamReady, weak_factory_.GetWeakPtr()));
-  if (rv == OK) {
-    stream_->SetDelegate(this);
-    if (request_info_->load_flags & LOAD_DISABLE_CONNECTION_MIGRATION) {
-      stream_->DisableConnectionMigration();
-    }
-    if (response_info_) {
-      next_state_ = STATE_SET_REQUEST_PRIORITY;
-    }
-  } else if (rv != ERR_IO_PENDING && !was_handshake_confirmed_) {
-    rv = ERR_QUIC_HANDSHAKE_FAILED;
+      base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
+}
+
+int QuicHttpStream::DoRequestStreamComplete(int rv) {
+  DCHECK(rv == OK || !stream_);
+  if (rv != OK)
+    return was_handshake_confirmed_ ? rv : ERR_QUIC_HANDSHAKE_FAILED;
+
+  stream_->SetDelegate(this);
+  if (request_info_->load_flags & LOAD_DISABLE_CONNECTION_MIGRATION) {
+    stream_->DisableConnectionMigration();
   }
-  return rv;
+
+  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_WAIT_FOR_CONFIRMATION;
   return OK;
@@ skipping 171 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