webui/options: Do not use Value::CreateStringValue.

chrome/browser/ui/webui/options/preferences_browsertest.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 "chrome/browser/ui/webui/options/preferences_browsertest.h"
 
 #include <iostream>
 #include <sstream>
 
 #include "base/json/json_reader.h"
@@ skipping 183 matching lines @@
   policy_provider_.UpdateChromePolicy(empty_policy_map);
 }
 
 void PreferencesBrowserTest::SetUserValues(
     const std::vector<std::string>& names,
     const std::vector<base::Value*>& values) {
   for (size_t i = 0; i < names.size(); ++i)
     pref_service_->Set(names[i].c_str(), *values[i]);
 }
 
-void PreferencesBrowserTest::VerifyKeyValue(const base::DictionaryValue* dict,
+void PreferencesBrowserTest::VerifyKeyValue(const base::DictionaryValue& dict,
                                             const std::string& key,
-                                            base::Value* expected) {
+                                            const base::Value& expected) {
   const base::Value* actual = NULL;
-  EXPECT_TRUE(dict->Get(key, &actual)) << "Was checking key: " << key;
-  EXPECT_EQ(*expected, *actual) << "Was checking key: " << key;
-  delete expected;
+  EXPECT_TRUE(dict.Get(key, &actual)) << "Was checking key: " << key;
+  EXPECT_EQ(expected, *actual) << "Was checking key: " << key;
 }
 
 void PreferencesBrowserTest::VerifyPref(const base::DictionaryValue* prefs,
                                         const std::string& name,
                                         const base::Value* value,
                                         const std::string& controlledBy,
                                         bool disabled,
                                         bool uncommitted) {
   const base::Value* pref;
   const base::DictionaryValue* dict;
   ASSERT_TRUE(prefs->GetWithoutPathExpansion(name, &pref));
   ASSERT_TRUE(pref->GetAsDictionary(&dict));
-  VerifyKeyValue(dict, "value", value->DeepCopy());
+  VerifyKeyValue(*dict, "value", *value);
   if (!controlledBy.empty()) {
-    VerifyKeyValue(dict, "controlledBy",
-                   base::Value::CreateStringValue(controlledBy));
+    VerifyKeyValue(*dict, "controlledBy", base::StringValue(controlledBy));
   } else {
     EXPECT_FALSE(dict->HasKey("controlledBy"));
   }
   if (disabled)
-    VerifyKeyValue(dict, "disabled", base::Value::CreateBooleanValue(true));
+    VerifyKeyValue(*dict, "disabled", base::FundamentalValue(true));
   else if (dict->HasKey("disabled"))
-    VerifyKeyValue(dict, "disabled", base::Value::CreateBooleanValue(false));
+    VerifyKeyValue(*dict, "disabled", base::FundamentalValue(false));
   if (uncommitted)
-    VerifyKeyValue(dict, "uncommitted", base::Value::CreateBooleanValue(true));
+    VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(true));
   else if (dict->HasKey("uncommitted"))
-    VerifyKeyValue(dict, "uncommitted", base::Value::CreateBooleanValue(false));
+    VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(false));
 }
 
 void PreferencesBrowserTest::VerifyObservedPref(const std::string& json,
                                                 const std::string& name,
                                                 const base::Value* value,
                                                 const std::string& controlledBy,
                                                 bool disabled,
                                                 bool uncommitted) {
   scoped_ptr<base::Value> observed_value_ptr(base::JSONReader::Read(json));
   const base::DictionaryValue* observed_dict;
@@ skipping 71 matching lines @@
 }
 
 void PreferencesBrowserTest::VerifySetPref(const std::string& name,
                                            const std::string& type,
                                            const base::Value* value,
                                            bool commit) {
   if (commit)
     ExpectSetCommit(name, value);
   else
     ExpectNoCommit(name);
-  scoped_ptr<base::Value> commit_ptr(base::Value::CreateBooleanValue(commit));
+  scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::string value_json;
   std::string commit_json;
   base::JSONWriter::Write(value, &value_json);
   base::JSONWriter::Write(commit_ptr.get(), &commit_json);
   std::wstringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.set" << type.c_str() << "Pref("
              << "      '" << name.c_str() << "',"
              << "      " << value_json.c_str() << ","
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
       render_view_host_, L"", javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, "", false, !commit);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyClearPref(const std::string& name,
                                              const base::Value* value,
                                              bool commit) {
   if (commit)
     ExpectClearCommit(name);
   else
     ExpectNoCommit(name);
-  scoped_ptr<base::Value> commit_ptr(base::Value::CreateBooleanValue(commit));
+  scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::string commit_json;
   base::JSONWriter::Write(commit_ptr.get(), &commit_json);
   std::wstringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.clearPref("
              << "      '" << name.c_str() << "',"
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
       render_view_host_, L"", javascript.str(), &observed_json));
@@ skipping 52 matching lines @@
   ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
       render_view_host_, L"", L"testEnv.finishObservingAndReply();",
       observed_json));
 }
 
 void PreferencesBrowserTest::UseDefaultTestPrefs(bool includeListPref) {
   // Boolean pref.
   types_.push_back("Boolean");
   pref_names_.push_back(prefs::kAlternateErrorPagesEnabled);
   policy_names_.push_back(policy::key::kAlternateErrorPagesEnabled);
-  non_default_values_.push_back(base::Value::CreateBooleanValue(false));
+  non_default_values_.push_back(new base::FundamentalValue(false));
 
   // Integer pref.
   types_.push_back("Integer");
   pref_names_.push_back(prefs::kRestoreOnStartup);
   policy_names_.push_back(policy::key::kRestoreOnStartup);
-  non_default_values_.push_back(base::Value::CreateIntegerValue(4));
+  non_default_values_.push_back(new base::FundamentalValue(4));
 
   // String pref.
   types_.push_back("String");
   pref_names_.push_back(prefs::kEnterpriseWebStoreName);
   policy_names_.push_back(policy::key::kEnterpriseWebStoreName);
-  non_default_values_.push_back(base::Value::CreateStringValue("Store"));
+  non_default_values_.push_back(new base::StringValue("Store"));
 
   // URL pref.
   types_.push_back("URL");
   pref_names_.push_back(prefs::kEnterpriseWebStoreURL);
   policy_names_.push_back(policy::key::kEnterpriseWebStoreURL);
   non_default_values_.push_back(
-      base::Value::CreateStringValue("http://www.google.com/"));
+      new base::StringValue("http://www.google.com/"));
 
   // List pref.
   if (includeListPref) {
     types_.push_back("List");
     pref_names_.push_back(prefs::kURLsToRestoreOnStartup);
     policy_names_.push_back(policy::key::kRestoreOnStartupURLs);
     base::ListValue* list = new base::ListValue;
-    list->Append(base::Value::CreateStringValue("http://www.google.com"));
-    list->Append(base::Value::CreateStringValue("http://example.com"));
+    list->Append(new base::StringValue("http://www.google.com"));
+    list->Append(new base::StringValue("http://example.com"));
     non_default_values_.push_back(list);
   }
 
   // Retrieve default values.
   for (std::vector<std::string>::const_iterator name = pref_names_.begin();
         name != pref_names_.end(); ++name) {
     default_values_.push_back(
         pref_service_->GetDefaultPrefValue(name->c_str())->DeepCopy());
   }
 }
