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 486 matching lines @@
 }
 
 bool Extension::is_packaged_app() const {
   return manifest()->is_packaged_app();
 }
 
 bool Extension::is_theme() const {
   return manifest()->is_theme();
 }
 
+bool Extension::is_content_pack() const {
+  return manifest()->is_content_pack();
+}
+
+FilePath Extension::GetContentPackSiteList() const {
+  if (content_pack_site_list_.empty())
+    return FilePath();
+
+  // TODO(bauerb): Use ExtensionResource?
+  return path().Append(content_pack_site_list_);
+}
+
 GURL Extension::GetBackgroundURL() const {
   if (!background_scripts_.empty()) {
     return GetResourceURL(
         extension_filenames::kGeneratedBackgroundPageFilename);
   } else {
     return background_url_;
   }
 }
 
 bool Extension::ResourceMatches(const URLPatternSet& pattern_set,
@@ skipping 2362 matching lines @@
                                            string16* error) {
   const DictionaryValue* display_properties_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
                                  &display_properties_value)) {
     theme_display_properties_.reset(
         display_properties_value->DeepCopy());
   }
   return true;
 }
 
+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;
+
+  return true;
+}
+
+bool Extension::LoadManagedModeSites(
+    const DictionaryValue* content_pack_value,
+    string16* error) {
+  if (!content_pack_value->HasKey(keys::kContentPackSites))
+    return true;
+
+  if (!content_pack_value->GetString(keys::kContentPackSites,
+                                     &content_pack_site_list_)) {
+    *error = ASCIIToUTF16(errors::kInvalidContentPackSites);
+    return false;
+  }
+
+  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 248 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 734 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions