Slice enum HttpResponseInfo::ConnectionInfo by QUIC version.

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 28 matching lines @@
   dict->SetString("url", url->spec());
   return std::move(dict);
 }
 
 }  // namespace
 
 QuicHttpStream::QuicHttpStream(
     const base::WeakPtr<QuicChromiumClientSession>& session)
     : next_state_(STATE_NONE),
       session_(session),
+      quic_version_(session->GetQuicVersion()),
       session_error_(OK),
       was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()),
       stream_(nullptr),
       request_info_(nullptr),
       request_body_stream_(nullptr),
       priority_(MINIMUM_PRIORITY),
       response_info_(nullptr),
       response_status_(OK),
       response_headers_received_(false),
       headers_bytes_received_(0),
@@ skipping 61 matching lines @@
 
   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);
 }
 
+HttpResponseInfo::ConnectionInfo QuicHttpStream::ConnectionInfoFromQuicVersion(
+    QuicVersion quic_version) {
+  switch (quic_version) {
+    case QUIC_VERSION_UNSUPPORTED:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_UNKNOWN_VERSION;
+    case QUIC_VERSION_32:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_32;
+    case QUIC_VERSION_33:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_33;
+    case QUIC_VERSION_34:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_34;
+    case QUIC_VERSION_35:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_35;
+    case QUIC_VERSION_36:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_36;
+  }
+  NOTREACHED();
+  return HttpResponseInfo::CONNECTION_INFO_QUIC_UNKNOWN_VERSION;
+}
+
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const NetLogWithSource& stream_net_log,
                                      const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   DCHECK(!stream_);
   if (!session_)
     return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
                                     : ERR_QUIC_HANDSHAKE_FAILED;
 
@@ skipping 283 matching lines @@
   return session_->GetTokenBindingSignature(key, tb_type, out);
 }
 
 void QuicHttpStream::Drain(HttpNetworkSession* session) {
   NOTREACHED();
   Close(false);
   delete this;
 }
 
 void QuicHttpStream::PopulateNetErrorDetails(NetErrorDetails* details) {
-  details->connection_info = HttpResponseInfo::CONNECTION_INFO_QUIC;
+  details->connection_info = ConnectionInfoFromQuicVersion(quic_version_);
   if (was_handshake_confirmed_)
     details->quic_connection_error = quic_connection_error_;
   if (session_) {
     session_->PopulateNetErrorDetails(details);
   } else {
     details->quic_port_migration_detected = port_migration_detected_;
   }
 }
 
 void QuicHttpStream::SetPriority(RequestPriority priority) {
@@ skipping 80 matching lines @@
   was_handshake_confirmed_ = true;
   if (next_state_ == STATE_WAIT_FOR_CONFIRMATION_COMPLETE) {
     int rv = DoLoop(OK);
 
     if (rv != ERR_IO_PENDING && !callback_.is_null()) {
       DoCallback(rv);
     }
   }
 }
 
+void QuicHttpStream::OnSuccessfulVersionNegotiation(
+    const QuicVersion& version) {
+  quic_version_ = version;
+}
+
 void QuicHttpStream::OnSessionClosed(int error, bool port_migration_detected) {
   Close(false);
   session_error_ = error;
   port_migration_detected_ = port_migration_detected;
   session_.reset();
 }
 
 void QuicHttpStream::OnIOComplete(int rv) {
   rv = DoLoop(rv);
 
@@ skipping 237 matching lines @@
 }
 
 int QuicHttpStream::ProcessResponseHeaders(const SpdyHeaderBlock& headers) {
   if (!SpdyHeadersToHttpResponse(headers, response_info_)) {
     DLOG(WARNING) << "Invalid headers";
     return ERR_QUIC_PROTOCOL_ERROR;
   }
   // Put the peer's IP address and port into the response.
   IPEndPoint address = session_->peer_address();
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
-  response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_QUIC;
+  response_info_->connection_info =
+      ConnectionInfoFromQuicVersion(quic_version_);
   response_info_->vary_data.Init(*request_info_,
                                  *response_info_->headers.get());
   response_info_->was_alpn_negotiated = true;
-  response_info_->alpn_negotiated_protocol = "quic/1+spdy/3";
+  response_info_->alpn_negotiated_protocol =
+      HttpResponseInfo::ConnectionInfoToString(response_info_->connection_info);
   response_info_->response_time = base::Time::Now();
   response_info_->request_time = request_time_;
   response_headers_received_ = true;
 
   // Populate |connect_timing_| when response headers are received. This should
   // take care of 0-RTT where request is sent before handshake is confirmed.
   connect_timing_ = session_->GetConnectTiming();
   return OK;
 }
 
@@ skipping 26 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