chrome/browser/extensions/extension_storage_monitor.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_storage_monitor.h"
   6
   7 #include <map>
   8
   9 #include "base/metrics/histogram.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/extensions/extension_service.h"
  15 #include "chrome/browser/extensions/extension_storage_monitor_factory.h"
  16 #include "chrome/browser/extensions/extension_util.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  19 #include "chrome/grit/generated_resources.h"
  20 #include "content/public/browser/browser_context.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "content/public/browser/notification_details.h"
  23 #include "content/public/browser/notification_source.h"
  24 #include "content/public/browser/storage_partition.h"
  25 #include "extensions/browser/extension_prefs.h"
  26 #include "extensions/browser/extension_registry.h"
  27 #include "extensions/browser/extension_system.h"
  28 #include "extensions/browser/image_loader.h"
  29 #include "extensions/browser/uninstall_reason.h"
  30 #include "extensions/common/extension.h"
  31 #include "extensions/common/manifest_handlers/icons_handler.h"
  32 #include "extensions/common/permissions/permissions_data.h"
  33 #include "storage/browser/quota/quota_manager.h"
  34 #include "storage/browser/quota/storage_observer.h"
  35 #include "ui/base/l10n/l10n_util.h"
  36 #include "ui/message_center/message_center.h"
  37 #include "ui/message_center/notifier_settings.h"
  38 #include "ui/message_center/views/constants.h"
  39
  40 using content::BrowserThread;
  41
  42 namespace extensions {
  43
  44 namespace {
  45
  46 // The rate at which we would like to observe storage events.
  47 const int kStorageEventRateSec = 30;
  48
  49 // Set the thresholds for the first notification. Ephemeral apps have a lower
  50 // threshold than installed extensions and apps. Once a threshold is exceeded,
  51 // it will be doubled to throttle notifications.
  52 const int64 kMBytes = 1024 * 1024;
  53 const int64 kEphemeralAppInitialThreshold = 250 * kMBytes;
  54 const int64 kExtensionInitialThreshold = 1000 * kMBytes;
  55
  56 // Notifications have an ID so that we can update them.
  57 const char kNotificationIdFormat[] = "ExtensionStorageMonitor-$1-$2";
  58 const char kSystemNotifierId[] = "ExtensionStorageMonitor";
  59
  60 // A preference that stores the next threshold for displaying a notification
  61 // when an extension or app consumes excessive disk space. This will not be
  62 // set until the extension/app reaches the initial threshold.
  63 const char kPrefNextStorageThreshold[] = "next_storage_threshold";
  64
  65 // If this preference is set to true, notifications will be suppressed when an
  66 // extension or app consumes excessive disk space.
  67 const char kPrefDisableStorageNotifications[] = "disable_storage_notifications";
  68
  69 bool ShouldMonitorStorageFor(const Extension* extension) {
  70   // Only monitor storage for extensions that are granted unlimited storage.
  71   // Do not monitor storage for component extensions.
  72   return extension->permissions_data()->HasAPIPermission(
  73              APIPermission::kUnlimitedStorage) &&
  74          extension->location() != Manifest::COMPONENT;
  75 }
  76
  77 bool ShouldGatherMetricsFor(const Extension* extension) {
  78   // We want to know the usage of hosted apps' storage.
  79   return ShouldMonitorStorageFor(extension) && extension->is_hosted_app();
  80 }
  81
  82 const Extension* GetExtensionById(content::BrowserContext* context,
  83                                   const std::string& extension_id) {
  84   return ExtensionRegistry::Get(context)->GetExtensionById(
  85       extension_id, ExtensionRegistry::EVERYTHING);
  86 }
  87
  88 void LogTemporaryStorageUsage(int64 usage,
  89                               storage::QuotaStatusCode status,
  90                               int64 global_quota) {
  91   if (status == storage::kQuotaStatusOk) {
  92     int64 per_app_quota =
  93         global_quota / storage::QuotaManager::kPerHostTemporaryPortion;
  94     // Note we use COUNTS_100 (instead of PERCENT) because this can potentially
  95     // exceed 100%.
  96     UMA_HISTOGRAM_COUNTS_100(
  97         "Extensions.HostedAppUnlimitedStorageTemporaryStorageUsage",
  98         100.0 * usage / per_app_quota);
  99   }
 100 }
 101
 102 }  // namespace
 103
 104 // StorageEventObserver monitors the storage usage of extensions and lives on
 105 // the IO thread. When a threshold is exceeded, a message will be posted to the
 106 // UI thread, which displays the notification.
 107 class StorageEventObserver
 108     : public base::RefCountedThreadSafe<StorageEventObserver,
 109                                         BrowserThread::DeleteOnIOThread>,
 110       public storage::StorageObserver {
 111  public:
 112   explicit StorageEventObserver(
 113       base::WeakPtr<ExtensionStorageMonitor> storage_monitor)
 114       : storage_monitor_(storage_monitor) {
 115   }
 116
 117   // Register as an observer for the extension's storage events.
 118   void StartObservingForExtension(
 119       scoped_refptr<storage::QuotaManager> quota_manager,
 120       const std::string& extension_id,
 121       const GURL& site_url,
 122       int64 next_threshold,
 123       const base::TimeDelta& rate,
 124       bool should_uma) {
 125     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 126     DCHECK(quota_manager.get());
 127
 128     GURL origin = site_url.GetOrigin();
 129     StorageState& state = origin_state_map_[origin];
 130     state.quota_manager = quota_manager;
 131     state.extension_id = extension_id;
 132     state.next_threshold = next_threshold;
 133     state.should_uma = should_uma;
 134
 135     // We always observe persistent storage usage.
 136     storage::StorageObserver::MonitorParams params(
 137         storage::kStorageTypePersistent, origin, rate, false);
 138     quota_manager->AddStorageObserver(this, params);
 139     if (should_uma) {
 140       // And if this is for uma, we also observe temporary storage usage.
 141       MonitorParams temporary_params(
 142           storage::kStorageTypeTemporary, origin, rate, false);
 143       quota_manager->AddStorageObserver(this, temporary_params);
 144     }
 145   }
 146
 147   // Updates the threshold for an extension already being monitored.
 148   void UpdateThresholdForExtension(const std::string& extension_id,
 149                                    int64 next_threshold) {
 150     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 151
 152     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
 153          it != origin_state_map_.end();
 154          ++it) {
 155       if (it->second.extension_id == extension_id) {
 156         it->second.next_threshold = next_threshold;
 157         break;
 158       }
 159     }
 160   }
 161
 162   // Deregister as an observer for the extension's storage events.
 163   void StopObservingForExtension(const std::string& extension_id) {
 164     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 165
 166     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
 167          it != origin_state_map_.end(); ) {
 168       if (it->second.extension_id == extension_id) {
 169         storage::StorageObserver::Filter filter(
 170             storage::kStorageTypePersistent, it->first);
 171         it->second.quota_manager->RemoveStorageObserverForFilter(this, filter);
 172         // We also need to unregister temporary storage observation, if this was
 173         // being tracked for uma.
 174         if (it->second.should_uma) {
 175           storage::StorageObserver::Filter temporary_filter(
 176               storage::kStorageTypeTemporary, it->first);
 177           it->second.quota_manager->RemoveStorageObserverForFilter(this,
 178                                                                    filter);
 179         }
 180         origin_state_map_.erase(it++);
 181       } else {
 182         ++it;
 183       }
 184     }
 185   }
 186
 187   // Stop observing all storage events. Called during shutdown.
 188   void StopObserving() {
 189     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 190
 191     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
 192          it != origin_state_map_.end(); ++it) {
 193       it->second.quota_manager->RemoveStorageObserver(this);
 194     }
 195     origin_state_map_.clear();
 196   }
 197
 198  private:
 199   friend class base::DeleteHelper<StorageEventObserver>;
 200   friend struct content::BrowserThread::DeleteOnThread<
 201       content::BrowserThread::IO>;
 202
 203   struct StorageState {
 204     scoped_refptr<storage::QuotaManager> quota_manager;
 205
 206     std::string extension_id;
 207
 208     // If |next_threshold| is -1, it signifies that we should not enforce (and
 209     // only track) storage for this extension.
 210     int64 next_threshold;
 211
 212     bool should_uma;
 213
 214     StorageState() : next_threshold(-1), should_uma(false) {}
 215   };
 216   typedef std::map<GURL, StorageState> OriginStorageStateMap;
 217
 218   ~StorageEventObserver() override {
 219     DCHECK(origin_state_map_.empty());
 220     StopObserving();
 221   }
 222
 223   // storage::StorageObserver implementation.
 224   void OnStorageEvent(const Event& event) override {
 225     OriginStorageStateMap::iterator iter =
 226         origin_state_map_.find(event.filter.origin);
 227     if (iter == origin_state_map_.end())
 228       return;
 229     StorageState& state = iter->second;
 230
 231     if (state.should_uma) {
 232       if (event.filter.storage_type == storage::kStorageTypePersistent) {
 233         UMA_HISTOGRAM_MEMORY_KB(
 234             "Extensions.HostedAppUnlimitedStoragePersistentStorageUsage",
 235             event.usage);
 236       } else {
 237         // We can't use the quota in the event because it assumes unlimited
 238         // storage.
 239         BrowserThread::PostTask(
 240             BrowserThread::IO,
 241             FROM_HERE,
 242             base::Bind(&storage::QuotaManager::GetTemporaryGlobalQuota,
 243                        state.quota_manager,
 244                        base::Bind(&LogTemporaryStorageUsage, event.usage)));
 245       }
 246     }
 247
 248     if (state.next_threshold != -1 &&
 249         event.usage >= state.next_threshold) {
 250       while (event.usage >= state.next_threshold)
 251         state.next_threshold *= 2;
 252
 253       BrowserThread::PostTask(
 254           BrowserThread::UI,
 255           FROM_HERE,
 256           base::Bind(&ExtensionStorageMonitor::OnStorageThresholdExceeded,
 257                      storage_monitor_,
 258                      state.extension_id,
 259                      state.next_threshold,
 260                      event.usage));
 261     }
 262   }
 263
 264   OriginStorageStateMap origin_state_map_;
 265   base::WeakPtr<ExtensionStorageMonitor> storage_monitor_;
 266 };
 267
 268 // ExtensionStorageMonitor
 269
 270 // static
 271 ExtensionStorageMonitor* ExtensionStorageMonitor::Get(
 272     content::BrowserContext* context) {
 273   return ExtensionStorageMonitorFactory::GetForBrowserContext(context);
 274 }
 275
 276 ExtensionStorageMonitor::ExtensionStorageMonitor(
 277     content::BrowserContext* context)
 278     : enable_for_all_extensions_(false),
 279       initial_extension_threshold_(kExtensionInitialThreshold),
 280       initial_ephemeral_threshold_(kEphemeralAppInitialThreshold),
 281       observer_rate_(base::TimeDelta::FromSeconds(kStorageEventRateSec)),
 282       context_(context),
 283       extension_prefs_(ExtensionPrefs::Get(context)),
 284       extension_registry_observer_(this),
 285       weak_ptr_factory_(this) {
 286   DCHECK(extension_prefs_);
 287
 288   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
 289                  content::Source<content::BrowserContext>(context_));
 290
 291   extension_registry_observer_.Add(ExtensionRegistry::Get(context_));
 292 }
 293
 294 ExtensionStorageMonitor::~ExtensionStorageMonitor() {}
 295
 296 void ExtensionStorageMonitor::Observe(
 297     int type,
 298     const content::NotificationSource& source,
 299     const content::NotificationDetails& details) {
 300   switch (type) {
 301     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
 302       StopMonitoringAll();
 303       break;
 304     }
 305     default:
 306       NOTREACHED();
 307   }
 308 }
 309
 310 void ExtensionStorageMonitor::OnExtensionLoaded(
 311     content::BrowserContext* browser_context,
 312     const Extension* extension) {
 313   StartMonitoringStorage(extension);
 314 }
 315
 316 void ExtensionStorageMonitor::OnExtensionUnloaded(
 317     content::BrowserContext* browser_context,
 318     const Extension* extension,
 319     UnloadedExtensionInfo::Reason reason) {
 320   StopMonitoringStorage(extension->id());
 321 }
 322
 323 void ExtensionStorageMonitor::OnExtensionWillBeInstalled(
 324     content::BrowserContext* browser_context,
 325     const Extension* extension,
 326     bool is_update,
 327     bool from_ephemeral,
 328     const std::string& old_name) {
 329   // If an ephemeral app was promoted to a regular installed app, we may need to
 330   // increase its next threshold.
 331   if (!from_ephemeral || !ShouldMonitorStorageFor(extension))
 332     return;
 333
 334   if (!enable_for_all_extensions_) {
 335     // If monitoring is not enabled for installed extensions, just stop
 336     // monitoring.
 337     SetNextStorageThreshold(extension->id(), 0);
 338     StopMonitoringStorage(extension->id());
 339     return;
 340   }
 341
 342   int64 next_threshold = GetNextStorageThresholdFromPrefs(extension->id());
 343   if (next_threshold <= initial_extension_threshold_) {
 344     // Clear the next threshold in the prefs. This effectively raises it to
 345     // |initial_extension_threshold_|. If the current threshold is already
 346     // higher than this, leave it as is.
 347     SetNextStorageThreshold(extension->id(), 0);
 348
 349     if (storage_observer_.get()) {
 350       BrowserThread::PostTask(
 351           BrowserThread::IO,
 352           FROM_HERE,
 353           base::Bind(&StorageEventObserver::UpdateThresholdForExtension,
 354                      storage_observer_,
 355                      extension->id(),
 356                      initial_extension_threshold_));
 357     }
 358   }
 359 }
 360
 361 void ExtensionStorageMonitor::OnExtensionUninstalled(
 362     content::BrowserContext* browser_context,
 363     const Extension* extension,
 364     extensions::UninstallReason reason) {
 365   RemoveNotificationForExtension(extension->id());
 366 }
 367
 368 void ExtensionStorageMonitor::OnExtensionUninstallDialogClosed(
 369     bool did_start_uninstall,
 370     const base::string16& error) {
 371   // We may get a lagging OnExtensionUninstalledDialogClosed() call during
 372   // testing, but did_start_uninstall should be false in this case.
 373   DCHECK(!uninstall_extension_id_.empty() || !did_start_uninstall);
 374   uninstall_extension_id_.clear();
 375 }
 376
 377 std::string ExtensionStorageMonitor::GetNotificationId(
 378     const std::string& extension_id) {
 379   std::vector<std::string> placeholders;
 380   placeholders.push_back(context_->GetPath().BaseName().MaybeAsASCII());
 381   placeholders.push_back(extension_id);
 382
 383   return base::ReplaceStringPlaceholders(
 384       kNotificationIdFormat, placeholders, NULL);
 385 }
 386
 387 void ExtensionStorageMonitor::OnStorageThresholdExceeded(
 388     const std::string& extension_id,
 389     int64 next_threshold,
 390     int64 current_usage) {
 391   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 392
 393   const Extension* extension = GetExtensionById(context_, extension_id);
 394   if (!extension)
 395     return;
 396
 397   if (GetNextStorageThreshold(extension->id()) < next_threshold)
 398     SetNextStorageThreshold(extension->id(), next_threshold);
 399
 400   const int kIconSize = message_center::kNotificationIconSize;
 401   ExtensionResource resource =  IconsInfo::GetIconResource(
 402       extension, kIconSize, ExtensionIconSet::MATCH_BIGGER);
 403   ImageLoader::Get(context_)->LoadImageAsync(
 404       extension, resource, gfx::Size(kIconSize, kIconSize),
 405       base::Bind(&ExtensionStorageMonitor::OnImageLoaded,
 406                  weak_ptr_factory_.GetWeakPtr(),
 407                  extension_id,
 408                  current_usage));
 409 }
 410
 411 void ExtensionStorageMonitor::OnImageLoaded(
 412     const std::string& extension_id,
 413     int64 current_usage,
 414     const gfx::Image& image) {
 415   const Extension* extension = GetExtensionById(context_, extension_id);
 416   if (!extension)
 417     return;
 418
 419   // Remove any existing notifications to force a new notification to pop up.
 420   std::string notification_id(GetNotificationId(extension_id));
 421   message_center::MessageCenter::Get()->RemoveNotification(
 422       notification_id, false);
 423
 424   message_center::RichNotificationData notification_data;
 425   notification_data.buttons.push_back(message_center::ButtonInfo(
 426       l10n_util::GetStringUTF16(extension->is_app() ?
 427           IDS_EXTENSION_STORAGE_MONITOR_BUTTON_DISMISS_APP :
 428           IDS_EXTENSION_STORAGE_MONITOR_BUTTON_DISMISS_EXTENSION)));
 429   notification_data.buttons.push_back(message_center::ButtonInfo(
 430       l10n_util::GetStringUTF16(extension->is_app() ?
 431           IDS_EXTENSION_STORAGE_MONITOR_BUTTON_UNINSTALL_APP :
 432           IDS_EXTENSION_STORAGE_MONITOR_BUTTON_UNINSTALL_EXTENSION)));
 433
 434   gfx::Image notification_image(image);
 435   if (notification_image.IsEmpty()) {
 436     notification_image =
 437         extension->is_app() ? gfx::Image(util::GetDefaultAppIcon())
 438                             : gfx::Image(util::GetDefaultExtensionIcon());
 439   }
 440
 441   scoped_ptr<message_center::Notification> notification;
 442   notification.reset(new message_center::Notification(
 443       message_center::NOTIFICATION_TYPE_SIMPLE,
 444       notification_id,
 445       l10n_util::GetStringUTF16(IDS_EXTENSION_STORAGE_MONITOR_TITLE),
 446       l10n_util::GetStringFUTF16(
 447           IDS_EXTENSION_STORAGE_MONITOR_TEXT,
 448           base::UTF8ToUTF16(extension->name()),
 449           base::IntToString16(current_usage / kMBytes)),
 450       notification_image,
 451       base::string16() /* display source */,
 452       message_center::NotifierId(
 453           message_center::NotifierId::SYSTEM_COMPONENT, kSystemNotifierId),
 454       notification_data,
 455       new message_center::HandleNotificationButtonClickDelegate(base::Bind(
 456           &ExtensionStorageMonitor::OnNotificationButtonClick,
 457           weak_ptr_factory_.GetWeakPtr(),
 458           extension_id))));
 459   notification->SetSystemPriority();
 460   message_center::MessageCenter::Get()->AddNotification(notification.Pass());
 461
 462   notified_extension_ids_.insert(extension_id);
 463 }
 464
 465 void ExtensionStorageMonitor::OnNotificationButtonClick(
 466     const std::string& extension_id, int button_index) {
 467   switch (button_index) {
 468     case BUTTON_DISABLE_NOTIFICATION: {
 469       DisableStorageMonitoring(extension_id);
 470       break;
 471     }
 472     case BUTTON_UNINSTALL: {
 473       ShowUninstallPrompt(extension_id);
 474       break;
 475     }
 476     default:
 477       NOTREACHED();
 478   }
 479 }
 480
 481 void ExtensionStorageMonitor::DisableStorageMonitoring(
 482     const std::string& extension_id) {
 483   scoped_refptr<const Extension> extension =
 484       ExtensionRegistry::Get(context_)->enabled_extensions().GetByID(
 485           extension_id);
 486   if (!extension.get() || !ShouldGatherMetricsFor(extension.get()))
 487     StopMonitoringStorage(extension_id);
 488
 489   SetStorageNotificationEnabled(extension_id, false);
 490
 491   message_center::MessageCenter::Get()->RemoveNotification(
 492       GetNotificationId(extension_id), false);
 493 }
 494
 495 void ExtensionStorageMonitor::StartMonitoringStorage(
 496     const Extension* extension) {
 497   if (!ShouldMonitorStorageFor(extension))
 498     return;
 499
 500   // First apply this feature only to experimental ephemeral apps. If it works
 501   // well, roll it out to all extensions and apps.
 502   bool should_enforce =
 503       (enable_for_all_extensions_ ||
 504        extension_prefs_->IsEphemeralApp(extension->id())) &&
 505       IsStorageNotificationEnabled(extension->id());
 506
 507   bool for_metrics = ShouldGatherMetricsFor(extension);
 508
 509   if (!should_enforce && !for_metrics)
 510     return;  // Don't track this extension.
 511
 512   // Lazily create the storage monitor proxy on the IO thread.
 513   if (!storage_observer_.get()) {
 514     storage_observer_ =
 515         new StorageEventObserver(weak_ptr_factory_.GetWeakPtr());
 516   }
 517
 518   GURL site_url = util::GetSiteForExtensionId(extension->id(), context_);
 519   content::StoragePartition* storage_partition =
 520       content::BrowserContext::GetStoragePartitionForSite(context_, site_url);
 521   DCHECK(storage_partition);
 522   scoped_refptr<storage::QuotaManager> quota_manager(
 523       storage_partition->GetQuotaManager());
 524
 525   GURL storage_origin(site_url.GetOrigin());
 526   if (extension->is_hosted_app())
 527     storage_origin = AppLaunchInfo::GetLaunchWebURL(extension).GetOrigin();
 528
 529   // Don't give a threshold if we're not enforcing.
 530   int next_threshold =
 531       should_enforce ? GetNextStorageThreshold(extension->id()) : -1;
 532
 533   BrowserThread::PostTask(
 534       BrowserThread::IO,
 535       FROM_HERE,
 536       base::Bind(&StorageEventObserver::StartObservingForExtension,
 537                  storage_observer_,
 538                  quota_manager,
 539                  extension->id(),
 540                  storage_origin,
 541                  next_threshold,
 542                  observer_rate_,
 543                  for_metrics));
 544 }
 545
 546 void ExtensionStorageMonitor::StopMonitoringStorage(
 547     const std::string& extension_id) {
 548   if (!storage_observer_.get())
 549     return;
 550
 551   BrowserThread::PostTask(
 552       BrowserThread::IO,
 553       FROM_HERE,
 554       base::Bind(&StorageEventObserver::StopObservingForExtension,
 555                  storage_observer_,
 556                  extension_id));
 557 }
 558
 559 void ExtensionStorageMonitor::StopMonitoringAll() {
 560   extension_registry_observer_.RemoveAll();
 561
 562   RemoveAllNotifications();
 563
 564   if (!storage_observer_.get())
 565     return;
 566
 567   BrowserThread::PostTask(
 568       BrowserThread::IO,
 569       FROM_HERE,
 570       base::Bind(&StorageEventObserver::StopObserving, storage_observer_));
 571   storage_observer_ = NULL;
 572 }
 573
 574 void ExtensionStorageMonitor::RemoveNotificationForExtension(
 575     const std::string& extension_id) {
 576   std::set<std::string>::iterator ext_id =
 577       notified_extension_ids_.find(extension_id);
 578   if (ext_id == notified_extension_ids_.end())
 579     return;
 580
 581   notified_extension_ids_.erase(ext_id);
 582   message_center::MessageCenter::Get()->RemoveNotification(
 583       GetNotificationId(extension_id), false);
 584 }
 585
 586 void ExtensionStorageMonitor::RemoveAllNotifications() {
 587   if (notified_extension_ids_.empty())
 588     return;
 589
 590   message_center::MessageCenter* center = message_center::MessageCenter::Get();
 591   DCHECK(center);
 592   for (std::set<std::string>::iterator it = notified_extension_ids_.begin();
 593        it != notified_extension_ids_.end(); ++it) {
 594     center->RemoveNotification(GetNotificationId(*it), false);
 595   }
 596   notified_extension_ids_.clear();
 597 }
 598
 599 void ExtensionStorageMonitor::ShowUninstallPrompt(
 600     const std::string& extension_id) {
 601   const Extension* extension = GetExtensionById(context_, extension_id);
 602   if (!extension)
 603     return;
 604
 605   if (!uninstall_dialog_.get()) {
 606     uninstall_dialog_.reset(ExtensionUninstallDialog::Create(
 607         Profile::FromBrowserContext(context_), NULL, this));
 608   }
 609
 610   uninstall_extension_id_ = extension->id();
 611   uninstall_dialog_->ConfirmUninstall(
 612       extension, extensions::UNINSTALL_REASON_STORAGE_THRESHOLD_EXCEEDED,
 613       UNINSTALL_SOURCE_STORAGE_THRESHOLD_EXCEEDED);
 614 }
 615
 616 int64 ExtensionStorageMonitor::GetNextStorageThreshold(
 617     const std::string& extension_id) const {
 618   int next_threshold = GetNextStorageThresholdFromPrefs(extension_id);
 619   if (next_threshold == 0) {
 620     // The next threshold is written to the prefs after the initial threshold is
 621     // exceeded.
 622     next_threshold = extension_prefs_->IsEphemeralApp(extension_id)
 623                          ? initial_ephemeral_threshold_
 624                          : initial_extension_threshold_;
 625   }
 626   return next_threshold;
 627 }
 628
 629 void ExtensionStorageMonitor::SetNextStorageThreshold(
 630     const std::string& extension_id,
 631     int64 next_threshold) {
 632   extension_prefs_->UpdateExtensionPref(
 633       extension_id,
 634       kPrefNextStorageThreshold,
 635       next_threshold > 0
 636           ? new base::StringValue(base::Int64ToString(next_threshold))
 637           : NULL);
 638 }
 639
 640 int64 ExtensionStorageMonitor::GetNextStorageThresholdFromPrefs(
 641     const std::string& extension_id) const {
 642   std::string next_threshold_str;
 643   if (extension_prefs_->ReadPrefAsString(
 644           extension_id, kPrefNextStorageThreshold, &next_threshold_str)) {
 645     int64 next_threshold;
 646     if (base::StringToInt64(next_threshold_str, &next_threshold))
 647       return next_threshold;
 648   }
 649
 650   // A return value of zero indicates that the initial threshold has not yet
 651   // been reached.
 652   return 0;
 653 }
 654
 655 bool ExtensionStorageMonitor::IsStorageNotificationEnabled(
 656     const std::string& extension_id) const {
 657   bool disable_notifications;
 658   if (extension_prefs_->ReadPrefAsBoolean(extension_id,
 659                                           kPrefDisableStorageNotifications,
 660                                           &disable_notifications)) {
 661     return !disable_notifications;
 662   }
 663
 664   return true;
 665 }
 666
 667 void ExtensionStorageMonitor::SetStorageNotificationEnabled(
 668     const std::string& extension_id,
 669     bool enable_notifications) {
 670   extension_prefs_->UpdateExtensionPref(
 671       extension_id,
 672       kPrefDisableStorageNotifications,
 673       enable_notifications ? NULL : new base::FundamentalValue(true));
 674 }
 675
 676 }  // namespace extensions