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

chrome/browser/extensions/extension_service.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_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 87 matching lines @@
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "extensions/common/error_utils.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
 
@@ skipping 249 matching lines @@
       show_extensions_prompts_(true),
       install_updates_when_idle_(true),
       ready_(false),
       toolbar_model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       menu_manager_(profile),
       app_notification_manager_(
           new extensions::AppNotificationManager(profile)),
       event_routers_initialized_(false),
       update_once_all_providers_are_ready_(false),
       browser_terminating_(false),
+      installs_delayed_(false),
       wipeout_is_active_(false),
       app_sync_bundle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       extension_sync_bundle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       app_shortcut_manager_(profile) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions) ||
       profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
@@ skipping 195 matching lines @@
   int include_mask = INCLUDE_ENABLED;
   if (include_disabled) {
     // Include blacklisted extensions here because there are hundreds of
     // callers of this function, and many might assume that this includes those
     // that have been disabled due to blacklisting.
     include_mask |= INCLUDE_DISABLED | INCLUDE_BLACKLISTED;
   }
   return GetExtensionById(id, include_mask);
 }
 
+GURL ExtensionService::GetSiteForExtensionId(const std::string& extension_id) {
+  return content::SiteInstance::GetSiteForURL(
+      profile_,
+      Extension::GetBaseURLFromExtensionId(extension_id));
+}
+
 const Extension* ExtensionService::GetExtensionById(
     const std::string& id, int include_mask) const {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_mask & INCLUDE_ENABLED) {
     const Extension* extension = extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
   if (include_mask & INCLUDE_DISABLED) {
     const Extension* extension = disabled_extensions_.GetByID(lowercase_id);
@@ skipping 12 matching lines @@
   }
   return NULL;
 }
 
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
-  // TODO(mek): It might be cleaner to do the FinishIdleInstallInfo stuff here
-  // instead of in installedloader
+  // TODO(mek): It might be cleaner to do the FinishDelayedInstallInfo stuff
+  // here instead of in installedloader.
   component_loader_->LoadAll();
   extensions::InstalledLoader(this).LoadAllExtensions();
 
   // The Sideload Wipeout effort takes place during load (see above), so once
   // that is done the flag can be set so that we don't have to check again.
   if (wipeout_is_active_) {
     extension_prefs_->SetSideloadWipeoutDone();
     wipeout_is_active_ = false;  // Wipeout is only on during load.
   }
 
   // If we are running in the import process, don't bother initializing the
   // extension service since this can interfere with the main browser process
   // that is already running an extension service for this profile.
   // TODO(aa): can we start up even less of ExtensionService?
   // http://crbug.com/107636
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kImport) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kImportFromFile)) {
     if (g_browser_process->profile_manager() &&
         g_browser_process->profile_manager()->will_import()) {
       RegisterForImportFinished();
     } else {
       // TODO(erikkay) this should probably be deferred to a future point
       // rather than running immediately at startup.
       CheckForExternalUpdates();
 
       // TODO(erikkay) this should probably be deferred as well.
       GarbageCollectExtensions();
     }
   }
+
+  if (extension_prefs_->NeedsStorageGarbageCollection()) {
+    GarbageCollectIsolatedStorage();
+    extension_prefs_->SetNeedsStorageGarbageCollection(false);
+  }
 }
 
 bool ExtensionService::UpdateExtension(const std::string& id,
                                        const FilePath& extension_path,
                                        const GURL& download_url,
                                        CrxInstaller** out_crx_installer) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (browser_terminating_) {
     LOG(WARNING) << "Skipping UpdateExtension due to browser shutdown";
     // Leak the temp file at extension_path. We don't want to add to the disk
@@ skipping 111 matching lines @@
 
     on_load_events_[extension_id] = events;
 
     path = current_extension->path();
     DisableExtension(extension_id, Extension::DISABLE_RELOAD);
     disabled_extension_paths_[extension_id] = path;
   } else {
     path = unloaded_extension_paths_[extension_id];
   }
 
-  if (pending_extension_updates_.Contains(extension_id)) {
+  if (delayed_updates_for_idle_.Contains(extension_id)) {
     FinishDelayedInstallation(extension_id);
     return;
   }
 
   // If we're reloading a component extension, use the component extension
   // loader's reloader.
   if (component_loader_->Exists(extension_id)) {
     component_loader_->Reload(extension_id);
     return;
   }
@@ skipping 77 matching lines @@
                 &extension_file_util::UninstallExtension,
                 install_directory_,
                 extension_id)))
       NOTREACHED();
   }
 
   GURL launch_web_url_origin(extension->launch_web_url());
   launch_web_url_origin = launch_web_url_origin.GetOrigin();
   bool is_storage_isolated = extension->is_storage_isolated();
 
