Moving test_api to api/test .

chrome/browser/extensions/extensions_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
 // 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_
 #pragma once
 
 #include <list>
 #include <map>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/values.h"
 
+namespace extensions {
+class ExtensionTestQuotaResetFunction;
+} // namespace extensions

[Yoyo Zhou, 2012/07/10 19:00:11]

ditto

[vabr (Chromium), 2012/07/11 10:01:25]

Done. Also moved the forward decl. after those non-nested, to match the style
guide.

+
 class ExtensionFunction;
 class QuotaLimitHeuristic;
 typedef std::list<QuotaLimitHeuristic*> QuotaLimitHeuristics;
 
 // The ExtensionsQuotaService takes care that calls to certain extension
 // functions do not exceed predefined quotas.
 //
 // The ExtensionsQuotaService 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 {
  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();
 
   // Decide whether the invocation of |function| with argument |args| by the
   // extension specified by |extension_id| results in a quota limit violation.
   // Returns true if the request is fine and can proceed, false if the request
   // should be throttled and an error returned to the extension.
   bool Assess(const std::string& extension_id, ExtensionFunction* function,
               const ListValue* args, const base::TimeTicks& event_time);
  private:
-  friend class ExtensionTestQuotaResetFunction;
+  friend class extensions::ExtensionTestQuotaResetFunction;
   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 |violators_|) 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
@@ skipping 147 matching lines @@
   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_