Update SHA1_LENGTH -> kSHA1Length to match previous change to SHA256_LENGTH.

net/socket/dns_cert_provenance_checker.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/socket/dns_cert_provenance_checker.h"
 
 #if !defined(USE_OPENSSL)
 
 #include <nspr.h>
 
 #include <hasht.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
 #include <set>
 #include <string>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
+#include "base/sha1.h"
 #include "base/threading/non_thread_safe.h"
 #include "crypto/encryptor.h"
+#include "crypto/sha2.h"

[wtc, 2011/09/24 01:39:41]

Please undo the changes in this file.  This file uses NSS.

 #include "crypto/symmetric_key.h"
 #include "net/base/completion_callback.h"
 #include "net/base/dns_util.h"
 #include "net/base/dnsrr_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace net {
 
 namespace {
@@ skipping 72 matching lines @@
 
     if (der_certs_.empty())
       return;
 
     DnsCertLimits* const limits = g_dns_cert_limits.Pointer();
     if (limits->HaveReachedMaxUploads() ||
         limits->HaveUploadedForHostname(hostname_)) {
       return;
     }
 
-    uint8 fingerprint[SHA1_LENGTH];
+    uint8 fingerprint[base::kSHA1Length];
     SECStatus rv = HASH_HashBuf(
         HASH_AlgSHA1, fingerprint, (uint8*) der_certs_[0].data(),
         der_certs_[0].size());
     DCHECK_EQ(SECSuccess, rv);
-    char fingerprint_hex[SHA1_LENGTH * 2 + 1];
+    char fingerprint_hex[base::kSHA1Length * 2 + 1];
     for (unsigned i = 0; i < sizeof(fingerprint); i++) {
       static const char hextable[] = "0123456789abcdef";
       fingerprint_hex[i*2] = hextable[fingerprint[i] >> 4];
       fingerprint_hex[i*2 + 1] = hextable[fingerprint[i] & 15];
     }
-    fingerprint_hex[SHA1_LENGTH * 2] = 0;
+    fingerprint_hex[base::kSHA1Length * 2] = 0;
 
     static const char kBaseCertName[] = ".certs.googlednstest.com";
     domain_.assign(fingerprint_hex);
     domain_.append(kBaseCertName);
 
     handle_ = dnsrr_resolver_->Resolve(
         domain_, kDNS_TXT, 0 /* flags */, &callback_, &response_,
         0 /* priority */, BoundNetLog());
     if (handle_ == DnsRRResolver::kInvalidHandle) {
       LOG(ERROR) << "Failed to resolve " << domain_ << " for " << hostname_;
@@ skipping 147 matching lines @@
       NULL /* random a */, NULL /* random b */, CKM_ECDH1_DERIVE,
       CKM_TLS_MASTER_KEY_DERIVE_DH, CKA_DERIVE, 0 /* key size */,
       CKD_NULL /* KDF */, NULL /* shared data */, NULL /* wincx */);
   SECKEY_DestroyPublicKey(server_pub_key);
   SECStatus rv = PK11_ExtractKeyValue(pms);
   DCHECK_EQ(SECSuccess, rv);
   SECItem* x_data = PK11_GetKeyData(pms);
 
   // The key and IV are 128-bits and generated from a SHA256 hash of the x
   // value.
-  char key_data[SHA256_LENGTH];
+  char key_data[crypto::kSHA256Length];
   HASH_HashBuf(HASH_AlgSHA256, reinterpret_cast<uint8*>(key_data),
                x_data->data, x_data->len);
   PK11_FreeSymKey(pms);
 
   DCHECK_GE(sizeof(key_data), kKeySizeInBytes + kIVSizeInBytes);
   std::string raw_key(key_data, kKeySizeInBytes);
 
   scoped_ptr<crypto::SymmetricKey> symkey(
       crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, raw_key));
   std::string iv(key_data + kKeySizeInBytes, kIVSizeInBytes);
@@ skipping 47 matching lines @@
 
 std::string DnsCertProvenanceChecker::BuildEncryptedReport(
     const std::string& hostname,
     const std::vector<std::string>& der_certs) {
   return "";
 }
 
 }  // namespace net
 
 #endif  // USE_OPENSSL