Show a notification when an ephemeral app consumes excessive disk space

extensions/browser/extension_prefs.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 "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 172 matching lines @@
 // Their data is retained and garbage collected when inactive for a long period
 // of time.
 const char kPrefEvictedEphemeralApp[] = "evicted_ephemeral_app";
 
 // Am installation parameter bundled with an extension.
 const char kPrefInstallParam[] = "install_parameter";
 
 // A list of installed ids and a signature.
 const char kInstallSignature[] = "extensions.install_signature";
 
+// 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";
+
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedExtensionPrefUpdate(PrefService* service,
                             const std::string& extension_id) :
     DictionaryPrefUpdate(service, pref_names::kExtensions),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
   }
@@ skipping 663 matching lines @@
   }
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& id) const {
   const base::DictionaryValue* ext_prefs = GetExtensionPref(id);
   return ext_prefs && IsBlacklistBitSet(ext_prefs);
 }
 
 namespace {
 
+// Serializes a 64bit integer as a string value.
+void SaveInt64(base::DictionaryValue* dictionary,
+               const char* key,
+               const int64 value) {
+  if (!dictionary)
+    return;
+
+  std::string string_value = base::Int64ToString(value);
+  dictionary->SetString(key, string_value);
+}
+
+// Deserializes a 64bit integer stored as a string value.
+bool ReadInt64(const base::DictionaryValue* dictionary,
+               const char* key,
+               int64* value) {
+  if (!dictionary)
+    return false;
+
+  std::string string_value;
+  if (!dictionary->GetString(key, &string_value))
+    return false;
+
+  return base::StringToInt64(string_value, value);
+}
+
 // Serializes |time| as a string value mapped to |key| in |dictionary|.
 void SaveTime(base::DictionaryValue* dictionary,
               const char* key,
               const base::Time& time) {
-  if (!dictionary)
-    return;
-  std::string string_value = base::Int64ToString(time.ToInternalValue());
-  dictionary->SetString(key, string_value);
+  SaveInt64(dictionary, key, time.ToInternalValue());
 }
 
 // The opposite of SaveTime. If |key| is not found, this returns an empty Time
 // (is_null() will return true).
 base::Time ReadTime(const base::DictionaryValue* dictionary, const char* key) {
-  if (!dictionary)
-    return base::Time();
-  std::string string_value;
   int64 value;
-  if (dictionary->GetString(key, &string_value)) {
-    if (base::StringToInt64(string_value, &value)) {
-      return base::Time::FromInternalValue(value);
-    }
-  }
+  if (ReadInt64(dictionary, key, &value))
+    return base::Time::FromInternalValue(value);
+
   return base::Time();
 }
 
 }  // namespace
 
 base::Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const {
   DCHECK(Extension::IdIsValid(extension_id));
   return ReadTime(GetExtensionPref(extension_id), kLastPingDay);
 }
 
@@ skipping 960 matching lines @@
   return install_parameter;
 }
 
 void ExtensionPrefs::SetInstallParam(const std::string& extension_id,
                                      const std::string& install_parameter) {
   UpdateExtensionPref(extension_id,
                       kPrefInstallParam,
                       new base::StringValue(install_parameter));
 }
 
+int64 ExtensionPrefs::GetNextStorageThreshold(
+    const std::string& extension_id) const {
+  int64 next_threshold;
+  if (ReadInt64(GetExtensionPref(extension_id),
+                kPrefNextStorageThreshold,
+                &next_threshold)) {
+    return next_threshold;
+  }
+
+  return 0;
+}
+
+void ExtensionPrefs::SetNextStorageThreshold(const std::string& extension_id,
+                                             int64 next_threshold) {
+
+  ScopedExtensionPrefUpdate update(prefs_, extension_id);
+  SaveInt64(update.Get(), kPrefNextStorageThreshold, next_threshold);
+}
+
+bool ExtensionPrefs::IsStorageNotificationEnabled(
+    const std::string& extension_id) const {
+  bool disable_notifications;
+  if (ReadPrefAsBoolean(extension_id,
+                        kPrefDisableStorageNotifications,
+                        &disable_notifications)) {
+    return !disable_notifications;
+  }
+
+  return true;
+}
+
+void ExtensionPrefs::SetStorageNotificationEnabled(
+    const std::string& extension_id, bool enable_notifications) {
+  UpdateExtensionPref(
+      extension_id,
+      kPrefDisableStorageNotifications,
+      enable_notifications ? NULL : new base::FundamentalValue(true));
+}
+
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const base::FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     scoped_ptr<AppSorting> app_sorting,
     scoped_ptr<TimeProvider> time_provider,
     bool extensions_disabled,
     const std::vector<ExtensionPrefsObserver*>& early_observers)
     : prefs_(prefs),
       install_directory_(root_dir),
@@ skipping 267 matching lines @@
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions