Fix 2 bugs related to remembering loaded unpacked extensions.

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2009 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 "base/string_util.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 
 using base::Time;
@@ skipping 18 matching lines @@
 // The dictionary containing the extension's manifest.
 const wchar_t kPrefManifest[] = L"manifest";
 
 // The version number.
 const wchar_t kPrefVersion[] = L"manifest.version";
 
 // Indicates if an extension is blacklisted:
 const wchar_t kPrefBlacklist[] = L"blacklist";
 
 // Indicates whether to show an install warning when the user enables.
-const wchar_t kShowInstallWarning[] = L"install_warning_on_enable";
+const wchar_t kExtensionDidEscalatePermissions[] = L"install_warning_on_enable";
 
 // A preference that tracks extension shelf configuration.  This is a list
 // object read from the Preferences file, containing a list of toolstrip URLs.
 const wchar_t kExtensionShelf[] = L"extensions.shelf";
 
 // A preference that tracks browser action toolbar configuration. This is a list
 // object stored in the Preferences file. The extensions are stored by ID.
 const wchar_t kExtensionToolbar[] = L"extensions.toolbar";
 
 // The key for a serialized Time value indicating the start of the day (from the
@@ skipping 131 matching lines @@
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
     const std::string& extension_id) {
-  return ReadExtensionPrefBoolean(extension_id, kShowInstallWarning);
+  return ReadExtensionPrefBoolean(extension_id,
+                                  kExtensionDidEscalatePermissions);
+}
+
+void ExtensionPrefs::SetDidExtensionEscalatePermissions(
+    Extension* extension, bool did_escalate) {
+  UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions,
+                      Value::CreateBooleanValue(did_escalate));
+  prefs_->SavePersistentPrefs();
 }
 
 void ExtensionPrefs::UpdateBlacklist(
   const std::set<std::string>& blacklist_set) {
   std::vector<std::string> remove_pref_ids;
   std::set<std::string> used_id_set;
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
 
   if (extensions) {
     for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
@@ skipping 209 matching lines @@
   return static_cast<Extension::State>(state);
 }
 
 void ExtensionPrefs::SetExtensionState(Extension* extension,
                                        Extension::State state) {
   UpdateExtensionPref(extension->id(), kPrefState,
                       Value::CreateIntegerValue(state));
   prefs_->SavePersistentPrefs();
 }
 
-void ExtensionPrefs::SetShowInstallWarningOnEnable(
-    Extension* extension, bool require) {
-  UpdateExtensionPref(extension->id(), kShowInstallWarning,
-                      Value::CreateBooleanValue(require));
-  prefs_->SavePersistentPrefs();
-}
-
 std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
   DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return std::string();
 
   std::string version;
   if (!extension->GetString(kPrefVersion, &version)) {
     LOG(ERROR) << "Bad or missing pref 'version' for extension '"
                << extension_id << "'";
   }
@@ skipping 54 matching lines @@
     const std::string& extension_id) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict)
     return NULL;
   DictionaryValue* extension = NULL;
   std::wstring id = ASCIIToWide(extension_id);
   dict->GetDictionary(id, &extension);
   return extension;
 }
 
