base: Remove using declaration of FundamentalValue as it's no longer necessary.

chrome/browser/extensions/extensions_quota_service_unittest.cc

 // Copyright (c) 2011 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/stl_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 183 matching lines @@
 
 TEST_F(ExtensionsQuotaServiceTest, NoHeuristic) {
   scoped_refptr<MockFunction> f(new MockFunction("foo"));
   ListValue args;
   EXPECT_TRUE(service_->Assess(extension_a_, f, &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, FrozenHeuristic) {
   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
   ListValue args;
-  args.Append(new FundamentalValue(1));
+  args.Append(new base::FundamentalValue(1));
   EXPECT_FALSE(service_->Assess(extension_a_, f, &args, kStartTime));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, SingleHeuristic) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   ListValue args;
-  args.Append(new FundamentalValue(1));
+  args.Append(new base::FundamentalValue(1));
   EXPECT_TRUE(service_->Assess(extension_a_, f, &args, kStartTime));
   EXPECT_TRUE(service_->Assess(extension_a_, f, &args,
               kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_FALSE(service_->Assess(extension_a_, f, &args,
               kStartTime + TimeDelta::FromSeconds(15)));
 
   ListValue args2;
-  args2.Append(new FundamentalValue(1));
-  args2.Append(new FundamentalValue(2));
+  args2.Append(new base::FundamentalValue(1));
+  args2.Append(new base::FundamentalValue(2));
   EXPECT_TRUE(service_->Assess(extension_b_, f, &args2, kStartTime));
   EXPECT_TRUE(service_->Assess(extension_b_, f, &args2,
               kStartTime + TimeDelta::FromSeconds(10)));
 
   TimeDelta peace = TimeDelta::FromMinutes(30);
   EXPECT_TRUE(service_->Assess(extension_b_, f, &args, kStartTime + peace));
   EXPECT_TRUE(service_->Assess(extension_b_, f, &args,
               kStartTime + peace + TimeDelta::FromSeconds(10)));
   EXPECT_FALSE(service_->Assess(extension_b_, f, &args2,
                kStartTime + peace + TimeDelta::FromSeconds(15)));
 
   // Test that items are independent.
   ListValue args3;
-  args3.Append(new FundamentalValue(3));
+  args3.Append(new base::FundamentalValue(3));
   EXPECT_TRUE(service_->Assess(extension_c_, f, &args, kStartTime));
   EXPECT_TRUE(service_->Assess(extension_c_, f, &args3,
               kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_TRUE(service_->Assess(extension_c_, f, &args,
               kStartTime + TimeDelta::FromSeconds(15)));
   EXPECT_TRUE(service_->Assess(extension_c_, f, &args3,
               kStartTime + TimeDelta::FromSeconds(20)));
   EXPECT_FALSE(service_->Assess(extension_c_, f, &args,
                kStartTime + TimeDelta::FromSeconds(25)));
   EXPECT_FALSE(service_->Assess(extension_c_, f, &args3,
                kStartTime + TimeDelta::FromSeconds(30)));
 }
 
 TEST_F(ExtensionsQuotaServiceTest, ChainedHeuristics) {
   scoped_refptr<MockFunction> f(new ChainedLimitsMockFunction("foo"));
   ListValue args;
-  args.Append(new FundamentalValue(1));
+  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_TRUE(service_->Assess(extension_a_, f, &args,
                 kStartTime + TimeDelta::FromSeconds(10 + i * 60)));
   }
 
   // This will bring us to 21 events in an hour, which is a violation.
@@ skipping 13 matching lines @@
   EXPECT_FALSE(service_->Assess(extension_b_, f, &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;
-  args_f.Append(new FundamentalValue(1));
-  args_g.Append(new FundamentalValue(2));
+  args_f.Append(new base::FundamentalValue(1));
+  args_g.Append(new base::FundamentalValue(2));
 
   EXPECT_TRUE(service_->Assess(extension_a_, f, &args_f, kStartTime));
   EXPECT_TRUE(service_->Assess(extension_a_, g, &args_g, kStartTime));
   EXPECT_TRUE(service_->Assess(extension_a_, f, &args_f,
               kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_TRUE(service_->Assess(extension_a_, g, &args_g,
               kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_FALSE(service_->Assess(extension_a_, f, &args_f,
                kStartTime + TimeDelta::FromSeconds(15)));
   EXPECT_FALSE(service_->Assess(extension_a_, g, &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;
-  arg.Append(new FundamentalValue(1));
+  arg.Append(new base::FundamentalValue(1));
   EXPECT_TRUE(service_->Assess(extension_a_, f, &arg, kStartTime));
   EXPECT_TRUE(service_->Assess(extension_a_, f, &arg,
               kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_FALSE(service_->Assess(extension_a_, f, &arg,
                kStartTime + TimeDelta::FromSeconds(15)));
 
   // We don't allow this extension to use quota limited functions even if they
   // wait a while.
   EXPECT_FALSE(service_->Assess(extension_a_, f, &arg,
                kStartTime + TimeDelta::FromDays(1)));
   EXPECT_FALSE(service_->Assess(extension_a_, g, &arg,
                kStartTime + TimeDelta::FromDays(1)));
 }