-  if (extension->is_hosted_app() &&
-      !profile_->GetExtensionSpecialStoragePolicy()->
-          IsStorageProtected(launch_web_url_origin)) {
-    extensions::DataDeleter::StartDeleting(
-        profile_, extension_id, launch_web_url_origin, is_storage_isolated);
+  if (is_storage_isolated) {
+    BrowserContext::AsyncObliterateStoragePartition(
+        profile_,
+        GetSiteForExtensionId(extension_id),
+        base::Bind(&ExtensionService::OnNeedsToGarbageCollectIsolatedStorage,
+                   AsWeakPtr()));
+  } else {
+    if (extension->is_hosted_app() &&
+        !profile_->GetExtensionSpecialStoragePolicy()->
+            IsStorageProtected(launch_web_url_origin)) {
+      extensions::DataDeleter::StartDeleting(
+          profile_, extension_id, launch_web_url_origin);
+    }
+    extensions::DataDeleter::StartDeleting(profile_, extension_id,
+                                           extension->url());
   }
-  extensions::DataDeleter::StartDeleting(
-      profile_, extension_id, extension->url(), is_storage_isolated);
 
   UntrackTerminatedExtension(extension_id);
 
   // Notify interested parties that we've uninstalled this extension.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   if (app_sync_bundle_.HasExtensionId(extension_id) &&
       sync_change.sync_data().GetDataType() == syncer::APPS) {
     app_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   } else if (extension_sync_bundle_.HasExtensionId(extension_id) &&
              sync_change.sync_data().GetDataType() == syncer::EXTENSIONS) {
     extension_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   }
 
-  pending_extension_updates_.Remove(extension_id);
+  delayed_updates_for_idle_.Remove(extension_id);
+  delayed_installs_.Remove(extension_id);
 
   // Track the uninstallation.
   UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionUninstalled", 1, 2);
 
   return true;
 }
 
 bool ExtensionService::IsExtensionEnabled(
     const std::string& extension_id) const {
   if (extensions_.Contains(extension_id) ||
@@ skipping 1144 matching lines @@
   }
 
   scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> info(
       extension_prefs_->GetInstalledExtensionsInfo());
 
   std::multimap<std::string, FilePath> extension_paths;
   for (size_t i = 0; i < info->size(); ++i)
     extension_paths.insert(std::make_pair(info->at(i)->extension_id,
                                           info->at(i)->extension_path));
 
-  info = extension_prefs_->GetAllIdleInstallInfo();
+  info = extension_prefs_->GetAllDelayedInstallInfo();
   for (size_t i = 0; i < info->size(); ++i)
     extension_paths.insert(std::make_pair(info->at(i)->extension_id,
                                           info->at(i)->extension_path));
 
   if (!GetFileTaskRunner()->PostTask(
           FROM_HERE,
           base::Bind(
               &extension_file_util::GarbageCollectExtensions,
               install_directory_,
               extension_paths))) {
@@ skipping 111 matching lines @@
   const std::string old_version_string(
       extension_prefs_->GetVersionString(extension->id()));
   const Version old_version(old_version_string);
 
   if (!old_version.IsValid() || !old_version.Equals(*extension->version())) {
     VLOG(1) << "Component extension " << extension->name() << " ("
         << extension->id() << ") installing/upgrading from '"
         << old_version_string << "' to " << extension->version()->GetString();
 
     AddNewOrUpdatedExtension(extension,
-                             syncer::StringOrdinal(),
-                             Extension::ENABLED_COMPONENT);
+                             Extension::ENABLED_COMPONENT,
+                             syncer::StringOrdinal());
     return;
   }
 
   AddExtension(extension);
 }
 
 void ExtensionService::InitializePermissions(const Extension* extension) {
   // If the extension has used the optional permissions API, it will have a
   // custom set of active permissions defined in the extension prefs. Here,
   // we update the extension's active permissions based on the prefs.
@@ skipping 238 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateType",
                               extension->GetType(), 100);
     UMA_HISTOGRAM_ENUMERATION("Extensions.UpdateSource",
                               extension->location(), Extension::NUM_LOCATIONS);
   }
 
   // Certain extension locations are specific enough that we can
   // auto-acknowledge any extension that came from one of them.
   if (extension->location() == Extension::EXTERNAL_POLICY_DOWNLOAD)
     AcknowledgeExternalExtension(extension->id());
