Reland restrict extension features based on the extension type.

chrome/browser/extensions/extension_prefs.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/manifest_value.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 
 using base::Time;
 
 namespace {
 
 // The number of apps per page. This isn't a hard limit, but new apps installed
@@ skipping 1068 matching lines @@
   extension_dict->Set(kPrefContentSettings, new ListValue());
   extension_dict->Set(kPrefIncognitoContentSettings, new ListValue());
 
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path());
   extension_dict->Set(kPrefPath, Value::CreateStringValue(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (extension->location() != Extension::LOAD) {
     extension_dict->Set(kPrefManifest,
-                        extension->manifest_value()->DeepCopy());
+                        extension->manifest_value()->value()->DeepCopy());

[Aaron Boodman, 2011/11/23 01:45:25]

Yeah, calling this thing just "manifest" would make this read better
(extension->manifest()->value()...)

[jstritar, 2011/11/28 23:09:56]

Yeah, much better. Done.

   }
 
   if (extension->is_app()) {
     if (page_index == -1)
       page_index = GetNaturalAppPageIndex();
     extension_dict->Set(kPrefPageIndex,
                         Value::CreateIntegerValue(page_index));
     extension_dict->Set(kPrefAppLaunchIndex,
         Value::CreateIntegerValue(GetNextAppLaunchIndex(page_index)));
   }
@@ skipping 69 matching lines @@
 }
 
 void ExtensionPrefs::UpdateManifest(const Extension* extension) {
   if (extension->location() != Extension::LOAD) {
     const DictionaryValue* extension_dict = GetExtensionPref(extension->id());
     if (!extension_dict)
       return;
     DictionaryValue* old_manifest = NULL;
     bool update_required =
         !extension_dict->GetDictionary(kPrefManifest, &old_manifest) ||
-        !extension->manifest_value()->Equals(old_manifest);
+        !extension->manifest_value()->value()->Equals(old_manifest);
     if (update_required) {
       UpdateExtensionPref(extension->id(), kPrefManifest,
-                          extension->manifest_value()->DeepCopy());
+                          extension->manifest_value()->value()->DeepCopy());
     }
   }
 }
 
 FilePath ExtensionPrefs::GetExtensionPath(const std::string& extension_id) {
   const DictionaryValue* dict = GetExtensionPref(extension_id);
   if (!dict)
     return FilePath();
 
   std::string path;
@@ skipping 623 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }