Remove more CreateIntegerValue calls.

components/policy/core/common/policy_service_impl_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 "components/policy/core/common/policy_service_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 56 matching lines @@
 class ChangePolicyObserver : public PolicyService::Observer {
  public:
   explicit ChangePolicyObserver(MockConfigurationPolicyProvider* provider)
       : provider_(provider),
         observer_invoked_(false) {}
 
   virtual void OnPolicyUpdated(const PolicyNamespace&,
                                const PolicyMap& previous,
                                const PolicyMap& current) OVERRIDE {
     PolicyMap new_policy;
-    new_policy.Set("foo", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                   base::Value::CreateIntegerValue(14), NULL);
+    new_policy.Set("foo",
+                   POLICY_LEVEL_MANDATORY,
+                   POLICY_SCOPE_USER,
+                   new base::FundamentalValue(14),
+                   NULL);
     provider_->UpdateChromePolicy(new_policy);
     observer_invoked_ = true;
   }
 
   bool observer_invoked() const { return observer_invoked_; }
 
  private:
   MockConfigurationPolicyProvider* provider_;
   bool observer_invoked_;
 };
 
 }  // namespace
 
 class PolicyServiceTest : public testing::Test {
  public:
   PolicyServiceTest() {}
   virtual void SetUp() OVERRIDE {
     EXPECT_CALL(provider0_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     EXPECT_CALL(provider1_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     EXPECT_CALL(provider2_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
 
     provider0_.Init();
     provider1_.Init();
     provider2_.Init();
 
-    policy0_.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                 base::Value::CreateIntegerValue(13), NULL);
+    policy0_.Set("pre",
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 new base::FundamentalValue(13),
+                 NULL);
     provider0_.UpdateChromePolicy(policy0_);
 
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider0_);
     providers.push_back(&provider1_);
     providers.push_back(&provider2_);
     policy_service_.reset(new PolicyServiceImpl(providers));
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 27 matching lines @@
   PolicyMap policy1_;
   PolicyMap policy2_;
   scoped_ptr<PolicyServiceImpl> policy_service_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PolicyServiceTest);
 };
 
 TEST_F(PolicyServiceTest, LoadsPoliciesBeforeProvidersRefresh) {
   PolicyMap expected;
-  expected.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(13), NULL);
+  expected.Set("pre",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(13),
+               NULL);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected));
 }
 
 TEST_F(PolicyServiceTest, NotifyObservers) {
   MockPolicyServiceObserver observer;
   policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &observer);
 
   PolicyMap expectedPrevious;
-  expectedPrevious.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                       base::Value::CreateIntegerValue(13), NULL);
+  expectedPrevious.Set("pre",
+                       POLICY_LEVEL_MANDATORY,
+                       POLICY_SCOPE_USER,
+                       new base::FundamentalValue(13),
+                       NULL);
 
   PolicyMap expectedCurrent;
   expectedCurrent.CopyFrom(expectedPrevious);
-  expectedCurrent.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                      base::Value::CreateIntegerValue(123), NULL);
-  policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(123), NULL);
+  expectedCurrent.Set("aaa",
+                      POLICY_LEVEL_MANDATORY,
+                      POLICY_SCOPE_USER,
+                      new base::FundamentalValue(123),
+                      NULL);
+  policy0_.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(123),
+               NULL);
   EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME,
                                                         std::string()),
                                         PolicyEquals(&expectedPrevious),
                                         PolicyEquals(&expectedCurrent)));
   provider0_.UpdateChromePolicy(policy0_);
   Mock::VerifyAndClearExpectations(&observer);
 
   // No changes.
   EXPECT_CALL(observer, OnPolicyUpdated(_, _, _)).Times(0);
   provider0_.UpdateChromePolicy(policy0_);
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expectedCurrent));
 
   // New policy.
   expectedPrevious.CopyFrom(expectedCurrent);
