Remove bookmarks API client-side write operations limits

extensions/browser/quota_service.h

 // Copyright 2013 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.
 
 // The QuotaService uses heuristics to limit abusive requests
 // made by extensions.  In this model 'items' (e.g individual bookmarks) are
 // represented by a 'Bucket' that holds state for that item for one single
 // interval of time.  The interval of time is defined as 'how long we need to
 // watch an item (for a particular heuristic) before making a decision about
 // quota violations'.  A heuristic is two functions: one mapping input
@@ skipping 12 matching lines @@
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 
 class ExtensionFunction;
 
 namespace extensions {
 class QuotaLimitHeuristic;
-class TestResetQuotaFunction;
 
 typedef std::list<QuotaLimitHeuristic*> QuotaLimitHeuristics;
 
 // The QuotaService takes care that calls to certain extension
 // functions do not exceed predefined quotas.
 //
 // The QuotaService needs to live entirely on one thread, i.e. be created,
 // called and destroyed on the same thread, due to its use of a RepeatingTimer.
 // It is not a KeyedService because instances exist on both the UI
 // and IO threads.
@@ skipping 10 matching lines @@
   // Decide whether the invocation of |function| with argument |args| by the
   // extension specified by |extension_id| results in a quota limit violation.
   // Returns an error message representing the failure if quota was exceeded,
   // or empty-string if the request is fine and can proceed.
   std::string Assess(const std::string& extension_id,
                      ExtensionFunction* function,
                      const base::ListValue* args,
                      const base::TimeTicks& event_time);
 
  private:
-  friend class extensions::TestResetQuotaFunction;
   typedef std::string ExtensionId;
   typedef std::string FunctionName;
   // All QuotaLimitHeuristic instances in this map are owned by us.
   typedef std::map<FunctionName, QuotaLimitHeuristics> FunctionHeuristicsMap;
 
   // Purge resets all accumulated data (except |violation_errors_|) as if the
   // service was just created. Called periodically so we don't consume an
   // unbounded amount of memory while tracking quota.  Yes, this could mean an
   // extension gets away with murder if it is timed right, but the extensions
   // we are trying to limit are ones that consistently violate, so we'll
@@ skipping 159 matching lines @@
  private:
   // Specifies how long exhaustion of buckets is allowed to continue before
   // denying requests.
   const int64 repeat_exhaustion_allowance_;
   int64 num_available_repeat_exhaustions_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_QUOTA_SERVICE_H_