Reland restrict extension features based on the extension type.

chrome/common/extensions/manifest.h

Index: chrome/common/extensions/manifest.h
diff --git a/chrome/common/extensions/manifest.h b/chrome/common/extensions/manifest.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb372708d5415301944c1a737570f139bf414128
--- /dev/null
+++ b/chrome/common/extensions/manifest.h
@@ -0,0 +1,112 @@
+// 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 CHROME_COMMON_EXTENSIONS_MANIFEST_H_
+#define CHROME_COMMON_EXTENSIONS_MANIFEST_H_
+#pragma once
+
+#include <map>
+#include <string>
+#include <set>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/string16.h"
+
+namespace base {
+class DictionaryValue;
+class ListValue;
+class Value;
+}
+
+namespace extensions {
+
+// Lightweight wrapper around a DictionaryValue representing an extension's
+// manifest. Currently enforces access to properties of the manifest based
+// on manifest type.
+//
+// TODO(aa): Move more smarts about mmanifest into this class over time.
+class Manifest {
+ public:
+  // Flags for matching types of extension manifests.
+  enum Type {
+    kTypeNone = 0,
+
+    // Extension::TYPE_EXTENSION and Extension::TYPE_USER_SCRIPT
+    kTypeExtension = 1 << 0,
+
+    // Extension::TYPE_THEME
+    kTypeTheme = 1 << 1,
+
+    // Extension::TYPE_HOSTED_APP
+    kTypeHostedApp = 1 << 2,
+
+    // Extension::TYPE_PACKAGED_APP
+    kTypePackagedApp = 1 << 3,
+
+    // Extension::TYPE_PLATFORM_APP
+    kTypePlatformApp = 1 << 4,
+
+    // All types
+    kTypeAll = (1 << 5) - 1,
+  };
+
+  // Returns all known keys (this is used for testing).
+  static std::set<std::string> GetAllKnownKeys();
+
+  // Takes over ownership of |value|.
+  explicit Manifest(base::DictionaryValue* value);
+  virtual ~Manifest();
+
+  // Returns true if all keys in the manifest can be specified by
+  // the extension type.
+  bool ValidateManifest(std::string* error) const;
+
+  // Returns the manifest type.
+  Type GetType() const;
+
+  // Returns true if the manifest represents an Extension::TYPE_THEME.
+  bool IsTheme() const;
+
+  // Returns true for Extension::TYPE_PLATFORM_APP
+  bool IsPlatformApp() const;
+
+  // Returns true for Extension::TYPE_PACKAGED_APP.
+  bool IsPackagedApp() const;
+
+  // Returns true for Extension::TYPE_HOSTED_APP.
+  bool IsHostedApp() const;
+
+  // These access the wrapped manifest value, returning false when the property
+  // does not exist or if the manifest type can't access it.
+  bool HasKey(const std::string& key) const;
+  bool Get(const std::string& path, base::Value** out_value) const;
+  bool GetBoolean(const std::string& path, bool* out_value) const;
+  bool GetInteger(const std::string& path, int* out_value) const;
+  bool GetString(const std::string& path, std::string* out_value) const;
+  bool GetString(const std::string& path, string16* out_value) const;
+  bool GetDictionary(const std::string& path,
+                     base::DictionaryValue** out_value) const;
+  bool GetList(const std::string& path, base::ListValue** out_value) const;
+
+  // Returns a new Manifest equal to this one, passing ownership to
+  // the caller.
+  Manifest* DeepCopy() const;
+
+  // Returns true if this equals the |other| manifest.
+  bool Equals(const Manifest* other) const;
+
+  // Gets the underlying DictionaryValue representing the manifest.
+  // Note: only know this when you KNOW you don't need the validation.
+  base::DictionaryValue* value() const { return value_.get(); }
+
+ private:
+  // Returns true if the extension can specify the given |path|.
+  bool CanAccessPath(const std::string& path) const;
+
+  scoped_ptr<base::DictionaryValue> value_;
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_COMMON_EXTENSIONS_MANIFEST_H_