Garbage Collect the Storage directory on next profile start after an extension uninstall.

chrome/browser/extensions/extension_prefs.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/browser/extensions/extension_prefs.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 98 matching lines @@
 
 // Similar to kLastPingDay, but for "active" instead of "rollcall" pings.
 const char kLastActivePingDay[] = "last_active_pingday";
 
 // A bit we use to keep track of whether we need to do an "active" ping.
 const char kActiveBit[] = "active_bit";
 
 // Path for settings specific to blacklist update.
 const char kExtensionsBlacklistUpdate[] = "extensions.blacklistupdate";
 
-// Path for the idle install info dictionary preference.
-const char kIdleInstallInfo[] = "idle_install_info";
+// Path for the delayed install info dictionary preference. The actual string
+// value is a legacy artifact for when delayed installs only pertained to
+// updates that were waiting for idle.
+const char kDelayedInstallInfo[] = "idle_install_info";
 
 // Path for the suggested page ordinal of a delayed extension install.
 const char kPrefSuggestedPageOrdinal[] = "suggested_page_ordinal";
 
 // A preference that, if true, will allow this extension to run in incognito
 // mode.
 const char kPrefIncognitoEnabled[] = "incognito";
 
 // A preference to control whether an extension is allowed to inject script in
 // pages with file URLs.
@@ skipping 1537 matching lines @@
       continue;
 
     scoped_ptr<ExtensionInfo> info = GetInstalledExtensionInfo(*extension_id);
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info.Pass();
 }
 
-void ExtensionPrefs::SetIdleInstallInfo(
+void ExtensionPrefs::SetDelayedInstallInfo(
     const Extension* extension,
     Extension::State initial_state,
     const syncer::StringOrdinal& page_ordinal) {
   DictionaryValue* extension_dict = new DictionaryValue();
   PopulateExtensionInfoPrefs(extension, time_provider_->GetCurrentTime(),
                              initial_state, extension_dict);
 
-  // Add transient data that is needed by FinishIdleInstallInfo(), but
+  // Add transient data that is needed by FinishDelayedInstallInfo(), but
   // should not be in the final extension prefs. All entries here should have
-  // a corresponding Remove() call in FinishIdleInstallInfo().
+  // a corresponding Remove() call in FinishDelayedInstallInfo().
   if (extension->RequiresSortOrdinal()) {
     extension_dict->SetString(kPrefSuggestedPageOrdinal,
                               page_ordinal.ToInternalValue());
   }
 
-  UpdateExtensionPref(extension->id(), kIdleInstallInfo, extension_dict);
+  UpdateExtensionPref(extension->id(), kDelayedInstallInfo, extension_dict);
 }
 
-bool ExtensionPrefs::RemoveIdleInstallInfo(const std::string& extension_id) {
+bool ExtensionPrefs::RemoveDelayedInstallInfo(
+    const std::string& extension_id) {
   if (!GetExtensionPref(extension_id))
     return false;
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
-  bool result = update->Remove(kIdleInstallInfo, NULL);
+  bool result = update->Remove(kDelayedInstallInfo, NULL);
   return result;
 }
 
-bool ExtensionPrefs::FinishIdleInstallInfo(const std::string& extension_id) {
+bool ExtensionPrefs::FinishDelayedInstallInfo(
+    const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   DictionaryValue* extension_dict = update.Get();
   DictionaryValue* pending_install_dict = NULL;
-  if (!extension_dict->GetDictionary(kIdleInstallInfo, &pending_install_dict))
+  if (!extension_dict->GetDictionary(kDelayedInstallInfo,
+                                     &pending_install_dict)) {
     return false;
+  }
 
-  // Retrieve and clear transient values populated by SetIdleInstallInfo(). Also
-  // do any other data cleanup that makes sense.
+  // Retrieve and clear transient values populated by SetDelayedInstallInfo().
+  // Also do any other data cleanup that makes sense.
   std::string serialized_ordinal;
   syncer::StringOrdinal suggested_page_ordinal;
   bool needs_sort_ordinal = false;
   if (pending_install_dict->GetString(kPrefSuggestedPageOrdinal,
                                       &serialized_ordinal)) {
     suggested_page_ordinal = syncer::StringOrdinal(serialized_ordinal);
     needs_sort_ordinal = true;
     pending_install_dict->Remove(kPrefSuggestedPageOrdinal, NULL);
   }
 
   const base::Time install_time = time_provider_->GetCurrentTime();
   pending_install_dict->Set(
       kPrefInstallTime,
       Value::CreateStringValue(
           base::Int64ToString(install_time.ToInternalValue())));
 
   // Commit the delayed install data.
   extension_dict->MergeDictionary(pending_install_dict);
   FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                            suggested_page_ordinal, extension_dict);
   return true;
 }
 
-scoped_ptr<ExtensionInfo> ExtensionPrefs::GetIdleInstallInfo(
+scoped_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
     const std::string& extension_id) const {
   const DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
   if (!extension_prefs)
     return scoped_ptr<ExtensionInfo>();
 
   const DictionaryValue* ext = NULL;
-  if (!extension_prefs->GetDictionary(kIdleInstallInfo, &ext))
+  if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext))
     return scoped_ptr<ExtensionInfo>();
 
   // TODO(mek): share code with GetInstalledExtensionInfo
   FilePath::StringType path;
   int location_value;
   if (!ext->GetInteger(kPrefLocation, &location_value))
     return scoped_ptr<ExtensionInfo>();
 
   if (!ext->GetString(kPrefPath, &path))
     return scoped_ptr<ExtensionInfo>();
@@ skipping 22 matching lines @@
       !ext->GetDictionary(kPrefManifest, &manifest)) {
     LOG(WARNING) << "Missing manifest for extension " << extension_id;
     // Just a warning for now.
   }
 
   return scoped_ptr<ExtensionInfo>(
       new ExtensionInfo(manifest, extension_id, FilePath(path), location));
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo> ExtensionPrefs::
-    GetAllIdleInstallInfo() const {
+    GetAllDelayedInstallInfo() const {
   scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
        extension_id != extensions->end_keys(); ++extension_id) {
     if (!Extension::IdIsValid(*extension_id))
       continue;
 
-    scoped_ptr<ExtensionInfo> info = GetIdleInstallInfo(*extension_id);
+    scoped_ptr<ExtensionInfo> info = GetDelayedInstallInfo(*extension_id);
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info.Pass();
 }
 
 bool ExtensionPrefs::GetWebStoreLogin(std::string* result) {
   if (prefs_->HasPrefPath(kWebStoreLogin)) {
     *result = prefs_->GetString(kWebStoreLogin);
     return true;
   }
   return false;
 }
 
 void ExtensionPrefs::SetWebStoreLogin(const std::string& login) {
   prefs_->SetString(kWebStoreLogin, login);
 }
 
 bool ExtensionPrefs::GetSideloadWipeoutDone() const {
   return prefs_->GetBoolean(kSideloadWipeoutDone);
 }
 
 void ExtensionPrefs::SetSideloadWipeoutDone() {
-  return prefs_->SetBoolean(kSideloadWipeoutDone, true);
+  prefs_->SetBoolean(kSideloadWipeoutDone, true);
 }
 
 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
                       Value::CreateBooleanValue(true));
 }
