Convert most of extensions and some other random stuff to using the base namespace for Values.

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
@@ skipping 38 matching lines @@
 
   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 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 ListValue* args,
+                     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
@@ skipping 75 matching lines @@
   // the set of buckets (which is typically stored in the BucketMapper itself)
   // for this QuotaLimitHeuristic.
   class BucketMapper {
    public:
     virtual ~BucketMapper() {}
     // In most cases, this should simply extract item IDs from the arguments
     // (e.g for bookmark operations involving an existing item). If a problem
     // occurs while parsing |args|, the function aborts - buckets may be non-
     // empty). The expectation is that invalid args and associated errors are
     // handled by the ExtensionFunction itself so we don't concern ourselves.
-    virtual void GetBucketsForArgs(const ListValue* args,
+    virtual void GetBucketsForArgs(const base::ListValue* args,
                                    BucketList* buckets) = 0;
   };
 
   // Maps all calls to the same bucket, regardless of |args|, for this
   // QuotaLimitHeuristic.
   class SingletonBucketMapper : public BucketMapper {
    public:
     SingletonBucketMapper() {}
     virtual ~SingletonBucketMapper() {}
-    virtual void GetBucketsForArgs(const ListValue* args,
+    virtual void GetBucketsForArgs(const base::ListValue* args,
                                    BucketList* buckets) OVERRIDE;
 
    private:
     Bucket bucket_;
     DISALLOW_COPY_AND_ASSIGN(SingletonBucketMapper);
   };
 
   // Ownership of |map| is given to the new QuotaLimitHeuristic.
   QuotaLimitHeuristic(const Config& config,
                       BucketMapper* map,
                       const std::string& name);
   virtual ~QuotaLimitHeuristic();
 
   // Determines if sufficient quota exists (according to the Apply
   // implementation of a derived class) to perform an operation with |args|,
   // based on the history of similar operations with similar arguments (which
   // is retrieved using the BucketMapper).
-  bool ApplyToArgs(const ListValue* args, const base::TimeTicks& event_time);
+  bool ApplyToArgs(const base::ListValue* args,
+                   const base::TimeTicks& event_time);
 
   // Returns an error formatted according to this heuristic.
   std::string GetError() const;
 
  protected:
   const Config& config() { return config_; }
 
   // Determine if the new event occurring at |event_time| involving |bucket|
   // constitutes a quota violation according to this heuristic.
   virtual bool Apply(Bucket* bucket, const base::TimeTicks& event_time) = 0;
@@ skipping 34 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_