-
+  const Extension::State initial_state =
+      initial_enable ? Extension::ENABLED : Extension::DISABLED;
   if (ShouldDelayExtensionUpdate(id, wait_for_idle)) {
-    extension_prefs_->SetIdleInstallInfo(
-        extension,
-        initial_enable ? Extension::ENABLED : Extension::DISABLED,
-        page_ordinal);
+    extension_prefs_->SetDelayedInstallInfo(extension, initial_state,
+                                            page_ordinal);
 
     // Transfer ownership of |extension|.
-    pending_extension_updates_.Insert(extension);
+    delayed_updates_for_idle_.Insert(extension);
 
     // Notify extension of available update.
     extensions::RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
         profile_, id, extension->manifest()->value());
     return;
   }
 
-  // Transfer ownership of |extension|.
-  AddNewOrUpdatedExtension(
-      extension,
-      page_ordinal,
-      initial_enable ? Extension::ENABLED : Extension::DISABLED);
+  if (installs_delayed()) {
+    extension_prefs_->SetDelayedInstallInfo(extension, initial_state,
+                                            page_ordinal);
+    delayed_installs_.Insert(extension);
+  } else {
+    AddNewOrUpdatedExtension(extension, initial_state, page_ordinal);
+  }
 }
 
 void ExtensionService::AddNewOrUpdatedExtension(
     const Extension* extension,
-    const syncer::StringOrdinal& page_ordinal,
-    Extension::State initial_state) {
+    Extension::State initial_state,
+    const syncer::StringOrdinal& page_ordinal) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   extension_prefs_->OnExtensionInstalled(
       extension,
       initial_state,
       page_ordinal);
 
-  // Unpacked extensions default to allowing file access, but if that has been
-  // overridden, don't reset the value.
-  if (Extension::ShouldAlwaysAllowFileAccess(extension->location()) &&
-      !extension_prefs_->HasAllowFileAccessSetting(extension->id())) {
-    extension_prefs_->SetAllowFileAccess(extension->id(), true);
-  }
-
   FinishInstallation(extension);
 }
 
 void ExtensionService::MaybeFinishDelayedInstallation(
     const std::string& extension_id) {
   // Check if the extension already got updated.
-  if (!pending_extension_updates_.Contains(extension_id))
+  if (!delayed_updates_for_idle_.Contains(extension_id))
     return;
   // Check if the extension is idle.
   if (!IsExtensionIdle(extension_id))
     return;
 
   FinishDelayedInstallation(extension_id);
 }
 
 void ExtensionService::FinishDelayedInstallation(
     const std::string& extension_id) {
   scoped_refptr<const Extension> extension(
       GetPendingExtensionUpdate(extension_id));
   CHECK(extension);
-  pending_extension_updates_.Remove(extension_id);
+  delayed_updates_for_idle_.Remove(extension_id);
 
-  if (!extension_prefs_->FinishIdleInstallInfo(extension_id))
+  if (!extension_prefs_->FinishDelayedInstallInfo(extension_id))
     NOTREACHED();
 
   FinishInstallation(extension);
 }
 
 void ExtensionService::FinishInstallation(const Extension* extension) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   bool unacknowledged_external = IsUnacknowledgedExternalExtension(extension);
 
