A bunch of remaining parts of extension content verification

extensions/browser/computed_hashes.h

Index: extensions/browser/computed_hashes.h
diff --git a/extensions/browser/computed_hashes.h b/extensions/browser/computed_hashes.h
new file mode 100644
index 0000000000000000000000000000000000000000..c68175c8d2c832107335eb4d8abd60266b23540f
--- /dev/null
+++ b/extensions/browser/computed_hashes.h
@@ -0,0 +1,64 @@
+// 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.
+
+#ifndef EXTENSIONS_BROWSER_COMPUTED_HASHES_H_
+#define EXTENSIONS_BROWSER_COMPUTED_HASHES_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/values.h"
+
+namespace base {
+class FilePath;
+}
+
+namespace extensions {
+
+// A pair of classes for serialization of a set of SHA256 block hashes computed
+// over the files inside an extension.
+class ComputedHashes {
+ public:
+  class Reader {

[Ken Rockot(use gerrit already), 2014/05/15 00:51:25]

nit: I guess I'd rather see separate classes in separate source modules for
ComputedHashesReader and ComputedHashesWriter, but I don't feel strongly about
it.

[asargent_no_longer_on_chrome, 2014/05/15 04:02:49]

I filed crbug.com/373597 for looking into doing this as a follow-up. One
advantage I saw of doing it this way was that I could have the key name
constants in one anonymous namespace in the shared .cc file. OTOH, most
consumers are typically only using one or the other, so having them declared in
the same header causes unnecessary code inclusion. 

+   public:
+    Reader();
+    ~Reader();
+    bool InitFromFile(const base::FilePath& path);
+
+    // The block size and hashes for |relative_path| will be copied into the
+    // out parameters.
+    bool GetHashes(const base::FilePath& relative_path,
+                   int* block_size,
+                   std::vector<std::string>* hashes);
+
+   private:
+    typedef std::pair<int, std::vector<std::string> > HashInfo;
+
+    // This maps a relative path to a pair of (block size, hashes)
+    std::map<base::FilePath, HashInfo> data_;
+  };
+
+  class Writer {
+   public:
+    Writer();
+    ~Writer();
+
+    // Adds hashes for |relative_path|. Should not be called more than once
+    // for a given |relative_path|.
+    void AddHashes(const base::FilePath& relative_path,
+                   int block_size,
+                   const std::vector<std::string>& hashes);
+
+    bool WriteToFile(const base::FilePath& path);
+
+   private:
+    // The top-level object that will be serialized as JSON.
+    base::ListValue file_list_;
+  };
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_COMPUTED_HASHES_H_