Handle promotion of ephemeral apps in the ExtensionStorageMonitor

chrome/browser/extensions/extension_storage_monitor.cc

 // Copyright 2014 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_storage_monitor.h"
 
 #include <map>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 36 matching lines @@
 // threshold than installed extensions and apps. Once a threshold is exceeded,
 // it will be doubled to throttle notifications.
 const int64 kMBytes = 1024 * 1024;
 const int64 kEphemeralAppInitialThreshold = 250 * kMBytes;
 const int64 kExtensionInitialThreshold = 1000 * kMBytes;
 
 // Notifications have an ID so that we can update them.
 const char kNotificationIdFormat[] = "ExtensionStorageMonitor-$1-$2";
 const char kSystemNotifierId[] = "ExtensionStorageMonitor";
 
+// A preference that stores the next threshold for displaying a notification
+// when an extension or app consumes excessive disk space. This will not be
+// set until the extension/app reaches the initial threshold.
+const char kPrefNextStorageThreshold[] = "next_storage_threshold";
+
+// If this preference is set to true, notifications will be suppressed when an
+// extension or app consumes excessive disk space.
+const char kPrefDisableStorageNotifications[] = "disable_storage_notifications";
+
+bool ShouldMonitorStorageFor(const Extension* extension) {
+  // Only monitor storage for extensions that are granted unlimited storage.
+  // Do not monitor storage for component extensions.
+  return extension->HasAPIPermission(APIPermission::kUnlimitedStorage) &&
+         extension->location() != Manifest::COMPONENT;
+}
+
 }  // namespace
 
 // StorageEventObserver monitors the storage usage of extensions and lives on
 // the IO thread. When a threshold is exceeded, a message will be posted to the
 // UI thread, which displays the notification.
 class StorageEventObserver
     : public base::RefCountedThreadSafe<
           StorageEventObserver,
           BrowserThread::DeleteOnIOThread>,
       public quota::StorageObserver {
@@ skipping 20 matching lines @@
     state.next_threshold = next_threshold;
 
     quota::StorageObserver::MonitorParams params(
         kMonitorStorageType,
         origin,
         base::TimeDelta::FromSeconds(rate),
         false);
     quota_manager->AddStorageObserver(this, params);
   }
 
+  // Updates the threshold for an extension already being monitored.
+  void UpdateThresholdForExtension(const std::string& extension_id,
+                                   int64 next_threshold) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+    for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
+         it != origin_state_map_.end();
+         ++it) {
+      if (it->second.extension_id == extension_id) {
+        it->second.next_threshold = next_threshold;
+        break;
+      }
+    }
+  }
+
   // Deregister as an observer for the extension's storage events.
   void StopObservingForExtension(const std::string& extension_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     for (OriginStorageStateMap::iterator it = origin_state_map_.begin();
          it != origin_state_map_.end(); ) {
       if (it->second.extension_id == extension_id) {
         quota::StorageObserver::Filter filter(kMonitorStorageType, it->first);
         it->second.quota_manager->RemoveStorageObserverForFilter(this, filter);
         origin_state_map_.erase(it++);
@@ skipping 67 matching lines @@
   return ExtensionStorageMonitorFactory::GetForBrowserContext(context);
 }
 
 ExtensionStorageMonitor::ExtensionStorageMonitor(
     content::BrowserContext* context)
     : enable_for_all_extensions_(false),
       initial_extension_threshold_(kExtensionInitialThreshold),
       initial_ephemeral_threshold_(kEphemeralAppInitialThreshold),
       observer_rate_(kStorageEventRateSec),
       context_(context),
+      extension_prefs_(ExtensionPrefs::Get(context)),
+      extension_registry_observer_(this),
       weak_ptr_factory_(this) {
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
-                 content::Source<content::BrowserContext>(context_));
+  DCHECK(extension_prefs_);
+
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::Source<content::BrowserContext>(context_));
 
-  ExtensionRegistry* registry = ExtensionRegistry::Get(context_);
-  DCHECK(registry);
-  registry->AddObserver(this);
+  extension_registry_observer_.Add(ExtensionRegistry::Get(context_));
 }
 
 ExtensionStorageMonitor::~ExtensionStorageMonitor() {}
 
 void ExtensionStorageMonitor::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED: {
-      const Extension* extension =
-          content::Details<const Extension>(details).ptr();
-      RemoveNotificationForExtension(extension->id());
-      break;
-    }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       StopMonitoringAll();
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionStorageMonitor::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
-  DCHECK(extension);
   StartMonitoringStorage(extension);
 }
 
 void ExtensionStorageMonitor::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
