Add content pack information to Extension.

chrome/common/extensions/extension.cc

 // 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.
 
 #include "chrome/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 1332 matching lines @@
 }
 
 bool Extension::can_be_incognito_enabled() const {
   return !is_platform_app();
 }
 
 bool Extension::is_theme() const {
   return manifest()->is_theme();
 }
 
+ExtensionResource Extension::GetContentPackSiteList() const {
+  if (content_pack_site_list_.empty())
+    return ExtensionResource();
+
+  return GetResource(content_pack_site_list_);
+}
+
 GURL Extension::GetBackgroundURL() const {
   if (background_scripts_.empty())
     return background_url_;
   return GetResourceURL(extension_filenames::kGeneratedBackgroundPageFilename);
 }
 
 Extension::RuntimeData::RuntimeData() {}
 Extension::RuntimeData::RuntimeData(const PermissionSet* active)
     : active_permissions_(active) {}
 Extension::RuntimeData::~RuntimeData() {}
@@ skipping 85 matching lines @@
   if (path_str.size() >= 2 && path_str[0] >= L'a' && path_str[0] <= L'z' &&
       path_str[1] == ':')
     path_str[0] += ('A' - 'a');
 
   return FilePath(path_str);
 #else
   return path;
 #endif
 }
 
+bool Extension::LoadManagedModeFeatures(string16* error) {
+  if (!manifest_->HasKey(keys::kContentPack))
+    return true;
+  DictionaryValue* content_pack_value = NULL;
+  if (!manifest_->GetDictionary(keys::kContentPack, &content_pack_value)) {
+    *error = ASCIIToUTF16(errors::kInvalidContentPack);
+    return false;
+  }
+
+  if (!LoadManagedModeSites(content_pack_value, error))
+    return false;
+  if (!LoadManagedModeConfigurations(content_pack_value, error))
+    return false;
+
+  return true;
+}
+
+bool Extension::LoadManagedModeSites(
+    const DictionaryValue* content_pack_value,
+    string16* error) {
+  if (!content_pack_value->HasKey(keys::kContentPackSites))
+    return true;
+
+  FilePath::StringType site_list_str;
+  if (!content_pack_value->GetString(keys::kContentPackSites, &site_list_str)) {
+    *error = ASCIIToUTF16(errors::kInvalidContentPackSites);
+    return false;
+  }
+
+  content_pack_site_list_ = FilePath(site_list_str);
+
+  return true;
+}
+
+bool Extension::LoadManagedModeConfigurations(
+    const DictionaryValue* content_pack_value,
+    string16* error) {
+  NOTIMPLEMENTED();
+  return true;
+}
+
 // static
 bool Extension::IsTrustedId(const std::string& id) {
   // See http://b/4946060 for more details.
   return id == std::string("nckgahadagoaajjgafhacjanaoiihapd");
 }
 
 Extension::Extension(const FilePath& path,
                      scoped_ptr<extensions::Manifest> manifest)
     : manifest_version_(0),
       incognito_split_mode_(false),
@@ skipping 106 matching lines @@
 
   if (!LoadSharedFeatures(api_permissions, error))
     return false;
 
   if (!LoadExtensionFeatures(&api_permissions, error))
     return false;
 
   if (!LoadThemeFeatures(error))
     return false;
 
+  if (!LoadManagedModeFeatures(error))
+    return false;
+
   if (HasMultipleUISurfaces()) {
     *error = ASCIIToUTF16(errors::kOneUISurfaceOnly);
     return false;
   }
 
   runtime_data_.SetActivePermissions(new PermissionSet(
       this, api_permissions, host_permissions));
   required_permission_set_ = new PermissionSet(
       this, api_permissions, host_permissions);
   optional_permission_set_ = new PermissionSet(
@@ skipping 2454 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions