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

chrome/browser/extensions/extensions_quota_service_unittest.cc

 // 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.
 
 #include "base/message_loop.h"
 #include "base/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
@@ skipping 16 matching lines @@
 const Config kFrozenConfig = { 0, TimeDelta::FromDays(0) };
 const Config k2PerMinute = { 2, TimeDelta::FromMinutes(1) };
 const Config k20PerHour = { 20, TimeDelta::FromHours(1) };
 const TimeTicks kStartTime = TimeTicks();
 const TimeTicks k1MinuteAfterStart = kStartTime + TimeDelta::FromMinutes(1);
 
 class Mapper : public QuotaLimitHeuristic::BucketMapper {
  public:
   Mapper() {}
   virtual ~Mapper() { STLDeleteValues(&buckets_); }
-  virtual void GetBucketsForArgs(const ListValue* args,
+  virtual void GetBucketsForArgs(const base::ListValue* args,
                                  BucketList* buckets) OVERRIDE {
     for (size_t i = 0; i < args->GetSize(); i++) {
       int id;
       ASSERT_TRUE(args->GetInteger(i, &id));
       if (buckets_.find(id) == buckets_.end())
         buckets_[id] = new Bucket();
       buckets->push_back(buckets_[id]);
     }
   }
  private:
   typedef std::map<int, Bucket*> BucketMap;
   BucketMap buckets_;
   DISALLOW_COPY_AND_ASSIGN(Mapper);
 };
 
 class MockMapper : public QuotaLimitHeuristic::BucketMapper {
  public:
-  virtual void GetBucketsForArgs(const ListValue* args,
+  virtual void GetBucketsForArgs(const base::ListValue* args,
                                  BucketList* buckets) OVERRIDE {
   }
 };
 
 class MockFunction : public ExtensionFunction {
  public:
   explicit MockFunction(const std::string& name) { set_name(name); }
 
-  virtual void SetArgs(const ListValue* args) OVERRIDE {}
+  virtual void SetArgs(const base::ListValue* args) OVERRIDE {}
   virtual const std::string GetError() OVERRIDE { return std::string(); }
   virtual void SetError(const std::string& error) OVERRIDE {}
   virtual void Run() OVERRIDE {}
   virtual void Destruct() const OVERRIDE { delete this; }
   virtual bool RunImpl() OVERRIDE { return true; }
   virtual void SendResponse(bool) OVERRIDE { }
 
  protected:
   virtual ~MockFunction() {}
 };
@@ skipping 135 matching lines @@
 
   // Do the same as above except don't exhaust the 3rd (w.l.o.g) bucket.
   bucket.Reset(k2PerMinute, kStartTime);
   DoMoreThan2PerMinuteFor5Minutes(kStartTime, &lim, &bucket, 3);
   // If the 3rd bucket were exhausted, this would fail (see first test).
   EXPECT_TRUE(lim.Apply(&bucket, kStartTime + TimeDelta::FromMinutes(6)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
   scoped_refptr<MockFunction> f(new MockFunction("foo"));
-  ListValue args;
+  base::ListValue args;
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
-  ListValue args;
+  base::ListValue args;
   args.Append(new base::FundamentalValue(1));
   EXPECT_NE("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
-  ListValue args;
+  base::ListValue args;
   args.Append(new base::FundamentalValue(1));
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
   EXPECT_EQ("",
             service_->Assess(extension_a_,
                              f.get(),
                              &args,
                              kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_NE("",
             service_->Assess(extension_a_,
                              f.get(),
                              &args,
                              kStartTime + TimeDelta::FromSeconds(15)));
 
-  ListValue args2;
+  base::ListValue args2;
   args2.Append(new base::FundamentalValue(1));
   args2.Append(new base::FundamentalValue(2));
   EXPECT_EQ("", service_->Assess(extension_b_, f.get(), &args2, kStartTime));
   EXPECT_EQ("",
             service_->Assess(extension_b_,
                              f.get(),
                              &args2,
                              kStartTime + TimeDelta::FromSeconds(10)));
 
   TimeDelta peace = TimeDelta::FromMinutes(30);
   EXPECT_EQ("",
             service_->Assess(extension_b_, f.get(), &args, kStartTime + peace));
   EXPECT_EQ("",
             service_->Assess(extension_b_,
                              f.get(),
                              &args,
                              kStartTime + peace + TimeDelta::FromSeconds(10)));
   EXPECT_NE("",
             service_->Assess(extension_b_,
                              f.get(),
                              &args2,
                              kStartTime + peace + TimeDelta::FromSeconds(15)));
 
   // Test that items are independent.
-  ListValue args3;
+  base::ListValue args3;
   args3.Append(new base::FundamentalValue(3));
   EXPECT_EQ("", service_->Assess(extension_c_, f.get(), &args, kStartTime));
   EXPECT_EQ("",
             service_->Assess(extension_c_,
                              f.get(),
                              &args3,
                              kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_EQ("",
             service_->Assess(extension_c_,
                              f.get(),
@@ skipping 11 matching lines @@
                              kStartTime + TimeDelta::FromSeconds(25)));
   EXPECT_NE("",
             service_->Assess(extension_c_,
                              f.get(),
                              &args3,
                              kStartTime + TimeDelta::FromSeconds(30)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
   scoped_refptr<MockFunction> f(new ChainedLimitsMockFunction("foo"));
-  ListValue args;
+  base::ListValue args;
   args.Append(new base::FundamentalValue(1));
 
   // First, test that the low limit can be avoided but the higher one is hit.
   // One event per minute for 20 minutes comes in under the sustained limit,
   // but is equal to the timed limit.
   for (int i = 0; i < 20; i++) {
     EXPECT_EQ(
         "",
         service_->Assess(extension_a_,
                          f.get(),
@@ skipping 34 matching lines @@
             service_->Assess(extension_b_,
                              f.get(),
                              &args,
                              kStartTime + TimeDelta::FromMinutes(6)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, MultipleFunctionsDontInterfere) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
 
-  ListValue args_f;
-  ListValue args_g;
+  base::ListValue args_f;
+  base::ListValue args_g;
   args_f.Append(new base::FundamentalValue(1));
   args_g.Append(new base::FundamentalValue(2));
 
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args_f, kStartTime));
   EXPECT_EQ("", service_->Assess(extension_a_, g.get(), &args_g, kStartTime));
   EXPECT_EQ("",
             service_->Assess(extension_a_,
                              f.get(),
                              &args_f,
                              kStartTime + TimeDelta::FromSeconds(10)));
@@ skipping 10 matching lines @@
   EXPECT_NE("",
             service_->Assess(extension_a_,
                              g.get(),
                              &args_g,
                              kStartTime + TimeDelta::FromSeconds(15)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ViolatorsWillBeViolators) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
-  ListValue arg;
+  base::ListValue arg;
   arg.Append(new base::FundamentalValue(1));
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &arg, kStartTime));
   EXPECT_EQ("",
             service_->Assess(extension_a_,
                              f.get(),
                              &arg,
                              kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_NE("",
             service_->Assess(extension_a_,
                              f.get(),
                              &arg,
                              kStartTime + TimeDelta::FromSeconds(15)));
 
   // We don't allow this extension to use quota limited functions even if they
   // wait a while.
   EXPECT_NE(
       "",
       service_->Assess(
           extension_a_, f.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
   EXPECT_NE(
       "",
       service_->Assess(
           extension_a_, g.get(), &arg, kStartTime + TimeDelta::FromDays(1)));
 }