Convert SHA256_LENGTH from a constant-in-anonymous-enum to a static const. This defines the cons...

net/base/transport_security_state.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/base/transport_security_state.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 
 TransportSecurityState::TransportSecurityState(const std::string& hsts_hosts)
     : delegate_(NULL) {
   if (!hsts_hosts.empty()) {
     bool dirty;
     Deserialise(hsts_hosts, &dirty, &forced_hosts_);
   }
 }
 
 static std::string HashHost(const std::string& canonicalized_host) {
-  char hashed[crypto::SHA256_LENGTH];
+  char hashed[crypto::kSHA256Length];
   crypto::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
   return std::string(hashed, sizeof(hashed));
 }
 
 void TransportSecurityState::EnableHost(const std::string& host,
                                         const DomainState& state) {
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return;
 
@@ skipping 240 matching lines @@
   std::string out;
   CHECK(base::Base64Encode(hashed, &out));
   return out;
 }
 
 // This inverts |HashedDomainToExternalString|, above. It turns an external
 // string (from a JSON file) into an internal (binary) string.
 static std::string ExternalStringToHashedDomain(const std::string& external) {
   std::string out;
   if (!base::Base64Decode(external, &out) ||
-      out.size() != crypto::SHA256_LENGTH) {
+      out.size() != crypto::kSHA256Length) {
     return std::string();
   }
 
   return out;
 }
 
 bool TransportSecurityState::Serialise(std::string* output) {
   DictionaryValue toplevel;
   for (std::map<std::string, DomainState>::const_iterator
        i = enabled_hosts_.begin(); i != enabled_hosts_.end(); ++i) {
@@ skipping 441 matching lines @@
   }
 
   LOG(ERROR) << "Rejecting public key chain for domain " << domain
              << ". Validated chain: " << HashesToBase64String(hashes)
              << ", expected: " << HashesToBase64String(public_key_hashes);
 
   return false;
 }
 
 }  // namespace