Strict transport security: come out from behind the flag.

net/url_request/url_request_http_job.cc

 // Copyright (c) 2006-2009 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/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 28 matching lines @@
   int port = request->url().IntPort();
   if (!net::IsPortAllowedByDefault(port) && !net::IsPortAllowedByOverride(port))
     return new URLRequestErrorJob(request, net::ERR_UNSAFE_PORT);
 
   if (!request->context() ||
       !request->context()->http_transaction_factory()) {
     NOTREACHED() << "requires a valid context";
     return new URLRequestErrorJob(request, net::ERR_INVALID_ARGUMENT);
   }
 
-  // We cache the value of the switch because this code path is hit on every
-  // network request.
-  static const bool kForceHTTPS =
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceHTTPS);
-  if (kForceHTTPS && scheme == "http" &&
+  if (scheme == "http" &&
       request->context()->strict_transport_security_state() &&
       request->context()->strict_transport_security_state()->IsEnabledForHost(
           request->url().host())) {

[abarth-chromium, 2009/09/10 00:59:02]

I'm slightly worried about the performance implications of this check.   Please
watch the perf charts to make sure this is ok.

     DCHECK_EQ(request->url().scheme(), "http");
     url_canon::Replacements<char> replacements;
     static const char kNewScheme[] = "https";
     replacements.SetScheme(kNewScheme,
                            url_parse::Component(0, strlen(kNewScheme)));
     GURL new_location = request->url().ReplaceComponents(replacements);
     return new URLRequestRedirectJob(request, new_location);
   }
 
   return new URLRequestHttpJob(request);
@@ skipping 412 matching lines @@
     SetStatus(URLRequestStatus());
   }
 
   NotifyReadComplete(result);
 }
 
 bool URLRequestHttpJob::ShouldTreatAsCertificateError(int result) {
   if (!net::IsCertificateError(result))
     return false;
 
-  // Hide the fancy processing behind a command line switch.
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceHTTPS))
-    return true;
-
   // Check whether our context is using Strict-Transport-Security.
   if (!context_->strict_transport_security_state())
     return true;
 
   return !context_->strict_transport_security_state()->IsEnabledForHost(
       request_info_.url.host());
 }
 
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
@@ skipping 188 matching lines @@
   void* iter = NULL;
   while (response_info_->headers->EnumerateHeader(&iter, name, &value))
     if (request_->context()->InterceptCookie(request_, &value))
       response_cookies_.push_back(value);
 }
 
 
 void URLRequestHttpJob::ProcessStrictTransportSecurityHeader() {
   DCHECK(response_info_);
 
-  // Hide processing behind a command line flag.
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceHTTPS))
-    return;
-
   // Only process Strict-Transport-Security from HTTPS responses.
   if (request_info_.url.scheme() != "https")
     return;
 
   // Only process Strict-Transport-Security from responses with valid certificates.
   if (response_info_->ssl_info.cert_status & net::CERT_STATUS_ALL_ERRORS)
     return;
 
   URLRequestContext* ctx = request_->context();
   if (!ctx || !ctx->strict_transport_security_state())
     return;
 
   std::string name = "Strict-Transport-Security";
   std::string value;
 
   void* iter = NULL;
   while (response_info_->headers->EnumerateHeader(&iter, name, &value)) {
     ctx->strict_transport_security_state()->DidReceiveHeader(
         request_info_.url, value);
   }
 }