Added a PolicyManifestHandler.

chrome/browser/extensions/api/storage/storage_schema_manifest_handler.cc

+// Copyright (c) 2013 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.
+
+#include "chrome/browser/extensions/api/storage/storage_schema_manifest_handler.h"
+
+#include <string>
+#include <vector>
+
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/string16.h"
+#include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/policy/policy_schema.h"
+#include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/manifest.h"
+#include "chrome/common/extensions/permissions/api_permission.h"
+#include "extensions/common/install_warning.h"
+
+using extension_manifest_keys::kStorageManagedSchema;
+
+namespace extensions {
+
+StorageSchemaManifestHandler::StorageSchemaManifestHandler() {}
+
+StorageSchemaManifestHandler::~StorageSchemaManifestHandler() {}
+
+// static
+scoped_ptr<policy::PolicySchema> StorageSchemaManifestHandler::GetSchema(
+    const Extension* extension,
+    std::string* error) {

[not at google - send to devlin, 2013/05/25 00:50:57]

DCHECK(FILE)?

[Joao da Silva, 2013/05/27 12:13:11]

The file operations (file_util::*) eventually hit a
"base::ThreadRestrictions::AssertIOAllowed();", which is sufficient. This
doesn't need the FILE thread exactly, just a thread that allows file IO (note
that this is actually called from the blocking pool in
managed_value_store_cache.cc)

+  if (!extension->HasAPIPermission(APIPermission::kStorage)) {
+    *error = base::StringPrintf("The storage permission is required to use %s",
+                                kStorageManagedSchema);
+    return scoped_ptr<policy::PolicySchema>();
+  }
+  std::string path;
+  extension->manifest()->GetString(kStorageManagedSchema, &path);
+  base::FilePath file = base::FilePath::FromUTF8Unsafe(path);
+  if (file.IsAbsolute() || file.ReferencesParent()) {
+    *error = base::StringPrintf("%s must be a relative path without ..",
+                                kStorageManagedSchema);
+    return scoped_ptr<policy::PolicySchema>();
+  }
+  file = extension->path().AppendASCII(path);
+  if (!file_util::PathExists(file)) {
+    *error =
+        base::StringPrintf("File does not exist: %s", file.value().c_str());
+    return scoped_ptr<policy::PolicySchema>();
+  }
+  std::string content;
+  if (!file_util::ReadFileToString(file, &content)) {
+    *error = base::StringPrintf("Can't read %s", file.value().c_str());
+    return scoped_ptr<policy::PolicySchema>();
+  }
+  return policy::PolicySchema::Parse(content, error);
+}
+
+bool StorageSchemaManifestHandler::Parse(Extension* extension,
+                                         string16* error) {
+  std::string path;
+  if (!extension->manifest()->GetString(kStorageManagedSchema, &path)) {
+    *error = ASCIIToUTF16(
+        base::StringPrintf("%s must be a string", kStorageManagedSchema));
+    return false;
+  }
+  return true;
+}
+
+bool StorageSchemaManifestHandler::Validate(
+    const Extension* extension,
+    std::string* error,
+    std::vector<InstallWarning>* warnings) const {
+  return !!GetSchema(extension, error);
+}
+
+const std::vector<std::string> StorageSchemaManifestHandler::Keys() const {
+  return SingleKey(kStorageManagedSchema);
+}
+
+}  // namespace extensions