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_;
+    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