Get rid of WTF::SHA1.

Source/core/inspector/DOMPatchSupport.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/Node.h"
 #include "core/dom/XMLDocument.h"
 #include "core/html/HTMLBodyElement.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLHeadElement.h"
 #include "core/html/parser/HTMLDocumentParser.h"
 #include "core/inspector/DOMEditor.h"
 #include "core/inspector/InspectorHistory.h"
 #include "core/xml/parser/XMLDocumentParser.h"
+#include "platform/CryptoUtilities.h"
+#include "public/platform/Platform.h"
 #include "wtf/Deque.h"
 #include "wtf/HashTraits.h"
 #include "wtf/RefPtr.h"
-#include "wtf/SHA1.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/CString.h"
 
 using namespace std;
 
 namespace WebCore {
 
 struct DOMPatchSupport::Digest {
     explicit Digest(Node* node) : m_node(node) { }
 
@@ skipping 324 matching lines @@
             continue;
         if (isHTMLBodyElement(*node) || isHTMLHeadElement(*node))
             continue; // Never move head or body, move the rest of the nodes around them.
 
         if (!m_domEditor->insertBefore(parentNode, node.release(), anchorNode, exceptionState))
             return false;
     }
     return true;
 }
 
-static void addStringToSHA1(SHA1& sha1, const String& string)
-{
-    CString cString = string.utf8();
-    sha1.addBytes(reinterpret_cast<const uint8_t*>(cString.data()), cString.length());
-}
-
 PassOwnPtr<DOMPatchSupport::Digest> DOMPatchSupport::createDigest(Node* node, UnusedNodesMap* unusedNodesMap)
 {
     Digest* digest = new Digest(node);
 
-    SHA1 sha1;
+    CryptoUtil::DigestValue digestResult;
+    StringBuilder digestable;
 
     Node::NodeType nodeType = node->nodeType();
-    sha1.addBytes(reinterpret_cast<const uint8_t*>(&nodeType), sizeof(nodeType));
-    addStringToSHA1(sha1, node->nodeName());
-    addStringToSHA1(sha1, node->nodeValue());
+    digestable.append(reinterpret_cast<const char*>(&nodeType), sizeof(nodeType));
+    digestable.append(node->nodeName());

[eseidel, 2014/03/12 06:50:29]

You could have just used Vector<uint8_t> here, StringBuilder tries to be smart
about appends to make them cheap, but it also provides you UTF16 access to your
data (which you don't want).  I think it's a bit of a lie to use it here.

[abarth-chromium, 2014/03/12 18:59:02]

Yeah, you've got an UTF-8 conversion at the end, which seems wrong.  I think you
just want to operate with a Vector of bytes here.

[jww, 2014/04/01 23:29:09]

I think this is irrelevant now because I've modified this to use the new
"digestor" API we've added to WebCrytpo, so we can digest chunks one at a time.

+    digestable.append(node->nodeValue());
 
     if (node->nodeType() == Node::ELEMENT_NODE) {
         Node* child = node->firstChild();
         while (child) {
             OwnPtr<Digest> childInfo = createDigest(child, unusedNodesMap);
-            addStringToSHA1(sha1, childInfo->m_sha1);
+            digestable.append(childInfo->m_sha1);
             child = child->nextSibling();
             digest->m_children.append(childInfo.release());
         }
         Element* element = toElement(node);
 
         if (element->hasAttributesWithoutUpdate()) {
             size_t numAttrs = element->attributeCount();
-            SHA1 attrsSHA1;
+            StringBuilder attrsDigestable;
             for (size_t i = 0; i < numAttrs; ++i) {
                 const Attribute& attribute = element->attributeItem(i);
-                addStringToSHA1(attrsSHA1, attribute.name().toString());
-                addStringToSHA1(attrsSHA1, attribute.value());
+                attrsDigestable.append(attribute.name().toString());
+                attrsDigestable.append(attribute.value());
             }
-            Vector<uint8_t, 20> attrsHash;
-            attrsSHA1.computeHash(attrsHash);
-            digest->m_attrsSHA1 = base64Encode(reinterpret_cast<const char*>(attrsHash.data()), 10);
-            addStringToSHA1(sha1, digest->m_attrsSHA1);
+            CString attrsDigestableCString = attrsDigestable.toString().utf8();
+            CryptoUtil::computeDigest(CryptoUtil::HashAlgorithmSha1, attrsDigestableCString.data(), attrsDigestableCString.length(), digestResult);
+            digest->m_attrsSHA1 = base64Encode(reinterpret_cast<const char*>(digestResult.data()), 10);

[eseidel, 2014/03/12 06:50:29]

I take it we only want the first 10 bytes of the digest?  Odd.

[jww, 2014/04/01 23:29:09]

I don't ask questions; I just make compatible with the old version. But, yes, I
agree, odd :-)

+            digestable.append(digest->m_attrsSHA1);
+            digestResult.clear();
         }
     }
 
-    Vector<uint8_t, 20> hash;
-    sha1.computeHash(hash);
-    digest->m_sha1 = base64Encode(reinterpret_cast<const char*>(hash.data()), 10);
+    CString digestableCString = digestable.toString().utf8();
+    CryptoUtil::computeDigest(CryptoUtil::HashAlgorithmSha1, digestableCString.data(), digestableCString.length(), digestResult);
+    digest->m_sha1 = base64Encode(reinterpret_cast<const char*>(digestResult.data()), 10);
     if (unusedNodesMap)
         unusedNodesMap->add(digest->m_sha1, digest);
     return adoptPtr(digest);
 }
 
 bool DOMPatchSupport::insertBeforeAndMarkAsUsed(ContainerNode* parentNode, Digest* digest, Node* anchor, ExceptionState& exceptionState)
 {
     bool result = m_domEditor->insertBefore(parentNode, digest->m_node, anchor, exceptionState);
     markNodeAsUsed(digest);
     return result;
@@ skipping 51 matching lines @@
 void DOMPatchSupport::dumpMap(const ResultMap& map, const String& name)
 {
     fprintf(stderr, "\n\n");
     for (size_t i = 0; i < map.size(); ++i)
         fprintf(stderr, "%s[%lu]: %s (%p) - [%lu]\n", name.utf8().data(), i, map[i].first ? nodeName(map[i].first->m_node).utf8().data() : "", map[i].first, map[i].second);
 }
 #endif
 
 } // namespace WebCore