Refactor to address URLRequestContext dependency added in

net/url_request/url_request_http_job.cc

 // Copyright (c) 2011 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 174 matching lines @@
     NOTREACHED() << "requires a valid context";
     return new URLRequestErrorJob(request, ERR_INVALID_ARGUMENT);
   }
 
   TransportSecurityState::DomainState domain_state;
   if (scheme == "http" &&
       request->context()->transport_security_state() &&
       request->context()->transport_security_state()->IsEnabledForHost(
           &domain_state,
           request->url().host(),
-          request->context()->IsSNIAvailable())) {
+          SSLConfigService::IsSNIAvailable(

[willchan no longer on Chromium, 2011/05/05 18:00:35]

please include ssl_config_service.h for this

[Chris Evans, 2011/05/05 22:00:56]

Done.

+              request->context()->ssl_config_service()))) {
     if (domain_state.mode ==
          TransportSecurityState::DomainState::MODE_STRICT) {
       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);
     } else {
@@ skipping 462 matching lines @@
   // certificate.
   const SSLInfo& ssl_info = transaction_->GetResponseInfo()->ssl_info;
   if (result == OK &&
       ssl_info.is_valid() &&
       ssl_info.is_issued_by_known_root &&
       context_->transport_security_state()) {
     TransportSecurityState::DomainState domain_state;
     if (context_->transport_security_state()->HasPinsForHost(
             &domain_state,
             request_->url().host(),
-            context_->IsSNIAvailable())) {
+            SSLConfigService::IsSNIAvailable(
+                context_->ssl_config_service()))) {
       if (!domain_state.IsChainOfPublicKeysPermitted(
               ssl_info.public_key_hashes)) {
         result = ERR_CERT_INVALID;
         UMA_HISTOGRAM_BOOLEAN("Net.CertificatePinSuccess", false);
       } else {
         UMA_HISTOGRAM_BOOLEAN("Net.CertificatePinSuccess", true);
       }
     }
   }
 
@@ skipping 38 matching lines @@
   if (result == ERR_CERT_UNABLE_TO_CHECK_REVOCATION)
     return true;
 
   // Check whether our context is using Strict-Transport-Security.
   if (!context_->transport_security_state())
     return true;
 
   TransportSecurityState::DomainState domain_state;
   // TODO(agl): don't ignore opportunistic mode.
   const bool r = context_->transport_security_state()->IsEnabledForHost(
-      &domain_state, request_info_.url.host(), context_->IsSNIAvailable());
+      &domain_state, request_info_.url.host(),
+      SSLConfigService::IsSNIAvailable(context_->ssl_config_service()));
 
   return !r || domain_state.mode ==
                TransportSecurityState::DomainState::MODE_OPPORTUNISTIC;
 }
 
 void URLRequestHttpJob::RestartTransactionWithAuth(
     const string16& username,
     const string16& password) {
   username_ = username;
   password_ = password;
@@ skipping 646 matching lines @@
 }
 
 bool URLRequestHttpJob::IsCompressibleContent() const {
   std::string mime_type;
   return GetMimeType(&mime_type) &&
       (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
        IsSupportedNonImageMimeType(mime_type.c_str()));
 }
 
 }  // namespace net