@@ skipping 169 matching lines @@
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the
 // CoreChromeOSOptionsHandler class.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ChromeOSDeviceFetchPrefs) {
   std::vector<base::Value*> decorated_non_default_values;
   std::string observed_json;
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kAccountsPrefAllowGuest);
-  default_values_.push_back(base::Value::CreateBooleanValue(true));
-  non_default_values_.push_back(base::Value::CreateBooleanValue(false));
+  default_values_.push_back(new base::FundamentalValue(true));
+  non_default_values_.push_back(new base::FundamentalValue(false));
   decorated_non_default_values.push_back(
       non_default_values_.back()->DeepCopy());
 
   // String pref.
   pref_names_.push_back(chromeos::kReleaseChannel);
-  default_values_.push_back(base::Value::CreateStringValue(""));
-  non_default_values_.push_back(
-      base::Value::CreateStringValue("stable-channel"));
+  default_values_.push_back(new base::StringValue(""));
+  non_default_values_.push_back(new base::StringValue("stable-channel"));
   decorated_non_default_values.push_back(
       non_default_values_.back()->DeepCopy());
 
   // List pref.
   pref_names_.push_back(chromeos::kAccountsPrefUsers);
   default_values_.push_back(new base::ListValue);
   base::ListValue* list = new base::ListValue;
-  list->Append(base::Value::CreateStringValue("me@google.com"));
-  list->Append(base::Value::CreateStringValue("you@google.com"));
+  list->Append(new base::StringValue("me@google.com"));
+  list->Append(new base::StringValue("you@google.com"));
   non_default_values_.push_back(list);
   list = new base::ListValue;
   base::DictionaryValue* dict = new base::DictionaryValue;
   dict->SetString("username", "me@google.com");
   dict->SetString("name", "me@google.com");
   dict->SetString("email", "");
   dict->SetBoolean("owner", false);
   list->Append(dict);
   dict = new base::DictionaryValue;
   dict->SetString("username", "you@google.com");
@@ skipping 23 matching lines @@
 }
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the Chrome OS proxy
 // settings parser.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ChromeOSProxyFetchPrefs) {
   std::string observed_json;
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kProxySingle);
-  default_values_.push_back(base::Value::CreateBooleanValue(false));
-  non_default_values_.push_back(base::Value::CreateBooleanValue(true));
+  default_values_.push_back(new base::FundamentalValue(false));
+  non_default_values_.push_back(new base::FundamentalValue(true));
 
   // Integer pref.
   pref_names_.push_back(chromeos::kProxySingleHttpPort);
-  default_values_.push_back(base::Value::CreateStringValue(""));
-  non_default_values_.push_back(base::Value::CreateIntegerValue(8080));
+  default_values_.push_back(new base::StringValue(""));
+  non_default_values_.push_back(new base::FundamentalValue(8080));
 
   // String pref.
   pref_names_.push_back(chromeos::kProxySingleHttp);
-  default_values_.push_back(base::Value::CreateStringValue(""));
-  non_default_values_.push_back(base::Value::CreateStringValue("127.0.0.1"));
+  default_values_.push_back(new base::StringValue(""));
+  non_default_values_.push_back(new base::StringValue("127.0.0.1"));
 
   // List pref.
   pref_names_.push_back(chromeos::kProxyIgnoreList);
   default_values_.push_back(new base::ListValue());
   base::ListValue* list = new base::ListValue();
-  list->Append(base::Value::CreateStringValue("www.google.com"));
-  list->Append(base::Value::CreateStringValue("example.com"));
+  list->Append(new base::StringValue("www.google.com"));
+  list->Append(new base::StringValue("example.com"));
   non_default_values_.push_back(list);
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, default_values_,
                       "", false, false);
 
   // Verify notifications when user-modified values are in effect.
   Profile* profile = browser()->profile();
   // Do not set the Boolean pref. It will toogle automatically.
   for (size_t i = 1; i < pref_names_.size(); ++i)
     chromeos::proxy_cros_settings_parser::SetProxyPrefValue(
         profile, pref_names_[i], non_default_values_[i]->DeepCopy());
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "", false, false);
 }
 
 #endif