Moved SuperFastHash function from base/hash.cc to base/third_party.

base/hash.h

 // 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.
 
 #ifndef BASE_HASH_H_
 #define BASE_HASH_H_
 
+#include <limits>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/logging.h"
 
 namespace base {
 
-// From http://www.azillionmonkeys.com/qed/hash.html
-// This is the hash used on WebCore/platform/stringhash

[Noel Gordon, 2014/03/04 08:39:52]

Late to this party, but why did the reference to the Blink (nee WebCore) gets
nixed here?

Seems it's in wtf/StringHasher.g these days :
https://chromium.googlesource.com/chromium/blink/+/master/Source/wtf/StringHa...

[Matt Giuca, 2014/03/04 23:47:31]

Ah, is that where it is. I did a brief search for it and didn't find it, so I
deleted this comment.

But even having found it, I don't see the point of a comment that says "this is
the hash used elsewhere".

1. It doesn't seem relevant; it's a totally separate implementation of the same
algorithm and changing one will not affect the other (so why add a "dependency"
-- if it moves again, this comment will get out of date again).

2. It's dangerous to say "it's the same as X" because they seem to have drifted
apart so far that they are now slightly different algorithms. In particular, the
upstream version used in Chromium has a special bug^H^H^Hcase where it treats
the last byte as signed rather than unsigned. (It was discussed in 2011 and
decided to keep this bug for backwards compatibility.) Whereas the Blink version
appears to have fixed this bug.

-BASE_EXPORT uint32 SuperFastHash(const char * data, int len);
+// WARNING: This hash function should not be used for any cryptographic purpose.
+BASE_EXPORT uint32 SuperFastHash(const char* data, int len);
 
+// Computes the hash of a string |key| of a given |length|. |key| does not need

[Noel Gordon, 2014/03/04 08:39:52]

"hash of a string"?  |key| does not appear to be a string - it seems to be just
a pointer to memory.  What am I missing?

Also, the hash is computed over |length| memory bytes.  I would be an astonished
API user if null bytes caused the hash computation to exit
early.

[Matt Giuca, 2014/03/04 23:47:31]

Yeah, all correct. I was just trying to be quite clear about the behaviour but
in hindsight, maybe it would have been easier to say "hash of a block of
memory". Do you think it's worth updating this comment?

+// to be null-terminated, and may contain null bytes.
+// WARNING: This hash function should not be used for any cryptographic purpose.
 inline uint32 Hash(const char* key, size_t length) {
+  if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    NOTREACHED();
+    return 0;
+  }
   return SuperFastHash(key, static_cast<int>(length));
 }
 
+// Computes the hash of a string |key|.
+// WARNING: This hash function should not be used for any cryptographic purpose.
 inline uint32 Hash(const std::string& key) {
-  if (key.empty())
-    return 0;
-  return SuperFastHash(key.data(), static_cast<int>(key.size()));
+  return Hash(key.data(), key.size());
 }
 
 }  // namespace base
 
 #endif  // BASE_HASH_H_