+  // Unpacked extensions default to allowing file access, but if that has been
+  // overridden, don't reset the value.
+  if (Extension::ShouldAlwaysAllowFileAccess(extension->location()) &&
+      !extension_prefs_->HasAllowFileAccessSetting(extension->id())) {
+    extension_prefs_->SetAllowFileAccess(extension->id(), true);
+  }
+
   AddExtension(extension);
 
 #if defined(ENABLE_THEMES)
   // We do this here since AddExtension() is always called on browser
   // startup, and we only really care about the last theme installed.
   // If that ever changes and we have to move this code somewhere
   // else, it should be somewhere that's not in the startup path.
   if (extension->is_theme() && extensions_.GetByID(extension->id())) {
     DCHECK_EQ(extensions_.GetByID(extension->id()), extension);
     // Now that the theme extension is visible from outside the
     // ExtensionService, notify the ThemeService about the
     // newly-installed theme.
     ThemeServiceFactory::GetForProfile(profile_)->SetTheme(extension);
   }
 #endif
 
   // If this is a new external extension that was disabled, alert the user
   // so he can reenable it. We do this last so that it has already been
   // added to our list of extensions.
   if (unacknowledged_external) {
     UpdateExternalExtensionAlert();
     UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalExtensionEvent",
                               EXTERNAL_EXTENSION_INSTALLED,
                               EXTERNAL_EXTENSION_BUCKET_BOUNDARY);
   }
 }
 
 const Extension* ExtensionService::GetPendingExtensionUpdate(
     const std::string& id) const {
-  return pending_extension_updates_.GetByID(id);
+  return delayed_updates_for_idle_.GetByID(id);
 }
 
 void ExtensionService::TrackTerminatedExtension(const Extension* extension) {
   if (!terminated_extensions_.Contains(extension->id()))
     terminated_extensions_.Insert(make_scoped_refptr(extension));
 
   UnloadExtension(extension->id(), extension_misc::UNLOAD_REASON_TERMINATE);
 }
 
 void ExtensionService::UntrackTerminatedExtension(const std::string& id) {
@@ skipping 225 matching lines @@
       break;
     }
     case chrome::NOTIFICATION_IMPORT_FINISHED: {
       InitAfterImport();
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       extensions::ExtensionHost* host =
           content::Details<extensions::ExtensionHost>(details).ptr();
       std::string extension_id = host->extension_id();
-      if (pending_extension_updates_.Contains(extension_id)) {
+      if (delayed_updates_for_idle_.Contains(extension_id)) {
         // We were waiting for this extension to become idle, it now might have,
         // so maybe finish installation.
         MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&ExtensionService::MaybeFinishDelayedInstallation,
                        AsWeakPtr(), extension_id),
             base::TimeDelta::FromSeconds(kUpdateIdleDelay));
       }
       break;
     }
@@ skipping 267 matching lines @@
     // Delay installation if the extension listens for the onUpdateAvailable
     // event.
     return system_->event_router()->ExtensionHasEventListener(
         extension_id, kOnUpdateAvailableEvent);
   } else {
     // Delay installation if the extension is not idle.
     return !IsExtensionIdle(extension_id);
   }
 }
 
+void ExtensionService::GarbageCollectIsolatedStorage() {
+  scoped_ptr<base::hash_set<FilePath> > active_paths(
+      new base::hash_set<FilePath>());
+  for (ExtensionSet::const_iterator it = extensions_.begin();
+       it != extensions_.end(); ++it) {
+    if ((*it)->is_storage_isolated()) {
+      active_paths->insert(
+          BrowserContext::GetStoragePartitionForSite(
+              profile_,
+              GetSiteForExtensionId((*it)->id()))->GetPath());
+    }
+  }
+
+  DCHECK(!installs_delayed());
+  set_installs_delayed(true);
+  BrowserContext::GarbageCollectStoragePartitions(
+      profile_, active_paths.Pass(),
+      base::Bind(&ExtensionService::OnGarbageCollectIsolatedStorageFinished,
+                 AsWeakPtr()));
+}
+
+void ExtensionService::OnGarbageCollectIsolatedStorageFinished() {
+  set_installs_delayed(false);
+  for (ExtensionSet::const_iterator it = delayed_installs_.begin();
+       it != delayed_installs_.end();
+       ++it) {
+    FinishDelayedInstallation((*it)->id());
+  }
+  for (ExtensionSet::const_iterator it = delayed_updates_for_idle_.begin();
+       it != delayed_updates_for_idle_.end();
+       ++it) {
+    MaybeFinishDelayedInstallation((*it)->id());
+  }
+  delayed_installs_.Clear();
+}
+
+void ExtensionService::OnNeedsToGarbageCollectIsolatedStorage() {
+  extension_prefs_->SetNeedsStorageGarbageCollection(true);
+}
+
 void ExtensionService::OnBlacklistUpdated() {
   blacklist_->GetBlacklistedIDs(
       GenerateInstalledExtensionsSet()->GetIDs(),
       base::Bind(&ExtensionService::ManageBlacklist,
                  AsWeakPtr(),
                  blacklisted_extensions_.GetIDs()));
 }
 
 void ExtensionService::ManageBlacklist(
     const std::set<std::string>& old_blacklisted_ids,
@@ skipping 27 matching lines @@
     scoped_refptr<const Extension> extension = GetInstalledExtension(*it);
     DCHECK(extension);
     if (!extension)
       continue;
     blacklisted_extensions_.Insert(extension);
     UnloadExtension(*it, extension_misc::UNLOAD_REASON_BLACKLIST);
   }
 
   IdentifyAlertableExtensions();
 }