Remove deprecated wstring Get(As)String() methods from Value, etc.

chrome/browser/dom_ui/core_options_handler.cc

 // Copyright (c) 2010 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/dom_ui/core_options_handler.h"
 
 #include "app/l10n_util.h"
+#include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
@@ skipping 145 matching lines @@
   // one more element for the actual preference identifier.
   const size_t kMinFetchPrefsParamCount = 2;
   if (param_values->GetSize() < kMinFetchPrefsParamCount)
     return;
 
   // Get callback JS function name.
   Value* callback;
   if (!param_values->Get(0, &callback) || !callback->IsType(Value::TYPE_STRING))
     return;
 
-  std::wstring callback_function;
+  string16 callback_function;
   if (!callback->GetAsString(&callback_function))
     return;
 
   // Get the list of name for prefs to build the response dictionary.
   DictionaryValue result_value;
   Value* list_member;
 
   for (size_t i = 1; i < param_values->GetSize(); i++) {
     if (!param_values->Get(i, &list_member))
       break;
 
     if (!list_member->IsType(Value::TYPE_STRING))
       continue;
 
     std::string pref_name;
     if (!list_member->GetAsString(&pref_name))
       continue;
 
     result_value.Set(pref_name.c_str(), FetchPref(pref_name));
   }
-  dom_ui_->CallJavascriptFunction(callback_function.c_str(), result_value);
+  dom_ui_->CallJavascriptFunction(UTF16ToWideHack(callback_function).c_str(),
+                                  result_value);
 }
 
 void CoreOptionsHandler::HandleObservePrefs(const Value* value) {
   if (!value || !value->IsType(Value::TYPE_LIST))
     return;
 
   DictionaryValue result_value;
   const ListValue* list_value = static_cast<const ListValue*>(value);
 
   // First param is name is JS callback function name, the rest are pref
   // identifiers that we are observing.
   const size_t kMinObservePrefsParamCount = 2;
   if (list_value->GetSize() < kMinObservePrefsParamCount)
     return;
 
   // Get preference change callback function name.
-  std::wstring callback_func_name;
+  string16 callback_func_name;
   if (!list_value->GetString(0, &callback_func_name))
     return;
 
   // Get all other parameters - pref identifiers.
   for (size_t i = 1; i < list_value->GetSize(); i++) {
     Value* list_member;
     if (!list_value->Get(i, &list_member))
       break;
 
     // Just ignore bad pref identifiers for now.
     std::string pref_name;
     if (!list_member->IsType(Value::TYPE_STRING) ||
         !list_member->GetAsString(&pref_name))
       continue;
 
     if (pref_callback_map_.find(pref_name) == pref_callback_map_.end())
       ObservePref(pref_name);
 
     pref_callback_map_.insert(
-        PreferenceCallbackMap::value_type(pref_name, callback_func_name));
+        PreferenceCallbackMap::value_type(pref_name,
+                                          UTF16ToWideHack(callback_func_name)));
   }
 }
 
 void CoreOptionsHandler::HandleSetBooleanPref(const Value* value) {
   HandleSetPref(value, Value::TYPE_BOOLEAN);
 }
 
 void CoreOptionsHandler::HandleSetIntegerPref(const Value* value) {
   HandleSetPref(value, Value::TYPE_INTEGER);
 }
@@ skipping 36 matching lines @@
         pref_callback_map_.find(*pref_name);
         iter != pref_callback_map_.end(); ++iter) {
       const std::wstring& callback_function = iter->second;
       ListValue result_value;
       result_value.Append(Value::CreateStringValue(pref_name->c_str()));
       result_value.Append(pref->GetValue()->DeepCopy());
       dom_ui_->CallJavascriptFunction(callback_function, result_value);
     }
   }
 }