Get rid of the rest of CreateStringValue

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 31 matching lines @@
   return base::Value::Equals(arg, expected);
 }
 
 // Helper that fills |bundle| with test policies.
 void AddTestPolicies(PolicyBundle* bundle,
                      const char* value,
                      PolicyLevel level,
                      PolicyScope scope) {
   PolicyMap* policy_map =
       &bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
-  policy_map->Set(kSameLevelPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                  base::Value::CreateStringValue(value), NULL);
-  policy_map->Set(kDiffLevelPolicy, level, scope,
-                  base::Value::CreateStringValue(value), NULL);
+  policy_map->Set(kSameLevelPolicy,
+                  POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_USER,
+                  new base::StringValue(value),
+                  NULL);
+  policy_map->Set(
+      kDiffLevelPolicy, level, scope, new base::StringValue(value), NULL);
   policy_map =
       &bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension));
-  policy_map->Set(kSameLevelPolicy, POLICY_LEVEL_MANDATORY,
-                  POLICY_SCOPE_USER, base::Value::CreateStringValue(value),
+  policy_map->Set(kSameLevelPolicy,
+                  POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_USER,
+                  new base::StringValue(value),
                   NULL);
-  policy_map->Set(kDiffLevelPolicy, level, scope,
-                  base::Value::CreateStringValue(value), NULL);
+  policy_map->Set(
+      kDiffLevelPolicy, level, scope, new base::StringValue(value), NULL);
 }
 
 // Observer class that changes the policy in the passed provider when the
 // callback is invoked.
 class ChangePolicyObserver : public PolicyService::Observer {
  public:
   explicit ChangePolicyObserver(MockConfigurationPolicyProvider* provider)
       : provider_(provider),
         observer_invoked_(false) {}
 
@@ skipping 169 matching lines @@
   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);
   PolicyMap policy_map;
   policy_map.CopyFrom(previous_policy_map);
-  policy_map.Set("policy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                 base::Value::CreateStringValue("value"), NULL);
+  policy_map.Set("policy",
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 new base::StringValue("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))
       .CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1))
       .CopyFrom(policy_map);
 
@@ skipping 17 matching lines @@
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&chrome_observer);
   Mock::VerifyAndClearExpectations(&extension_observer);
 
   // Chrome policy stays the same, kExtension0 is gone, kExtension1 changes,
   // and kExtension2 is new.
   previous_policy_map.CopyFrom(policy_map);
   bundle.reset(new PolicyBundle());
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(policy_map);
-  policy_map.Set("policy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                 base::Value::CreateStringValue("another value"), NULL);
+  policy_map.Set("policy",
+                 POLICY_LEVEL_MANDATORY,
+                 POLICY_SCOPE_USER,
+                 new base::StringValue("another value"),
+                 NULL);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension1))
       .CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension2))
       .CopyFrom(policy_map);
 
   EXPECT_CALL(chrome_observer, OnPolicyUpdated(_, _, _)).Times(0);
   EXPECT_CALL(
       extension_observer,
       OnPolicyUpdated(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension0),
                       PolicyEquals(&previous_policy_map),
@@ skipping 201 matching lines @@
                   POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
 
   provider0_.UpdatePolicy(bundle0.Pass());
   provider1_.UpdatePolicy(bundle1.Pass());
   provider2_.UpdatePolicy(bundle2.Pass());
   RunUntilIdle();
 
   PolicyMap expected;
   // For policies of the same level and scope, the first provider takes
   // precedence, on every namespace.
-  expected.Set(kSameLevelPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateStringValue("bundle0"), NULL);
+  expected.Set(kSameLevelPolicy,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_USER,
+               new base::StringValue("bundle0"),
+               NULL);
   // For policies with different levels and scopes, the highest priority
   // level/scope combination takes precedence, on every namespace.
-  expected.Set(kDiffLevelPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-               base::Value::CreateStringValue("bundle2"), NULL);
+  expected.Set(kDiffLevelPolicy,
+               POLICY_LEVEL_MANDATORY,
+               POLICY_SCOPE_MACHINE,
+               new base::StringValue("bundle2"),
+               NULL);
   EXPECT_TRUE(policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())).Equals(expected));
   EXPECT_TRUE(policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension)).Equals(expected));
 }
 
 TEST_F(PolicyServiceTest, IsInitializationComplete) {
   // |provider0| has all domains initialized.
   Mock::VerifyAndClearExpectations(&provider1_);
   Mock::VerifyAndClearExpectations(&provider2_);
@@ skipping 79 matching lines @@
 
   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);
 
   // 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"),
+  policy_map.Set(key::kProxyMode,
+                 POLICY_LEVEL_RECOMMENDED,
+                 POLICY_SCOPE_USER,
+                 new base::StringValue("pac_script"),
+                 NULL);
+  policy_map.Set(key::kProxyPacUrl,
+                 POLICY_LEVEL_RECOMMENDED,
+                 POLICY_SCOPE_USER,
+                 new base::StringValue("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);
 
   // 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),
                          NULL);
 
   provider0_.UpdatePolicy(policy_bundle.Pass());
   RunUntilIdle();
 
   EXPECT_TRUE(VerifyPolicies(chrome_namespace, expected_chrome));
   EXPECT_TRUE(VerifyPolicies(extension_namespace, expected_extension));
 }
 
 }  // namespace policy