@@ skipping 358 matching lines @@
 }
 
 void ExtensionPrefs::Init(bool extensions_disabled) {
   MakePathsRelative();
 
   InitPrefStore(extensions_disabled);
 
   content_settings_store_->AddObserver(this);
 }
 
+void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) {
+  prefs_->SetBoolean(prefs::kExtensionStorageGarbageCollect, value);
+}
+
+bool ExtensionPrefs::NeedsStorageGarbageCollection() {
+  return prefs_->GetBoolean(prefs::kExtensionStorageGarbageCollect);
+}
+
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(kExtensionToolbar, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(kExtensionActionBox, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(kExtensionActionBoxBar, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize,
                              -1,  // default value
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate,
                                 PrefService::UNSYNCABLE_PREF);
   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);
   prefs->RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion,
                             "0",  // default value
                             PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterBooleanPref(prefs::kExtensionStorageGarbageCollect,
+                             false,  // default value
+                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kExtensionsLastChromeVersion,
                             std::string(),  // default value
@@ skipping 73 matching lines @@
     DictionaryValue* extension_dict) {
   // Reinitializes various preferences with empty dictionaries.
   extension_dict->Set(kPrefPreferences, new DictionaryValue());
   extension_dict->Set(kPrefIncognitoPreferences, new DictionaryValue());
   extension_dict->Set(kPrefRegularOnlyPreferences, new DictionaryValue());
   extension_dict->Set(kPrefContentSettings, new ListValue());
   extension_dict->Set(kPrefIncognitoContentSettings, new ListValue());
 
   // If this point has been reached, any pending installs should be considered
   // out of date.
-  extension_dict->Remove(kIdleInstallInfo, NULL);
+  extension_dict->Remove(kDelayedInstallInfo, NULL);
 
   // Clear state that may be registered from a previous install.
   extension_dict->Remove(kRegisteredEvents, NULL);
 
   // FYI, all code below here races on sudden shutdown because
   // |extension_dict|, |extension_sorting_|, |extension_pref_value_map_|,
   // and |content_settings_store_| are updated non-transactionally. This is
   // probably not fixable without nested transactional updates to pref
   // dictionaries.
   if (needs_sort_ordinal) {
     extension_sorting_->EnsureValidOrdinals(extension_id,
                                             suggested_page_ordinal);
   }
 
   bool is_enabled = false;
   int initial_state;
   if (extension_dict->GetInteger(kPrefState, &initial_state)) {
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions