Separate http_security_headers from transport_security_state

net/base/hash_value.h

+// Copyright (c) 2012 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 NET_BASE_HASH_VALUE_H_
+#define NET_BASE_HASH_VALUE_H_
+
+#include <string.h>
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "build/build_config.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+// Types (SHA1HashValue, SHA256HashValue, HashValue, HashValueVector)

[Ryan Sleevi, 2012/11/13 19:02:32]

Drop this comment (and the other 'sectional' notations - eg: 72, 103)

[unsafe, 2012/11/13 23:20:18]

Done.

+
+struct NET_EXPORT SHA1HashValue {
+  bool Equals(const SHA1HashValue& other) const {
+    return memcmp(data, other.data, sizeof(data)) == 0;
+  }
+
+  unsigned char data[20];
+};
+
+struct NET_EXPORT SHA256HashValue {
+  bool Equals(const SHA256HashValue& other) const {
+    return memcmp(data, other.data, sizeof(data)) == 0;
+  }
+
+  unsigned char data[32];
+};
+
+enum HashValueTag {
+  HASH_VALUE_SHA1,
+  HASH_VALUE_SHA256,
+
+  // This must always be last.
+  HASH_VALUE_TAGS_COUNT
+};
+
+class NET_EXPORT HashValue {
+ public:
+  explicit HashValue(HashValueTag tag) : tag(tag) {}
+  HashValue() : tag(HASH_VALUE_SHA1) {}
+
+  bool Equals(const HashValue& other) const;
+
+  // Parse/write in this format: "sha1/Guzek9lMwR3KeIS8wwS9gBvVtIg="

[Ryan Sleevi, 2012/11/13 19:02:32]

nit: Can you expand on the comments for these methods a bit, based on
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Functi...
?

Things to mention:
1) what the form of the string is (eg: <hash-name>/<hash-value>"
2) Is this intended to be a stable, serialized form - or simply a logging form
3) What the state of the object is on error (FromString)
4) What the state of the output string is on error (ToString)

[unsafe, 2012/11/13 23:20:18]

Done.

+  bool FromString(const std::string& input);

[Ryan Sleevi, 2012/11/13 19:02:32]

API: suggestion: Use (const base::StringPiece& input) instead.

[unsafe, 2012/11/13 23:20:18]

I don't know what the conventions are around std::string vs StringPiece, so I'm
inclined to just leave this...

+  std::string ToString() const;
+
+  size_t size() const;
+  unsigned char* data();
+  const unsigned char* data() const;
+
+  HashValueTag tag;
+
+ private:
+  union {
+    SHA1HashValue sha1;
+    SHA256HashValue sha256;
+  } fingerprint;
+};
+
+typedef std::vector<HashValue> HashValueVector;
+
+
+// Predicates for types
+
+class NET_EXPORT SHA1HashValueLessThan {

[Ryan Sleevi, 2012/11/13 19:02:32]

As far as NET_EXPORT goes, I don't believe any of the following classes need to
be NET_EXPORTed - that is, they're not used outside of the 'net' module, ergo no
need to export them.

Keeping it internal to the module is more of a check to make sure the right
abstractions are being exposed to those who depend on the net module.

It may be better to address this in a follow-up, just to keep to a minimum
changes when moving code between files (makes it easier to code spleunk the
diffs to keep changes minimal when moving)

[unsafe, 2012/11/13 23:20:18]

I removed NET_EXPORT from this whole file, apparently nothing needs it...

[Ryan Sleevi, 2012/11/13 23:32:05]

I'm not sure that's true, or you may not be building in shared-library mode. It
should definitely be needed for HashValue, which is used by chrome/browser/net -
not to mention HashValueVector and friends.

When I looked at the dependencies, it was only from this point onwards in the
file that it wasn't necessary

+ public:
+  bool operator()(const SHA1HashValue& lhs,
+                  const SHA1HashValue& rhs) const {
+    return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) < 0;
+  }
+};
+
+class NET_EXPORT SHA256HashValueLessThan {
+ public:
+  bool operator()(const SHA256HashValue& lhs,
+                  const SHA256HashValue& rhs) const {
+    return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) < 0;
+  }
+};
+
+class NET_EXPORT HashValuesEqual {
+  public:
+  explicit HashValuesEqual(const HashValue& fingerprint) :
+      fingerprint_(fingerprint) {}
+
+  bool operator()(const HashValue& other) const {
+    return fingerprint_.Equals(other);
+  }
+
+  const HashValue& fingerprint_;
+};
+
+
+// Misc hash-related funcs

[palmer, 2012/11/13 19:35:04]

NIT: s/funcs/functions./

[unsafe, 2012/11/13 23:20:18]

Removed entire (sectional) comment.

+
+// IsSHA1HashInSortedArray returns true iff |hash| is in |array|, a sorted
+// array of SHA1 hashes.
+bool NET_EXPORT IsSHA1HashInSortedArray(const SHA1HashValue& hash,
+                                        const uint8* array,
+                                        size_t array_byte_len);
+
+}  // namespace net
+
+#endif  // NET_BASE_HASH_VALUE_H_