Add an async method to QuicChromiumClientSession::Handle for

net/quic/chromium/quic_chromium_client_session.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_chromium_client_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 181 matching lines @@
 
 QuicChromiumClientSession::Handle::Handle(
     const base::WeakPtr<QuicChromiumClientSession>& session)
     : MultiplexedSessionHandle(session),
       session_(session),
       net_log_(session_->net_log()),
       was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()),
       error_(OK),
       port_migration_detected_(false),
       server_id_(session_->server_id()),
-      quic_version_(session->connection()->version()) {
+      quic_version_(session->connection()->version()),
+      push_handle_(nullptr) {
   DCHECK(session_);
   session_->AddHandle(this);
 }
 
 QuicChromiumClientSession::Handle::~Handle() {
+  if (push_handle_) {
+    auto* push_handle = push_handle_;

[xunjieli, 2017/06/22 14:43:30]

Is saving |push_handle_| on to the stack still necessary? |this| won't be
destroyed when session is closed. Is there a re-entrancy in Cancel() that I am
not seeing?

The following should be enough, right?
if (push_handle_) {
  push_handle_->Cancel();
  push_handle_ = nullptr;
}

[Ryan Hamilton, 2017/06/22 20:40:38]

So it "should" work, but I'm nervous. As you point out, if there is any
reentrancy, this could be problematic. Since Cancel() can result in a write,
it's not immediately obvious what bad things can happen. Since we're getting
crashes in this code before the Handle code, I'm super nervous. I'll revert it
if you feel strongly, but I'm nervous :)

+    push_handle_ = nullptr;
+    push_handle->Cancel();
+  }
+
   if (session_)
     session_->RemoveHandle(this);
 }
 
 void QuicChromiumClientSession::Handle::OnCryptoHandshakeConfirmed() {
   was_handshake_confirmed_ = true;
 }
 
 void QuicChromiumClientSession::Handle::OnSessionClosed(
     QuicVersion quic_version,
     int error,
     bool port_migration_detected,
     LoadTimingInfo::ConnectTiming connect_timing) {
   session_ = nullptr;
   port_migration_detected_ = port_migration_detected;
   error_ = error;
   quic_version_ = quic_version;
   connect_timing_ = connect_timing;
+  push_handle_ = nullptr;
 }
 
 bool QuicChromiumClientSession::Handle::IsConnected() const {
   return session_ != nullptr;
 }
 
 bool QuicChromiumClientSession::Handle::IsCryptoHandshakeConfirmed() const {
   return was_handshake_confirmed_;
 }
 
@@ skipping 46 matching lines @@
 
   return base::MakeUnique<QuicConnection::ScopedPacketBundler>(
       session_->connection(), bundling_mode);
 }
 
 bool QuicChromiumClientSession::Handle::SharesSameSession(
     const Handle& other) const {
   return session_.get() == other.session_.get();
 }
 
+int QuicChromiumClientSession::Handle::RendezvousWithPromised(
+    const SpdyHeaderBlock& headers,
+    const CompletionCallback& callback) {
+  if (!session_)
+    return ERR_CONNECTION_CLOSED;
+
+  QuicAsyncStatus push_status =
+      session_->push_promise_index()->Try(headers, this, &push_handle_);
+
+  switch (push_status) {
+    case QUIC_FAILURE:
+      return ERR_FAILED;
+    case QUIC_SUCCESS:
+      return OK;
+    case QUIC_PENDING:
+      push_callback_ = callback;
+      return ERR_IO_PENDING;
+  }
+  NOTREACHED();
+  return ERR_UNEXPECTED;
+}
+
 int QuicChromiumClientSession::Handle::RequestStream(
     bool requires_confirmation,
     const CompletionCallback& callback) {
   DCHECK(!stream_request_);
 
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
   // base::MakeUnique does not work because the StreamRequest constructor
   // is private.
   stream_request_ = std::unique_ptr<StreamRequest>(
       new StreamRequest(this, requires_confirmation));
   return stream_request_->StartRequest(callback);
 }
 
 std::unique_ptr<QuicChromiumClientStream::Handle>
 QuicChromiumClientSession::Handle::ReleaseStream() {
   DCHECK(stream_request_);
 
   auto handle = stream_request_->ReleaseStream();
   stream_request_.reset();
   return handle;
 }
 
+std::unique_ptr<QuicChromiumClientStream::Handle>
+QuicChromiumClientSession::Handle::ReleasePromisedStream() {
+  DCHECK(push_stream_);
+  return std::move(push_stream_);
+}
+
 int QuicChromiumClientSession::Handle::WaitForHandshakeConfirmation(
     const CompletionCallback& callback) {
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
   return session_->WaitForHandshakeConfirmation(callback);
 }
 
 void QuicChromiumClientSession::Handle::CancelRequest(StreamRequest* request) {
   if (session_)
@@ skipping 17 matching lines @@
 
 int QuicChromiumClientSession::Handle::GetPeerAddress(
     IPEndPoint* address) const {
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
   *address = session_->peer_address().impl().socket_address();
   return OK;
 }
 
+bool QuicChromiumClientSession::Handle::CheckVary(
+    const SpdyHeaderBlock& client_request,
+    const SpdyHeaderBlock& promise_request,
+    const SpdyHeaderBlock& promise_response) {
+  HttpRequestInfo promise_request_info;
+  ConvertHeaderBlockToHttpRequestHeaders(promise_request,
+                                         &promise_request_info.extra_headers);
+  HttpRequestInfo client_request_info;
+  ConvertHeaderBlockToHttpRequestHeaders(client_request,
+                                         &client_request_info.extra_headers);
+
+  HttpResponseInfo promise_response_info;
+  if (!SpdyHeadersToHttpResponse(promise_response, &promise_response_info)) {
+    DLOG(WARNING) << "Invalid headers";
+    return false;
+  }
+
+  HttpVaryData vary_data;
+  if (!vary_data.Init(promise_request_info,
+                      *promise_response_info.headers.get())) {
+    // Promise didn't contain valid vary info, so URL match was sufficient.
+    return true;
+  }
+  // Now compare the client request for matching.
+  return vary_data.MatchesRequest(client_request_info,
+                                  *promise_response_info.headers.get());
+}
+
+void QuicChromiumClientSession::Handle::OnRendezvousResult(
+    QuicSpdyStream* stream) {
+  DCHECK(!push_stream_);
+  int rv = ERR_FAILED;
+  if (stream) {
+    rv = OK;
+    push_stream_ =
+        static_cast<QuicChromiumClientStream*>(stream)->CreateHandle();
+  }
+
+  if (push_callback_) {
+    DCHECK(push_handle_);
+    push_handle_ = nullptr;
+    base::ResetAndReturn(&push_callback_).Run(rv);
+  }
+}
+
 QuicChromiumClientSession::StreamRequest::StreamRequest(
     QuicChromiumClientSession::Handle* session,
     bool requires_confirmation)
     : session_(session),
       requires_confirmation_(requires_confirmation),
       stream_(nullptr),
       weak_factory_(this) {}
 
 QuicChromiumClientSession::StreamRequest::~StreamRequest() {
   if (stream_)
@@ skipping 1400 matching lines @@
 }
 
 size_t QuicChromiumClientSession::EstimateMemoryUsage() const {
   // TODO(xunjieli): Estimate |crypto_stream_|, QuicSpdySession's
   // QuicHeaderList, QuicSession's QuiCWriteBlockedList, open streams and
   // unacked packet map.
   return base::trace_event::EstimateMemoryUsage(packet_readers_);
 }
 
 }  // namespace net