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..223ff5edeb11d7134fafce574b4314bc175f4766
--- /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 extensino manifests.

[Aaron Boodman, 2011/12/01 21:32:04]

typo: extensino

[jstritar, 2011/12/02 16:26:33]

Done.

+  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;

[Aaron Boodman, 2011/12/01 21:32:04]

Something to consider for the future:

This API from DictionaryValue is terrible. It requires two lines for every call,
even if you know that it won't fail, or don't care about failures.

It would be nice if there was a convenience form of each of these getters too,
that simply returned the value (or a default in the case of failure).

[jstritar, 2011/12/02 16:26:33]

Agreed, the DictionaryValue API is really annoying.

I'd eventually like to hide the fact that this is a DictionaryValue, and only
expose higher level accessors like IsPlatformApp() and GetDefaultPermissions().
Then we can support manifest versions by having subclasses that override the old
accessors. This would also let us get rid of the duplicate data (members on
Extension and the data in DictionaryValue) as you mentioned in the other code
review.

We'd still want to simplify these methods though (and make them private).

+  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_