Process HTTP/2 ALTSVC frames.

net/spdy/spdy_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/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 2467 matching lines @@
         headers, response_time, recv_first_byte_time, stream));
   } else {
     int rv = stream->OnAdditionalResponseHeadersReceived(headers);
     if (rv < 0) {
       DCHECK_NE(rv, ERR_IO_PENDING);
       DCHECK(active_streams_.find(stream_id) == active_streams_.end());
     }
   }
 }
 
+void SpdySession::OnAltSvc(
+    SpdyStreamId stream_id,
+    base::StringPiece origin,
+    const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
+  if (!is_secure_)
+    return;
+
+  url::SchemeHostPort scheme_host_port;
+  if (stream_id == 0) {
+    if (origin.empty())
+      return;

[Ryan Hamilton, 2016/06/03 19:05:18]

I'm surprised that this is, in the spec, to be ignored instead of closing the
connection with an error.

[Bence, 2016/06/03 20:57:52]

Acknowledged.

+    const GURL gurl(origin);
+    if (!gurl.SchemeIs("https"))
+      return;
+    SSLInfo ssl_info;
+    bool was_npn_negotiated;
+    NextProto protocol_negotiated = kProtoUnknown;
+    if (!GetSSLInfo(&ssl_info, &was_npn_negotiated, &protocol_negotiated))
+      return;
+    if (!CanPool(transport_security_state_, ssl_info, host_port_pair().host(),
+                 gurl.host())) {
+      return;
+    }
+    scheme_host_port = url::SchemeHostPort(gurl);
+  } else {
+    if (!origin.empty())
+      return;
+    const ActiveStreamMap::iterator it = active_streams_.find(stream_id);
+    if (it == active_streams_.end())
+      return;
+    const GURL& gurl(it->second.stream->url());
+    if (!gurl.SchemeIs("https"))
+      return;
+    scheme_host_port = url::SchemeHostPort(gurl);
+  }
+
+  AlternativeServiceInfoVector alternative_service_info_vector;

[Ryan Hamilton, 2016/06/03 19:05:18]

I think there's a constructor you can call to set the size which you could use
to set it to the size of the input vector to (possibly) avoid a reallocation.

[Bence, 2016/06/03 20:57:52]

Didn't find a constructor call, how about std::vector::reserve()?

[Ryan Hamilton, 2016/06/03 21:26:18]

Does this work?

http://en.cppreference.com/w/cpp/container/vector/vector
explicit vector( size_type count );
3) Constructs the container with count default-inserted instances of T. No
copies are made.

[Bence, 2016/06/04 02:43:55]

It could work, but note that the for loop can skip entries if |protocol_id|
string cannot be parsed into an AlternateProtocol, and if so, placeholder for
those omitted entries would manually have to be erased from the end.  So I would
need to have a running int i counter, do vector[i] = AltSvcInfo(...) instead of
push_back(), and in the end, delete size()-i or so entries from the end.  If you
see an easier way, please let me know, I'm happy to do a follow-up CL.

+  const base::Time now(base::Time::Now());
+  for (const SpdyAltSvcWireFormat::AlternativeService& altsvc : altsvc_vector) {
+    const AlternateProtocol protocol =
+        AlternateProtocolFromString(altsvc.protocol_id);
+    if (protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+      continue;
+    const AlternativeService alternative_service(protocol, altsvc.host,
+                                                 altsvc.port);
+    const base::Time expiration =
+        now + base::TimeDelta::FromSeconds(altsvc.max_age);
+    alternative_service_info_vector.push_back(
+        AlternativeServiceInfo(alternative_service, expiration));
+  }
+  http_server_properties_->SetAlternativeServices(
+      scheme_host_port, alternative_service_info_vector);
+}
+
 bool SpdySession::OnUnknownFrame(SpdyStreamId stream_id, int frame_type) {
   // Validate stream id.
   // Was the frame sent on a stream id that has not been used in this session?
   if (stream_id % 2 == 1 && stream_id > stream_hi_water_mark_)
     return false;
 
   if (stream_id % 2 == 0 && stream_id > last_accepted_push_stream_id_)
     return false;
 
   return true;
@@ skipping 838 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net