-  expectedCurrent.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                      base::Value::CreateIntegerValue(456), NULL);
-  policy0_.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(456), NULL);
+  expectedCurrent.Set("bbb",
+                      POLICY_LEVEL_MANDATORY,
+                      POLICY_SCOPE_USER,
+                      new base::FundamentalValue(456),
+                      NULL);
+  policy0_.Set("bbb",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(456),
+               NULL);
   EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME,
                                                         std::string()),
                                         PolicyEquals(&expectedPrevious),
                                         PolicyEquals(&expectedCurrent)));
   provider0_.UpdateChromePolicy(policy0_);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Removed policy.
   expectedPrevious.CopyFrom(expectedCurrent);
   expectedCurrent.Erase("bbb");
   policy0_.Erase("bbb");
   EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME,
                                                         std::string()),
                                         PolicyEquals(&expectedPrevious),
                                         PolicyEquals(&expectedCurrent)));
   provider0_.UpdateChromePolicy(policy0_);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Changed policy.
   expectedPrevious.CopyFrom(expectedCurrent);
-  expectedCurrent.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                      base::Value::CreateIntegerValue(789), NULL);
-  policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(789), NULL);
+  expectedCurrent.Set("aaa",
+                      POLICY_LEVEL_MANDATORY,
+                      POLICY_SCOPE_USER,
+                      new base::FundamentalValue(789),
+                      NULL);
+  policy0_.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(789),
+               NULL);
 
   EXPECT_CALL(observer, OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_CHROME,
                                                         std::string()),
                                         PolicyEquals(&expectedPrevious),
                                         PolicyEquals(&expectedCurrent)));
   provider0_.UpdateChromePolicy(policy0_);
   Mock::VerifyAndClearExpectations(&observer);
 
   // No changes again.
   EXPECT_CALL(observer, OnPolicyUpdated(_, _, _)).Times(0);
   provider0_.UpdateChromePolicy(policy0_);
   Mock::VerifyAndClearExpectations(&observer);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expectedCurrent));
 
   policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
 }
 
 TEST_F(PolicyServiceTest, NotifyObserversInMultipleNamespaces) {
   const std::string kExtension0("extension-0");
   const std::string kExtension1("extension-1");
   const std::string kExtension2("extension-2");
   MockPolicyServiceObserver chrome_observer;
   MockPolicyServiceObserver extension_observer;
   policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &chrome_observer);
   policy_service_->AddObserver(POLICY_DOMAIN_EXTENSIONS, &extension_observer);
 
   PolicyMap previous_policy_map;
-  previous_policy_map.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                          base::Value::CreateIntegerValue(13), NULL);
+  previous_policy_map.Set("pre",
+                          POLICY_LEVEL_MANDATORY,
+                          POLICY_SCOPE_USER,
+                          new base::FundamentalValue(13),
+                          NULL);
   PolicyMap policy_map;
   policy_map.CopyFrom(previous_policy_map);
   policy_map.Set("policy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  base::Value::CreateStringValue("value"), NULL);
 
   scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
   // The initial setup includes a policy for chrome that is now changing.
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension0))
@@ skipping 57 matching lines @@
   Mock::VerifyAndClearExpectations(&extension_observer);
 
   policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &chrome_observer);
   policy_service_->RemoveObserver(POLICY_DOMAIN_EXTENSIONS,
                                   &extension_observer);
 }
 
 TEST_F(PolicyServiceTest, ObserverChangesPolicy) {
   ChangePolicyObserver observer(&provider0_);
   policy_service_->AddObserver(POLICY_DOMAIN_CHROME, &observer);
-  policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(123), NULL);
-  policy0_.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(1234), NULL);
+  policy0_.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(123),
+               NULL);
+  policy0_.Set("bbb",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(1234),
+               NULL);
   // Should not crash.
   provider0_.UpdateChromePolicy(policy0_);
   policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, &observer);
   EXPECT_TRUE(observer.observer_invoked());
 }
 
 TEST_F(PolicyServiceTest, Priorities) {
   PolicyMap expected;
-  expected.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(13), NULL);
-  expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(0), NULL);
-  policy0_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(0), NULL);
-  policy1_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(1), NULL);
-  policy2_.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(2), NULL);
+  expected.Set("pre",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(13),
+               NULL);
+  expected.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(0),
+               NULL);
+  policy0_.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(0),
+               NULL);
+  policy1_.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(1),
+               NULL);
+  policy2_.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(2),
+               NULL);
   provider0_.UpdateChromePolicy(policy0_);
   provider1_.UpdateChromePolicy(policy1_);
   provider2_.UpdateChromePolicy(policy2_);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected));
 
