Moved ExtensionInfoMap and ExtensionsQuotaService to extensions/

extensions/browser/quota_service.h

 // Copyright (c) 2012 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 ExtensionsQuotaService uses heuristics to limit abusive requests
+// 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
 // arguments to a unique Bucket (the BucketMapper), and another to determine
 // if a new request involving such an item at a given time is a violation.
 
-#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSIONS_QUOTA_SERVICE_H_
-#define CHROME_BROWSER_EXTENSIONS_EXTENSIONS_QUOTA_SERVICE_H_
+#ifndef EXTENSIONS_BROWSER_QUOTA_SERVICE_H_
+#define EXTENSIONS_BROWSER_QUOTA_SERVICE_H_
 
 #include <list>
 #include <map>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #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;
 
-namespace extensions {
-class TestResetQuotaFunction;
-}
-
-// The ExtensionsQuotaService takes care that calls to certain extension
+// The QuotaService takes care that calls to certain extension
 // functions do not exceed predefined quotas.
 //
-// The ExtensionsQuotaService needs to live entirely on one thread, i.e.
+// 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.
-class ExtensionsQuotaService : public base::NonThreadSafe {
+class QuotaService : public base::NonThreadSafe {
  public:
   // Some concrete heuristics (declared below) that ExtensionFunctions can
   // use to help the service make decisions about quota violations.
   class TimedLimit;
   class SustainedLimit;
 
-  ExtensionsQuotaService();
-  virtual ~ExtensionsQuotaService();
+  QuotaService();
+  virtual ~QuotaService();
 
   // 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
   // converge to the correct set.
   void Purge();
   void PurgeFunctionHeuristicsMap(FunctionHeuristicsMap* map);
-  base::RepeatingTimer<ExtensionsQuotaService> purge_timer_;
+  base::RepeatingTimer<QuotaService> purge_timer_;
 
   // Our quota tracking state for extensions that have invoked quota limited
   // functions.  Each extension is treated separately, so extension ids are the
   // key for the mapping.  As an extension invokes functions, the map keeps
   // track of which functions it has invoked and the heuristics for each one.
   // Each heuristic will be evaluated and ANDed together to get a final answer.
   std::map<ExtensionId, FunctionHeuristicsMap> function_heuristics_;
 
   // For now, as soon as an extension violates quota, we don't allow it to
   // make any more requests to quota limited functions.  This provides a quick
   // lookup for these extensions that is only stored in memory.
   typedef std::map<std::string, std::string> ViolationErrorMap;
   ViolationErrorMap violation_errors_;
 
-  DISALLOW_COPY_AND_ASSIGN(ExtensionsQuotaService);
+  DISALLOW_COPY_AND_ASSIGN(QuotaService);
 };
 
 // A QuotaLimitHeuristic is two things: 1, A heuristic to map extension
 // function arguments to corresponding Buckets for each input arg, and 2) a
 // heuristic for determining if a new event involving a particular item
 // (represented by its Bucket) constitutes a quota violation.
 class QuotaLimitHeuristic {
  public:
   // Parameters to configure the amount of tokens allotted to individual
   // Bucket objects (see Below) and how often they are replenished.
@@ skipping 24 matching lines @@
     bool has_tokens() const { return num_tokens_ > 0; }
 
     // Reset this bucket to specification (from internal configuration), to be
     // valid from |start| until the first refill interval elapses and it needs
     // to be reset again.
     void Reset(const Config& config, const base::TimeTicks& start);
 
     // The time at which the token count and next expiration should be reset,
     // via a call to Reset.
     const base::TimeTicks& expiration() { return expiration_; }
+
    private:
     base::TimeTicks expiration_;
     int64 num_tokens_;
     DISALLOW_COPY_AND_ASSIGN(Bucket);
   };
   typedef std::list<Bucket*> BucketList;
 
   // A helper interface to retrieve the bucket corresponding to |args| from
   // the set of buckets (which is typically stored in the BucketMapper itself)
   // for this QuotaLimitHeuristic.
@@ skipping 55 matching lines @@
   scoped_ptr<BucketMapper> bucket_mapper_;
 
   // The name of the heuristic for formatting error messages.
   std::string name_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaLimitHeuristic);
 };
 
 // A simple per-item heuristic to limit the number of events that can occur in
 // a given period of time; e.g "no more than 100 events in an hour".
-class ExtensionsQuotaService::TimedLimit : public QuotaLimitHeuristic {
+class QuotaService::TimedLimit : public QuotaLimitHeuristic {
  public:
   TimedLimit(const Config& config, BucketMapper* map, const std::string& name)
       : QuotaLimitHeuristic(config, map, name) {}
   virtual bool Apply(Bucket* bucket,
                      const base::TimeTicks& event_time) OVERRIDE;
 };
 
 // A per-item heuristic to limit the number of events that can occur in a
 // period of time over a sustained longer interval. E.g "no more than two
 // events per minute, sustained over 10 minutes".
-class ExtensionsQuotaService::SustainedLimit : public QuotaLimitHeuristic {
+class QuotaService::SustainedLimit : public QuotaLimitHeuristic {
  public:
   SustainedLimit(const base::TimeDelta& sustain,
                  const Config& config,
                  BucketMapper* map,
                  const std::string& name);
   virtual bool Apply(Bucket* bucket,
                      const base::TimeTicks& event_time) OVERRIDE;
+
  private:
   // Specifies how long exhaustion of buckets is allowed to continue before
   // denying requests.
   const int64 repeat_exhaustion_allowance_;
   int64 num_available_repeat_exhaustions_;
 };
 
-#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_QUOTA_SERVICE_H_
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_QUOTA_SERVICE_H_