-  DCHECK(extension);
   StopMonitoringStorage(extension->id());
 }
 
+void ExtensionStorageMonitor::OnExtensionWillBeInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update,
+    bool from_ephemeral,
+    const std::string& old_name) {
+  // If an ephemeral app was promoted to a regular installed app, we may need to
+  // increase its next threshold.
+  if (!from_ephemeral || !ShouldMonitorStorageFor(extension))
+    return;
+
+  if (!enable_for_all_extensions_) {
+    // If monitoring is not enabled for installed extensions, just stop
+    // monitoring.
+    SetNextStorageThreshold(extension->id(), 0);
+    StopMonitoringStorage(extension->id());
+    return;
+  }
+
+  int64 next_threshold = GetNextStorageThresholdFromPrefs(extension->id());
+  if (next_threshold <= initial_extension_threshold_) {
+    // Clear the next threshold in the prefs. This effectively raises it to
+    // |initial_extension_threshold_|. If the current threshold is already
+    // higher than this, leave it as is.
+    SetNextStorageThreshold(extension->id(), 0);
+
+    if (storage_observer_.get()) {
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(&StorageEventObserver::UpdateThresholdForExtension,
+                     storage_observer_,
+                     extension->id(),
+                     initial_extension_threshold_));
+    }
+  }
+}
+
+void ExtensionStorageMonitor::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  RemoveNotificationForExtension(extension->id());
+}
+
 std::string ExtensionStorageMonitor::GetNotificationId(
     const std::string& extension_id) {
   std::vector<std::string> placeholders;
   placeholders.push_back(context_->GetPath().BaseName().MaybeAsASCII());
   placeholders.push_back(extension_id);
 
   return ReplaceStringPlaceholders(kNotificationIdFormat, placeholders, NULL);
 }
 
 void ExtensionStorageMonitor::OnStorageThresholdExceeded(
     const std::string& extension_id,
     int64 next_threshold,
     int64 current_usage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension = ExtensionRegistry::Get(context_)->
       GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
   if (!extension)
     return;
 
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
-  DCHECK(prefs);
-  prefs->SetNextStorageThreshold(extension->id(), next_threshold);
+  if (GetNextStorageThreshold(extension->id()) < next_threshold)
+    SetNextStorageThreshold(extension->id(), next_threshold);
 
   const int kIconSize = message_center::kNotificationIconSize;
   ExtensionResource resource =  IconsInfo::GetIconResource(
       extension, kIconSize, ExtensionIconSet::MATCH_BIGGER);
   ImageLoader::Get(context_)->LoadImageAsync(
       extension, resource, gfx::Size(kIconSize, kIconSize),
       base::Bind(&ExtensionStorageMonitor::OnImageLoaded,
                  weak_ptr_factory_.GetWeakPtr(),
                  extension_id,
                  current_usage));
@@ skipping 59 matching lines @@
     }
     default:
       NOTREACHED();
   }
 }
 
 void ExtensionStorageMonitor::DisableStorageMonitoring(
     const std::string& extension_id) {
   StopMonitoringStorage(extension_id);
 
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
-  DCHECK(prefs);
-  prefs->SetStorageNotificationEnabled(extension_id, false);
+  SetStorageNotificationEnabled(extension_id, false);
 
   message_center::MessageCenter::Get()->RemoveNotification(
       GetNotificationId(extension_id), false);
 }
 
 void ExtensionStorageMonitor::StartMonitoringStorage(
     const Extension* extension) {
-  if (!extension->HasAPIPermission(APIPermission::kUnlimitedStorage))
+  if (!ShouldMonitorStorageFor(extension))
     return;
 
-  // Do not monitor storage for component extensions.
-  if (extension->location() == Manifest::COMPONENT)
-    return;
-
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
-  DCHECK(prefs);
-
   // First apply this feature only to experimental ephemeral apps. If it works
   // well, roll it out to all extensions and apps.
-  bool is_ephemeral = prefs->IsEphemeralApp(extension->id());
-  if (!is_ephemeral && !enable_for_all_extensions_)
+  if (!enable_for_all_extensions_ &&
+      !extension_prefs_->IsEphemeralApp(extension->id())) {
     return;
+  }
 
-  if (!prefs->IsStorageNotificationEnabled(extension->id()))
+  if (!IsStorageNotificationEnabled(extension->id()))
     return;
 
   // Lazily create the storage monitor proxy on the IO thread.
   if (!storage_observer_.get()) {
     storage_observer_ =
         new StorageEventObserver(weak_ptr_factory_.GetWeakPtr());
   }
 
   GURL site_url =
       extensions::util::GetSiteForExtensionId(extension->id(), context_);
   content::StoragePartition* storage_partition =
       content::BrowserContext::GetStoragePartitionForSite(context_, site_url);
   DCHECK(storage_partition);
   scoped_refptr<quota::QuotaManager> quota_manager(
       storage_partition->GetQuotaManager());
 
   GURL storage_origin(site_url.GetOrigin());
   if (extension->is_hosted_app())
     storage_origin = AppLaunchInfo::GetLaunchWebURL(extension).GetOrigin();
 
-  int next_threshold = prefs->GetNextStorageThreshold(extension->id());
-  if (next_threshold == 0) {
-    // The next threshold is written to the prefs after the initial threshold is
-    // exceeded.
-    next_threshold = is_ephemeral ? initial_ephemeral_threshold_
-                                  : initial_extension_threshold_;
-  }
-
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&StorageEventObserver::StartObservingForExtension,
                  storage_observer_,
                  quota_manager,
                  extension->id(),
                  storage_origin,
-                 next_threshold,
+                 GetNextStorageThreshold(extension->id()),
                  observer_rate_));
 }
 
 void ExtensionStorageMonitor::StopMonitoringStorage(
     const std::string& extension_id) {
   if (!storage_observer_.get())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&StorageEventObserver::StopObservingForExtension,
                  storage_observer_,
                  extension_id));
 }
 
 void ExtensionStorageMonitor::StopMonitoringAll() {
-  ExtensionRegistry* registry = ExtensionRegistry::Get(context_);
-  DCHECK(registry);
-  registry->RemoveObserver(this);
+  extension_registry_observer_.RemoveAll();
 
   RemoveAllNotifications();
 
   if (!storage_observer_.get())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&StorageEventObserver::StopObserving, storage_observer_));
@@ skipping 18 matching lines @@
 
   message_center::MessageCenter* center = message_center::MessageCenter::Get();
   DCHECK(center);
   for (std::set<std::string>::iterator it = notified_extension_ids_.begin();
        it != notified_extension_ids_.end(); ++it) {
     center->RemoveNotification(GetNotificationId(*it), false);
   }
   notified_extension_ids_.clear();
 }
 
+int64 ExtensionStorageMonitor::GetNextStorageThreshold(
+    const std::string& extension_id) const {
+  int next_threshold = GetNextStorageThresholdFromPrefs(extension_id);
+  if (next_threshold == 0) {
+    // The next threshold is written to the prefs after the initial threshold is
+    // exceeded.
+    next_threshold = extension_prefs_->IsEphemeralApp(extension_id)
+                         ? initial_ephemeral_threshold_
+                         : initial_extension_threshold_;
+  }
+  return next_threshold;
+}
+
+void ExtensionStorageMonitor::SetNextStorageThreshold(
+    const std::string& extension_id,
+    int64 next_threshold) {
+  extension_prefs_->UpdateExtensionPref(
+      extension_id,
+      kPrefNextStorageThreshold,
+      next_threshold > 0
+          ? new base::StringValue(base::Int64ToString(next_threshold))
+          : NULL);
+}
+
+int64 ExtensionStorageMonitor::GetNextStorageThresholdFromPrefs(
+    const std::string& extension_id) const {
+  std::string next_threshold_str;
+  if (extension_prefs_->ReadPrefAsString(
+          extension_id, kPrefNextStorageThreshold, &next_threshold_str)) {
+    int64 next_threshold;
+    if (base::StringToInt64(next_threshold_str, &next_threshold))
+      return next_threshold;
+  }
+
+  // A return value of zero indicates that the initial threshold has not yet
+  // been reached.
+  return 0;
+}
+
+bool ExtensionStorageMonitor::IsStorageNotificationEnabled(
+    const std::string& extension_id) const {
+  bool disable_notifications;
+  if (extension_prefs_->ReadPrefAsBoolean(extension_id,
+                                          kPrefDisableStorageNotifications,
+                                          &disable_notifications)) {
+    return !disable_notifications;
+  }
+
+  return true;
+}
+
+void ExtensionStorageMonitor::SetStorageNotificationEnabled(
+    const std::string& extension_id,
+    bool enable_notifications) {
+  extension_prefs_->UpdateExtensionPref(
+      extension_id,
+      kPrefDisableStorageNotifications,
+      enable_notifications ? NULL : new base::FundamentalValue(true));
+}
+
 }  // namespace extensions