Disable HTTP/2 Alternative Services.

net/http/http_stream_factory_impl_job_controller.cc

 // Copyright (c) 2016 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/http/http_stream_factory_impl_job_controller.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 932 matching lines @@
     }
   } else {
     if (request_info.url.host_piece() == alternative_service.host) {
       type = NOT_QUIC_SAME_DESTINATION;
     } else {
       type = NOT_QUIC_DIFFERENT_DESTINATION;
     }
   }
   UMA_HISTOGRAM_ENUMERATION("Net.AlternativeServiceTypeForRequest", type,
                             MAX_ALTERNATIVE_SERVICE_TYPE);
+
+  // TODO(bnc): https://crbug.com/615413 Re-enable HTTP/2 Alternative Services.
+  if (alternative_service.protocol == kProtoHTTP2 &&
+      !session_->params().enable_http2_alternative_service) {
+    return AlternativeService();
+  }

[Ryan Hamilton, 2017/04/13 21:53:45]

I don't understand why we want to move this here instead of keeping it down in
the loop in GetAlternativeServiceForInternal. Can you say more?

[Bence, 2017/04/14 01:10:16]

Sure.  If it's in GetAlternativeServiceForInternal(), then that never returns an
HTTP/2 alternative service (unless in tests), so
Net.AlternativeServiceTypeForRequest never logs them, so we won't know if they
are advertised in the wild.

[Ryan Hamilton, 2017/04/14 02:49:13]

In that case, perhaps we need a new histogram for rejected AlternativeServices?
I ask because I know that there are server operators planning to advertise both
QUIC and remote H2 so I'd like to make sure that when we encounter those servers
that we speak one of the alternatives.

[Bence, 2017/04/17 11:29:46]

Oops, I wasn't aware of that, sorry.  Let me just revert this part of the change
to make sure that QUIC is used if it is advertised.

+
   return alternative_service;
 }
 
 AlternativeService
 HttpStreamFactoryImpl::JobController::GetAlternativeServiceForInternal(
     const HttpRequestInfo& request_info,
     HttpStreamRequest::Delegate* delegate,
     HttpStreamRequest::StreamType stream_type) {
   GURL original_url = request_info.url;
 
@@ skipping 18 matching lines @@
        alternative_service_vector) {
     DCHECK(IsAlternateProtocolValid(alternative_service.protocol));
     if (!quic_advertised && alternative_service.protocol == kProtoQUIC)
       quic_advertised = true;
     if (http_server_properties.IsAlternativeServiceBroken(
             alternative_service)) {
       HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN, false);
       continue;
     }
 
-
     // Some shared unix systems may have user home directories (like
     // http://foo.com/~mike) which allow users to emit headers.  This is a bad
     // idea already, but with Alternate-Protocol, it provides the ability for a
     // single user on a multi-user system to hijack the alternate protocol.
     // These systems also enforce ports <1024 as restricted ports.  So don't
     // allow protocol upgrades to user-controllable ports.
     const int kUnrestrictedPort = 1024;
     if (!session_->params().enable_user_alternate_protocol_ports &&
         (alternative_service.port >= kUnrestrictedPort &&
          origin.port() < kUnrestrictedPort))
       continue;
 
     if (alternative_service.protocol == kProtoHTTP2) {
-      if (origin.host() != alternative_service.host &&
-          !session_->params()
-               .enable_http2_alternative_service_with_different_host) {
-        continue;
-      }
-
       // Cache this entry if we don't have a non-broken Alt-Svc yet.
       if (first_alternative_service.protocol == kProtoUnknown)
         first_alternative_service = alternative_service;
       continue;
     }
 
     DCHECK_EQ(kProtoQUIC, alternative_service.protocol);
     if (origin.host() != alternative_service.host &&
         !session_->params()
              .enable_quic_alternative_service_with_different_host) {
@@ skipping 138 matching lines @@
     return;
   DCHECK(alternative_job_->alternative_proxy_server().is_valid());
   alternative_job_->Start(request_->stream_type());
 }
 
 bool HttpStreamFactoryImpl::JobController::IsJobOrphaned(Job* job) const {
   return !request_ || (job_bound_ && bound_job_ != job);
 }
 
 }  // namespace net