Remove all the ephemeral apps code.

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/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 28 matching lines @@
 
 using content::BrowserThread;
 
 namespace extensions {
 
 namespace {
 
 // The rate at which we would like to observe storage events.
 const int kStorageEventRateSec = 30;
 
-// Set the thresholds for the first notification. Ephemeral apps have a lower
-// threshold than installed extensions and apps. Once a threshold is exceeded,
+// Set the thresholds for the first notification. 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";
@@ skipping 206 matching lines @@
 // static
 ExtensionStorageMonitor* ExtensionStorageMonitor::Get(
     content::BrowserContext* context) {
   return ExtensionStorageMonitorFactory::GetForBrowserContext(context);
 }
 
 ExtensionStorageMonitor::ExtensionStorageMonitor(
     content::BrowserContext* context)
     : enable_for_all_extensions_(false),
       initial_extension_threshold_(kExtensionInitialThreshold),
-      initial_ephemeral_threshold_(kEphemeralAppInitialThreshold),
       observer_rate_(base::TimeDelta::FromSeconds(kStorageEventRateSec)),
       context_(context),
       extension_prefs_(ExtensionPrefs::Get(context)),
       extension_registry_observer_(this),
       weak_ptr_factory_(this) {
   DCHECK(extension_prefs_);
 
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::Source<content::BrowserContext>(context_));
 
@@ skipping 26 matching lines @@
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   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))
+  if (!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;
   }
 
@@ skipping 145 matching lines @@
 
   message_center::MessageCenter::Get()->RemoveNotification(
       GetNotificationId(extension_id), false);
 }
 
 void ExtensionStorageMonitor::StartMonitoringStorage(
     const Extension* extension) {
   if (!ShouldMonitorStorageFor(extension))
     return;
 
-  // First apply this feature only to experimental ephemeral apps. If it works
-  // well, roll it out to all extensions and apps.
-  bool should_enforce =
-      (enable_for_all_extensions_ ||
-       extension_prefs_->IsEphemeralApp(extension->id())) &&
-      IsStorageNotificationEnabled(extension->id());
+  bool should_enforce = (enable_for_all_extensions_) &&
+                        IsStorageNotificationEnabled(extension->id());
 
   bool for_metrics = ShouldGatherMetricsFor(extension);
 
   if (!should_enforce && !for_metrics)
     return;  // Don't track this extension.
 
   // Lazily create the storage monitor proxy on the IO thread.
   if (!storage_observer_.get()) {
     storage_observer_ =
         new StorageEventObserver(weak_ptr_factory_.GetWeakPtr());
@@ skipping 96 matching lines @@
       extension, extensions::UNINSTALL_REASON_STORAGE_THRESHOLD_EXCEEDED,
       UNINSTALL_SOURCE_STORAGE_THRESHOLD_EXCEEDED);
 }
 
 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_;
+    next_threshold = initial_extension_threshold_;
   }
   return next_threshold;
 }
 
 void ExtensionStorageMonitor::SetNextStorageThreshold(
     const std::string& extension_id,
     int64 next_threshold) {
   extension_prefs_->UpdateExtensionPref(
       extension_id,
       kPrefNextStorageThreshold,
@@ skipping 32 matching lines @@
 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