Extension Settings API: throttle the API in the same way that the Bookmarks API

chrome/browser/extensions/settings/settings_api.cc

 // Copyright (c) 2011 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/settings/settings_api.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extensions_quota_service.h"
+#include "chrome/browser/extensions/settings/settings_api.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace extensions {
 
 using content::BrowserThread;
 
 namespace {
 const char* kUnsupportedArgumentType = "Unsupported argument type";
@@ skipping 50 matching lines @@
         &SettingsObserver::OnSettingsChanged,
         extension_id(),
         SettingChange::GetEventJson(result.changes()));
   }
 
   return true;
 }
 
 // Concrete settings functions
 
+namespace {
+
 // Adds all StringValues from a ListValue to a vector of strings.
-static void AddAllStringValues(
-    const ListValue& from, std::vector<std::string>* to) {
+void AddAllStringValues(const ListValue& from, std::vector<std::string>* to) {
   DCHECK(to->empty());
   std::string as_string;
   for (ListValue::const_iterator it = from.begin(); it != from.end(); ++it) {
     if ((*it)->GetAsString(&as_string)) {
       to->push_back(as_string);
     }
   }
 }
 
 // Gets the keys of a DictionaryValue.
-static std::vector<std::string> GetKeys(const DictionaryValue& dict) {
+std::vector<std::string> GetKeys(const DictionaryValue& dict) {
   std::vector<std::string> keys;
   for (DictionaryValue::key_iterator it = dict.begin_keys();
       it != dict.end_keys(); ++it) {
     keys.push_back(*it);
   }
   return keys;
 }
 
+// Creates quota heuristics for settings modification.
+static void GetModificationQuotaLimitHeuristics(
+    QuotaLimitHeuristics* heuristics) {
+  // A max of 1000 operations per hour.
+  QuotaLimitHeuristic::Config longLimitConfig = {
+      1000,
+      base::TimeDelta::FromHours(1)
+  };
+  heuristics->push_back(
+      new ExtensionsQuotaService::TimedLimit(
+          longLimitConfig, new QuotaLimitHeuristic::SingletonBucketMapper()));
+
+  // A max of 10 operations per minute, sustained over 10 minutes.
+  QuotaLimitHeuristic::Config shortLimitConfig = {
+      10,
+      base::TimeDelta::FromMinutes(1)
+  };
+  heuristics->push_back(
+      new ExtensionsQuotaService::SustainedLimit(
+          base::TimeDelta::FromMinutes(10),
+          shortLimitConfig,
+          new QuotaLimitHeuristic::SingletonBucketMapper()));
+};
+
+}  // namespace
+
 bool GetSettingsFunction::RunWithStorage(
     scoped_refptr<SettingsObserverList> observers,
     SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Value *input;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &input));
 
   switch (input->GetType()) {
     case Value::TYPE_NULL:
       return UseReadResult(storage->Get());
@@ skipping 32 matching lines @@
 
 bool SetSettingsFunction::RunWithStorage(
     scoped_refptr<SettingsObserverList> observers,
     SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DictionaryValue *input;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &input));
   return UseWriteResult(observers, storage->Set(*input));
 }
 
+void SetSettingsFunction::GetQuotaLimitHeuristics(
+    QuotaLimitHeuristics* heuristics) const {
+  GetModificationQuotaLimitHeuristics(heuristics);
+}
+
 bool RemoveSettingsFunction::RunWithStorage(
     scoped_refptr<SettingsObserverList> observers,
     SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Value *input;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &input));
 
   switch (input->GetType()) {
     case Value::TYPE_STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
       return UseWriteResult(observers, storage->Remove(as_string));
     }
 
     case Value::TYPE_LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<ListValue*>(input), &as_string_list);
       return UseWriteResult(observers, storage->Remove(as_string_list));
     }
 
     default:
       return UseWriteResult(
           observers,
           SettingsStorage::WriteResult(kUnsupportedArgumentType));
   };
 }
 
+void RemoveSettingsFunction::GetQuotaLimitHeuristics(
+    QuotaLimitHeuristics* heuristics) const {
+  GetModificationQuotaLimitHeuristics(heuristics);
+}
+
 bool ClearSettingsFunction::RunWithStorage(
     scoped_refptr<SettingsObserverList> observers,
     SettingsStorage* storage) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   return UseWriteResult(observers, storage->Clear());
 }
 
+void ClearSettingsFunction::GetQuotaLimitHeuristics(
+    QuotaLimitHeuristics* heuristics) const {
+  GetModificationQuotaLimitHeuristics(heuristics);
+}
+
 }  // namespace extensions