-// static
-ExtensionPrefs::ExtensionsInfo* ExtensionPrefs::CollectExtensionsInfo(
-    ExtensionPrefs* prefs) {
-  scoped_ptr<DictionaryValue> extension_data(
-      prefs->CopyCurrentExtensions());
+// Helper function for GetInstalledExtensionsInfo.
+static ExtensionInfo* GetInstalledExtensionInfoImpl(
+    DictionaryValue* extension_data,
+    DictionaryValue::key_iterator extension_id) {
+  DictionaryValue* ext;
+  if (!extension_data->GetDictionaryWithoutPathExpansion(*extension_id, &ext)) {
+    LOG(WARNING) << "Invalid pref for extension " << *extension_id;
+    NOTREACHED();
+    return NULL;
+  }
+  if (ext->HasKey(kPrefBlacklist)) {
+    bool is_blacklisted = false;
+    if (!ext->GetBoolean(kPrefBlacklist, &is_blacklisted)) {
+      NOTREACHED() << "Invalid blacklist pref:" << *extension_id;
+      return NULL;
+    }
+    if (is_blacklisted) {
+      LOG(WARNING) << "Blacklisted extension: " << *extension_id;
+      return NULL;
+    }
+  }
+  int state_value;
+  if (!ext->GetInteger(kPrefState, &state_value)) {
+    LOG(WARNING) << "Missing state pref for extension " << *extension_id;
+    NOTREACHED();
+    return NULL;
+  }
+  if (state_value == Extension::KILLBIT) {
+    LOG(WARNING) << "External extension has been uninstalled by the user "
+                 << *extension_id;
+    return NULL;
+  }
+  FilePath::StringType path;
+  if (!ext->GetString(kPrefPath, &path)) {
+    LOG(WARNING) << "Missing path pref for extension " << *extension_id;
+    NOTREACHED();
+    return NULL;
+  }
+  int location_value;
+  if (!ext->GetInteger(kPrefLocation, &location_value)) {
+    LOG(WARNING) << "Missing location pref for extension " << *extension_id;
+    NOTREACHED();
+    return NULL;
+  }
+
+  // Only the following extension types can be installed permanently in the
+  // preferences.
+  Extension::Location location =
+      static_cast<Extension::Location>(location_value);
+  if (location != Extension::INTERNAL &&
+      location != Extension::LOAD &&
+      !Extension::IsExternalLocation(location)) {
+    NOTREACHED();
+    return NULL;
+  }
+
+  DictionaryValue* manifest = NULL;
+  if (!ext->GetDictionary(kPrefManifest, &manifest)) {
+    LOG(WARNING) << "Missing manifest for extension " << *extension_id;
+    // Just a warning for now.
+  }
+
+  return new ExtensionInfo(manifest, WideToASCII(*extension_id),
+                           FilePath(path), location);
+}
+
+ExtensionPrefs::ExtensionsInfo* ExtensionPrefs::GetInstalledExtensionsInfo() {
+  scoped_ptr<DictionaryValue> extension_data(CopyCurrentExtensions());
 
   ExtensionsInfo* extensions_info = new ExtensionsInfo;
 
   for (DictionaryValue::key_iterator extension_id(
            extension_data->begin_keys());
        extension_id != extension_data->end_keys(); ++extension_id) {
-    DictionaryValue* ext;
-    if (!extension_data->GetDictionaryWithoutPathExpansion(*extension_id,
-                                                            &ext)) {
-      LOG(WARNING) << "Invalid pref for extension " << *extension_id;
-      NOTREACHED();
-      continue;
-    }
-    if (ext->HasKey(kPrefBlacklist)) {
-      bool is_blacklisted = false;
-      if (!ext->GetBoolean(kPrefBlacklist, &is_blacklisted)) {
-        NOTREACHED() << "Invalid blacklist pref:" << *extension_id;
-        continue;
-      }
-      if (is_blacklisted) {
-        LOG(WARNING) << "Blacklisted extension: " << *extension_id;
-        continue;
-      }
-    }
-    int state_value;
-    if (!ext->GetInteger(kPrefState, &state_value)) {
-      LOG(WARNING) << "Missing state pref for extension " << *extension_id;
-      NOTREACHED();
-      continue;
-    }
-    if (state_value == Extension::KILLBIT) {
-      LOG(WARNING) << "External extension has been uninstalled by the user "
-                   << *extension_id;
-      continue;
-    }
-    FilePath::StringType path;
-    if (!ext->GetString(kPrefPath, &path)) {
-      LOG(WARNING) << "Missing path pref for extension " << *extension_id;
-      NOTREACHED();
-      continue;
-    }
-    int location_value;
-    if (!ext->GetInteger(kPrefLocation, &location_value)) {
-      LOG(WARNING) << "Missing location pref for extension " << *extension_id;
-      NOTREACHED();
-      continue;
-    }
-
-    // Only the following extension types can be installed permanently in the
-    // preferences.
-    Extension::Location location =
-        static_cast<Extension::Location>(location_value);
-    if (location != Extension::INTERNAL &&
-        location != Extension::LOAD &&
-        !Extension::IsExternalLocation(location)) {
-      NOTREACHED();
-      continue;
-    }
-
-    DictionaryValue* manifest = NULL;
-    if (!ext->GetDictionary(kPrefManifest, &manifest)) {
-      LOG(WARNING) << "Missing manifest for extension " << *extension_id;
-      // Just a warning for now.
-    }
-
-    extensions_info->push_back(linked_ptr<ExtensionInfo>(new ExtensionInfo(
-        manifest, WideToASCII(*extension_id), FilePath(path), location)));
+    ExtensionInfo* info = GetInstalledExtensionInfoImpl(extension_data.get(),
+                                                        extension_id);
+    if (info)
+      extensions_info->push_back(linked_ptr<ExtensionInfo>(info));
   }
 
   return extensions_info;
 }
 
+ExtensionInfo* ExtensionPrefs::GetInstalledExtensionInfo(
+    const std::string& extension_id) {
+  scoped_ptr<DictionaryValue> extension_data(CopyCurrentExtensions());
+
+  for (DictionaryValue::key_iterator extension_iter(
+           extension_data->begin_keys());
+       extension_iter != extension_data->end_keys(); ++extension_iter) {
+    if (WideToASCII(*extension_iter) == extension_id) {
+      return GetInstalledExtensionInfoImpl(extension_data.get(),
+                                           extension_iter);
+    }
+  }
+
+  return NULL;
+}
+
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref);
   prefs->RegisterListPref(kExtensionShelf);
   prefs->RegisterListPref(kExtensionToolbar);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize, -1);
 }