Snapshot of all changes to get jumbo in blink and content.

net/http/transport_security_state.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/http/transport_security_state.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 209 matching lines @@
 }
 
 std::string HashHost(const std::string& canonicalized_host) {
   char hashed[crypto::kSHA256Length];
   crypto::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
   return std::string(hashed, sizeof(hashed));
 }
 
 // Returns true if the intersection of |a| and |b| is not empty. If either
 // |a| or |b| is empty, returns false.
-bool HashesIntersect(const HashValueVector& a,
+bool HashesIntersect2(const HashValueVector& a,
                      const HashValueVector& b) {
   for (const auto& hash : a) {
     if (base::ContainsValue(b, hash))
       return true;
   }
   return false;
 }
 
 bool AddHash(const char* sha256_hash, HashValueVector* out) {
   HashValue hash(HASH_VALUE_SHA256);
@@ skipping 1579 matching lines @@
   // Validate that hashes is not empty. By the time this code is called (in
   // production), that should never happen, but it's good to be defensive.
   // And, hashes *can* be empty in some test scenarios.
   if (hashes.empty()) {
     failure_log->append(
         "Rejecting empty public key chain for public-key-pinned domains: " +
         domain);
     return false;
   }
 
-  if (HashesIntersect(bad_spki_hashes, hashes)) {
+  if (HashesIntersect2(bad_spki_hashes, hashes)) {
     failure_log->append("Rejecting public key chain for domain " + domain +
                         ". Validated chain: " + HashesToBase64String(hashes) +
                         ", matches one or more bad hashes: " +
                         HashesToBase64String(bad_spki_hashes));
     return false;
   }
 
   // If there are no pins, then any valid chain is acceptable.
   if (spki_hashes.empty())
     return true;
 
-  if (HashesIntersect(spki_hashes, hashes)) {
+  if (HashesIntersect2(spki_hashes, hashes)) {
     return true;
   }
 
   failure_log->append("Rejecting public key chain for domain " + domain +
                       ". Validated chain: " + HashesToBase64String(hashes) +
                       ", expected: " + HashesToBase64String(spki_hashes));
   return false;
 }
 
 bool TransportSecurityState::PKPState::HasPublicKeyPins() const {
   return spki_hashes.size() > 0 || bad_spki_hashes.size() > 0;
 }
 
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace net