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()),

[Ryan Hamilton, 2016/10/28 19:02:02]

We're only speaking 1 version of QUIC at a time in Chrome, but if we ever did
version negotiation this might grab the first version not the negotiated
version. Can you also set in QuicHttpStream::DoRequestStreamComplete in case it
changed?

[Bence, 2016/11/01 15:11:23]

Hm, I see.  QuicFramer's version can change after QuicHttpStream is
instantiated, so QuicHttpStream::quic_version needs to be updated.

I don't like that QuicHttpStream needs to know about where in the state machine
can the version change and needs an update.  I would prefer to wire version
changes through the QuicChromiumClientSession::Observer interface, because it's
more explicit this way.  WDYT?

But really, I wish |session_| was not a WeakPtr, so that
session_->GetQuicVersion() could be called every time its value is needed,
instead of having to store and update |quic_version_|.

[Ryan Hamilton, 2016/11/03 14:33:05]

SGTM!
Yeah, that'd be nice. Alas, the object lifetimes don't permit that to work
easily :(

       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 337 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