chrome/browser/extensions/extension_garbage_collector.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/extension_garbage_collector.h"
   6
   7 #include "base/bind.h"
   8 #include "base/files/file_enumerator.h"
   9 #include "base/files/file_util.h"
  10 #include "base/location.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/sequenced_task_runner.h"
  14 #include "base/single_thread_task_runner.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/thread_task_runner_handle.h"
  18 #include "base/time/time.h"
  19 #include "chrome/browser/extensions/extension_garbage_collector_factory.h"
  20 #include "chrome/browser/extensions/extension_service.h"
  21 #include "chrome/browser/extensions/extension_util.h"
  22 #include "chrome/browser/extensions/install_tracker.h"
  23 #include "chrome/browser/extensions/pending_extension_manager.h"
  24 #include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
  25 #include "components/crx_file/id_util.h"
  26 #include "content/public/browser/browser_context.h"
  27 #include "content/public/browser/browser_thread.h"
  28 #include "content/public/browser/storage_partition.h"
  29 #include "extensions/browser/extension_prefs.h"
  30 #include "extensions/browser/extension_registry.h"
  31 #include "extensions/browser/extension_system.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/file_util.h"
  34 #include "extensions/common/one_shot_event.h"
  35
  36 namespace extensions {
  37
  38 namespace {
  39
  40 // Wait this many seconds before trying to garbage collect extensions again.
  41 const int kGarbageCollectRetryDelayInSeconds = 30;
  42
  43 // Wait this many seconds after startup to see if there are any extensions
  44 // which can be garbage collected.
  45 const int kGarbageCollectStartupDelay = 30;
  46
  47 typedef std::multimap<std::string, base::FilePath> ExtensionPathsMultimap;
  48
  49 void CheckExtensionDirectory(const base::FilePath& path,
  50                              const ExtensionPathsMultimap& extension_paths) {
  51   base::FilePath basename = path.BaseName();
  52   // Clean up temporary files left if Chrome crashed or quit in the middle
  53   // of an extension install.
  54   if (basename.value() == file_util::kTempDirectoryName) {
  55     base::DeleteFile(path, true);  // Recursive.
  56     return;
  57   }
  58
  59   // Parse directory name as a potential extension ID.
  60   std::string extension_id;
  61   if (base::IsStringASCII(basename.value())) {
  62     extension_id = base::UTF16ToASCII(basename.LossyDisplayName());
  63     if (!crx_file::id_util::IdIsValid(extension_id))
  64       extension_id.clear();
  65   }
  66
  67   // Delete directories that aren't valid IDs.
  68   if (extension_id.empty()) {
  69     base::DeleteFile(path, true);  // Recursive.
  70     return;
  71   }
  72
  73   typedef ExtensionPathsMultimap::const_iterator Iter;
  74   std::pair<Iter, Iter> iter_pair = extension_paths.equal_range(extension_id);
  75
  76   // If there is no entry in the prefs file, just delete the directory and
  77   // move on. This can legitimately happen when an uninstall does not
  78   // complete, for example, when a plugin is in use at uninstall time.
  79   if (iter_pair.first == iter_pair.second) {
  80     base::DeleteFile(path, true);  // Recursive.
  81     return;
  82   }
  83
  84   // Clean up old version directories.
  85   base::FileEnumerator versions_enumerator(
  86       path, false /* Not recursive */, base::FileEnumerator::DIRECTORIES);
  87   for (base::FilePath version_dir = versions_enumerator.Next();
  88        !version_dir.empty();
  89        version_dir = versions_enumerator.Next()) {
  90     bool known_version = false;
  91     for (Iter iter = iter_pair.first; iter != iter_pair.second; ++iter) {
  92       if (version_dir.BaseName() == iter->second.BaseName()) {
  93         known_version = true;
  94         break;
  95       }
  96     }
  97     if (!known_version)
  98       base::DeleteFile(version_dir, true);  // Recursive.
  99   }
 100 }
 101
 102 }  // namespace
 103
 104 ExtensionGarbageCollector::ExtensionGarbageCollector(
 105     content::BrowserContext* context)
 106     : context_(context), crx_installs_in_progress_(0), weak_factory_(this) {
 107
 108   ExtensionSystem* extension_system = ExtensionSystem::Get(context_);
 109   DCHECK(extension_system);
 110
 111   extension_system->ready().PostDelayed(
 112       FROM_HERE,
 113       base::Bind(&ExtensionGarbageCollector::GarbageCollectExtensions,
 114                  weak_factory_.GetWeakPtr()),
 115       base::TimeDelta::FromSeconds(kGarbageCollectStartupDelay));
 116
 117   extension_system->ready().Post(
 118       FROM_HERE,
 119       base::Bind(
 120           &ExtensionGarbageCollector::GarbageCollectIsolatedStorageIfNeeded,
 121           weak_factory_.GetWeakPtr()));
 122
 123   InstallTracker::Get(context_)->AddObserver(this);
 124 }
 125
 126 ExtensionGarbageCollector::~ExtensionGarbageCollector() {}
 127
 128 // static
 129 ExtensionGarbageCollector* ExtensionGarbageCollector::Get(
 130     content::BrowserContext* context) {
 131   return ExtensionGarbageCollectorFactory::GetForBrowserContext(context);
 132 }
 133
 134 void ExtensionGarbageCollector::Shutdown() {
 135   InstallTracker::Get(context_)->RemoveObserver(this);
 136 }
 137
 138 void ExtensionGarbageCollector::GarbageCollectExtensionsForTest() {
 139   GarbageCollectExtensions();
 140 }
 141
 142 // static
 143 void ExtensionGarbageCollector::GarbageCollectExtensionsOnFileThread(
 144     const base::FilePath& install_directory,
 145     const ExtensionPathsMultimap& extension_paths) {
 146   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 147
 148   // Nothing to clean up if it doesn't exist.
 149   if (!base::DirectoryExists(install_directory))
 150     return;
 151
 152   base::FileEnumerator enumerator(install_directory,
 153                                   false,  // Not recursive.
 154                                   base::FileEnumerator::DIRECTORIES);
 155
 156   for (base::FilePath extension_path = enumerator.Next();
 157        !extension_path.empty();
 158        extension_path = enumerator.Next()) {
 159     CheckExtensionDirectory(extension_path, extension_paths);
 160   }
 161 }
 162
 163 void ExtensionGarbageCollector::GarbageCollectExtensions() {
 164   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 165
 166   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(context_);
 167   DCHECK(extension_prefs);
 168
 169   if (extension_prefs->pref_service()->ReadOnly())
 170     return;
 171
 172   if (crx_installs_in_progress_ > 0) {
 173     // Don't garbage collect while there are installations in progress,
 174     // which may be using the temporary installation directory. Try to garbage
 175     // collect again later.
 176     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 177         FROM_HERE,
 178         base::Bind(&ExtensionGarbageCollector::GarbageCollectExtensions,
 179                    weak_factory_.GetWeakPtr()),
 180         base::TimeDelta::FromSeconds(kGarbageCollectRetryDelayInSeconds));
 181     return;
 182   }
 183
 184   scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
 185       extension_prefs->GetInstalledExtensionsInfo());
 186   std::multimap<std::string, base::FilePath> extension_paths;
 187   for (size_t i = 0; i < info->size(); ++i) {
 188     extension_paths.insert(
 189         std::make_pair(info->at(i)->extension_id, info->at(i)->extension_path));
 190   }
 191
 192   info = extension_prefs->GetAllDelayedInstallInfo();
 193   for (size_t i = 0; i < info->size(); ++i) {
 194     extension_paths.insert(
 195         std::make_pair(info->at(i)->extension_id, info->at(i)->extension_path));
 196   }
 197
 198   ExtensionService* service =
 199       ExtensionSystem::Get(context_)->extension_service();
 200   if (!service->GetFileTaskRunner()->PostTask(
 201           FROM_HERE,
 202           base::Bind(&GarbageCollectExtensionsOnFileThread,
 203                      service->install_directory(),
 204                      extension_paths))) {
 205     NOTREACHED();
 206   }
 207 }
 208
 209 void ExtensionGarbageCollector::GarbageCollectIsolatedStorageIfNeeded() {
 210   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 211
 212   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(context_);
 213   DCHECK(extension_prefs);
 214   if (!extension_prefs->NeedsStorageGarbageCollection())
 215     return;
 216   extension_prefs->SetNeedsStorageGarbageCollection(false);
 217
 218   scoped_ptr<base::hash_set<base::FilePath> > active_paths(
 219       new base::hash_set<base::FilePath>());
 220   scoped_ptr<ExtensionSet> extensions =
 221       ExtensionRegistry::Get(context_)->GenerateInstalledExtensionsSet();
 222   for (ExtensionSet::const_iterator iter = extensions->begin();
 223        iter != extensions->end();
 224        ++iter) {
 225     if (AppIsolationInfo::HasIsolatedStorage(iter->get())) {
 226       active_paths->insert(
 227           content::BrowserContext::GetStoragePartitionForSite(
 228               context_, util::GetSiteForExtensionId((*iter)->id(), context_))
 229               ->GetPath());
 230     }
 231   }
 232
 233   ExtensionService* service =
 234       ExtensionSystem::Get(context_)->extension_service();
 235   service->OnGarbageCollectIsolatedStorageStart();
 236   content::BrowserContext::GarbageCollectStoragePartitions(
 237       context_,
 238       active_paths.Pass(),
 239       base::Bind(&ExtensionService::OnGarbageCollectIsolatedStorageFinished,
 240                  service->AsWeakPtr()));
 241 }
 242
 243 void ExtensionGarbageCollector::OnBeginCrxInstall(
 244     const std::string& extension_id) {
 245   crx_installs_in_progress_++;
 246 }
 247
 248 void ExtensionGarbageCollector::OnFinishCrxInstall(
 249     const std::string& extension_id,
 250     bool success) {
 251   crx_installs_in_progress_--;
 252   if (crx_installs_in_progress_ < 0) {
 253     // This can only happen if there is a mismatch in our begin/finish
 254     // accounting.
 255     NOTREACHED();
 256
 257     // Don't let the count go negative to avoid garbage collecting when
 258     // an install is actually in progress.
 259     crx_installs_in_progress_ = 0;
 260   }
 261 }
 262
 263 }  // namespace extensions