Moved IS_EPHEMERAL flag to extension prefs

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 193 matching lines @@
           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(
@@ skipping 92 matching lines @@
 
 void ExtensionStorageMonitor::OnNotificationButtonClick(
     const std::string& extension_id, int button_index) {
   switch (button_index) {
     case BUTTON_DISABLE_NOTIFICATION: {
       DisableStorageMonitoring(extension_id);
       break;
     }
     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);
 
   message_center::MessageCenter::Get()->RemoveNotification(
       GetNotificationId(extension_id), false);
 }
 
 void ExtensionStorageMonitor::StartMonitoringStorage(
     const Extension* extension) {
   if (!extension->HasAPIPermission(APIPermission::kUnlimitedStorage))
     return;
 
   // Do not monitor storage for component extensions.
   if (extension->location() == Manifest::COMPONENT)
     return;
 
-  // First apply this feature only to experimental ephemeral apps. If it works
-  // well, roll it out to all extensions and apps.
-  if (!extension->is_ephemeral() && !enable_for_all_extensions_)
-    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_)
+    return;
+
   if (!prefs->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 = extension->is_ephemeral() ? initial_ephemeral_threshold_
-                                               : initial_extension_threshold_;
+    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,
@@ skipping 50 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();
 }
 
 }  // namespace extensions