-  expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(1), NULL);
+  expected.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(1),
+               NULL);
   policy0_.Erase("aaa");
   provider0_.UpdateChromePolicy(policy0_);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected));
 
-  expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(2), NULL);
-  policy1_.Set("aaa", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(1), NULL);
+  expected.Set("aaa",
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(2),
+               NULL);
+  policy1_.Set("aaa",
+               POLICY_LEVEL_RECOMMENDED,
+               POLICY_SCOPE_USER,
+               new base::FundamentalValue(1),
+               NULL);
   provider1_.UpdateChromePolicy(policy1_);
   EXPECT_TRUE(VerifyPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()), expected));
 }
 
 TEST_F(PolicyServiceTest, PolicyChangeRegistrar) {
   scoped_ptr<PolicyChangeRegistrar> registrar(new PolicyChangeRegistrar(
       policy_service_.get(),
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())));
 
@@ skipping 228 matching lines @@
 }
 
 TEST_F(PolicyServiceTest, FixDeprecatedPolicies) {
   const PolicyNamespace chrome_namespace(POLICY_DOMAIN_CHROME, std::string());
   const PolicyNamespace extension_namespace(POLICY_DOMAIN_EXTENSIONS, "xyz");
 
   scoped_ptr<PolicyBundle> policy_bundle(new PolicyBundle());
   PolicyMap& policy_map = policy_bundle->Get(chrome_namespace);
   // Individual proxy policy values in the Chrome namespace should be collected
   // into a dictionary.
-  policy_map.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
-                 POLICY_SCOPE_USER, base::Value::CreateIntegerValue(3), NULL);
+  policy_map.Set(key::kProxyServerMode,
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 new base::FundamentalValue(3),
+                 NULL);
 
   // Both these policies should be ignored, since there's a higher priority
   // policy available.
   policy_map.Set(key::kProxyMode, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
                  base::Value::CreateStringValue("pac_script"), NULL);
   policy_map.Set(key::kProxyPacUrl, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
                  base::Value::CreateStringValue("http://example.com/wpad.dat"),
                  NULL);
 
   // Add a value to a non-Chrome namespace.
-  policy_bundle->Get(extension_namespace)
-      .Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-           base::Value::CreateIntegerValue(3), NULL);
+  policy_bundle->Get(extension_namespace).Set(key::kProxyServerMode,
+                                              POLICY_LEVEL_MANDATORY,
+                                              POLICY_SCOPE_USER,
+                                              new base::FundamentalValue(3),
+                                              NULL);
 
   // The resulting Chrome namespace map should have the collected policy.
   PolicyMap expected_chrome;
   scoped_ptr<base::DictionaryValue> expected_value(new base::DictionaryValue);
   expected_value->SetInteger(key::kProxyServerMode, 3);
   expected_chrome.Set(key::kProxySettings, POLICY_LEVEL_MANDATORY,
                       POLICY_SCOPE_USER, expected_value.release(), NULL);
 
   // The resulting Extensions namespace map shouldn't have been modified.
   PolicyMap expected_extension;
-  expected_extension.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY,
-                         POLICY_SCOPE_USER, base::Value::CreateIntegerValue(3),
+  expected_extension.Set(key::kProxyServerMode,
+                         POLICY_LEVEL_MANDATORY,
+                         POLICY_SCOPE_USER,
+                         new base::FundamentalValue(3),
                          NULL);
 
   provider0_.UpdatePolicy(policy_bundle.Pass());
   RunUntilIdle();
 
   EXPECT_TRUE(VerifyPolicies(chrome_namespace, expected_chrome));
   EXPECT_TRUE(VerifyPolicies(extension_namespace, expected_extension));
 }
 
 }  // namespace policy