Get rid of WTF::SHA1.

Source/core/frame/csp/CSPSourceList.cpp

 // Copyright 2014 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 "config.h"
 #include "core/frame/csp/CSPSourceList.h"
 
 #include "core/frame/csp/CSPSource.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
+#include "platform/CryptoUtilities.h"
 #include "platform/ParsingUtilities.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/HashSet.h"
-#include "wtf/StringHasher.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/WTFString.h"
 
-namespace WTF {
-
-struct DigestValueHash {
-    static unsigned hash(const WebCore::DigestValue& v)
-    {
-        return StringHasher::computeHash(v.data(), v.size());
-    }
-    static bool equal(const WebCore::DigestValue& a, const WebCore::DigestValue& b)
-    {
-        return a == b;
-    };
-    static const bool safeToCompareToEmptyOrDeleted = true;
-};
-template <>
-struct DefaultHash<WebCore::DigestValue> {
-    typedef DigestValueHash Hash;
-};
-
-template <>
-struct DefaultHash<WebCore::ContentSecurityPolicyHashAlgorithm> {
-    typedef IntHash<WebCore::ContentSecurityPolicyHashAlgorithm> Hash;
-};
-template <>
-struct HashTraits<WebCore::ContentSecurityPolicyHashAlgorithm> : UnsignedWithZeroKeyHashTraits<WebCore::ContentSecurityPolicyHashAlgorithm> {
-};
-
-} // namespace WTF
-
 namespace WebCore {
 
 static bool isSourceListNone(const UChar* begin, const UChar* end)
 {
     skipWhile<UChar, isASCIISpace>(begin, end);
 
     const UChar* position = begin;
     skipWhile<UChar, isSourceCharacter>(position, end);
     if (!equalIgnoringCase("'none'", begin, position - begin))
         return false;
@@ skipping 134 matching lines @@
     if (m_policy->experimentalFeaturesEnabled()) {
         String nonce;
         if (!parseNonce(begin, end, nonce))
             return false;
 
         if (!nonce.isNull()) {
             addSourceNonce(nonce);
             return true;
         }
 
-        DigestValue hash;
+        CryptoUtil::DigestValue hash;
         ContentSecurityPolicyHashAlgorithm algorithm = ContentSecurityPolicyHashAlgorithmNone;
         if (!parseHash(begin, end, hash, algorithm))
             return false;
 
         if (hash.size() > 0) {
             addSourceHash(algorithm, hash);
             return true;
         }
     }
 
@@ skipping 91 matching lines @@
         return false;
 
     nonce = String(nonceBegin, position - nonceBegin);
     return true;
 }
 
 // hash-source       = "'" hash-algorithm "-" hash-value "'"
 // hash-algorithm    = "sha1" / "sha256" / "sha384" / "sha512"
 // hash-value        = 1*( ALPHA / DIGIT / "+" / "/" / "=" )
 //
-bool CSPSourceList::parseHash(const UChar* begin, const UChar* end, DigestValue& hash, ContentSecurityPolicyHashAlgorithm& hashAlgorithm)
+bool CSPSourceList::parseHash(const UChar* begin, const UChar* end, CryptoUtil::DigestValue& hash, ContentSecurityPolicyHashAlgorithm& hashAlgorithm)
 {
     // Any additions or subtractions from this struct should also modify the
     // respective entries in the kAlgorithmMap array in checkDigest().
     static const struct {
         const char* prefix;
         ContentSecurityPolicyHashAlgorithm algorithm;
     } kSupportedPrefixes[] = {
         { "'sha1-", ContentSecurityPolicyHashAlgorithmSha1 },
         { "'sha256-", ContentSecurityPolicyHashAlgorithmSha256 },
         { "'sha384-", ContentSecurityPolicyHashAlgorithmSha384 },
@@ skipping 28 matching lines @@
 
     // Base64 encodings may end with exactly one or two '=' characters
     skipExactly<UChar>(position, position + 1, '=');
     skipExactly<UChar>(position, position + 1, '=');
 
     if ((position + 1) != end || *position != '\'' || !(position - hashBegin))
         return false;
 
     Vector<char> hashVector;
     base64Decode(hashBegin, position - hashBegin, hashVector);
-    if (hashVector.size() > kMaxDigestSize)
+    if (hashVector.size() > CryptoUtil::kMaxDigestSize)
         return false;
     hash.append(reinterpret_cast<uint8_t*>(hashVector.data()), hashVector.size());
     return true;
 }
 
 //                     ; <scheme> production from RFC 3986
 // scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 //
 bool CSPSourceList::parseScheme(const UChar* begin, const UChar* end, String& scheme)
 {
@@ skipping 127 matching lines @@
 void CSPSourceList::addSourceUnsafeEval()
 {
     m_allowEval = true;
 }
 
 void CSPSourceList::addSourceNonce(const String& nonce)
 {
     m_nonces.add(nonce);
 }
 
-void CSPSourceList::addSourceHash(const ContentSecurityPolicyHashAlgorithm& algorithm, const DigestValue& hash)
+void CSPSourceList::addSourceHash(const ContentSecurityPolicyHashAlgorithm& algorithm, const CryptoUtil::DigestValue& hash)
 {
     m_hashes.add(CSPHashValue(algorithm, hash));
     m_hashAlgorithmsUsed |= algorithm;
 }
 
 
 } // namespace WebCore