Remove ListValue::Append(new {Fundamental,String}Value(...)) pattern in //extensions

extensions/browser/quota_service_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
@@ skipping 162 matching lines @@
 
 TEST_F(QuotaServiceTest, NoHeuristic) {
   scoped_refptr<MockFunction> f(new MockFunction("foo"));
   base::ListValue args;
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
 TEST_F(QuotaServiceTest, FrozenHeuristic) {
   scoped_refptr<MockFunction> f(new FrozenMockFunction("foo"));
   base::ListValue args;
-  args.Append(new base::FundamentalValue(1));
+  args.AppendInteger(1);
   EXPECT_NE("", service_->Assess(extension_a_, f.get(), &args, kStartTime));
 }
 
 TEST_F(QuotaServiceTest, SingleHeuristic) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   base::ListValue args;
-  args.Append(new base::FundamentalValue(1));
+  args.AppendInteger(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)));
 
   base::ListValue args2;
-  args2.Append(new base::FundamentalValue(1));
-  args2.Append(new base::FundamentalValue(2));
+  args2.AppendInteger(1);
+  args2.AppendInteger(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.
   base::ListValue args3;
-  args3.Append(new base::FundamentalValue(3));
+  args3.AppendInteger(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(),
                              &args,
@@ skipping 14 matching lines @@
                              &args3,
                              kStartTime + TimeDelta::FromSeconds(30)));
 }
 
 TEST_F(QuotaServiceTest, MultipleFunctionsDontInterfere) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   scoped_refptr<MockFunction> g(new TimedLimitMockFunction("bar"));
 
   base::ListValue args_f;
   base::ListValue args_g;
-  args_f.Append(new base::FundamentalValue(1));
-  args_g.Append(new base::FundamentalValue(2));
+  args_f.AppendInteger(1);
+  args_g.AppendInteger(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)));
   EXPECT_EQ("",
             service_->Assess(extension_a_,
                              g.get(),
                              &args_g,
                              kStartTime + TimeDelta::FromSeconds(10)));
   EXPECT_NE("",
             service_->Assess(extension_a_,
                              f.get(),
                              &args_f,
                              kStartTime + TimeDelta::FromSeconds(15)));
   EXPECT_NE("",
             service_->Assess(extension_a_,
                              g.get(),
                              &args_g,
                              kStartTime + TimeDelta::FromSeconds(15)));
 }
 
 TEST_F(QuotaServiceTest, ViolatorsWillBeForgiven) {
   scoped_refptr<MockFunction> f(new TimedLimitMockFunction("foo"));
   base::ListValue arg;
-  arg.Append(new base::FundamentalValue(1));
+  arg.AppendInteger(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,
@@ skipping 19 matching lines @@
   EXPECT_NE("", service_->Assess(extension_a_, f.get(), &arg,
                                  kStartTime + TimeDelta::FromDays(1) +
                                      TimeDelta::FromSeconds(25)));
 
   // Like now.
   EXPECT_EQ("", service_->Assess(extension_a_, f.get(), &arg,
                                  kStartTime + TimeDelta::FromDays(2)));
 }
 
 }  // namespace extensions