Rename GetStringAsUTF16() to GetString() (and overload), etc.

chrome/browser/geolocation/network_location_provider_unittest.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/geolocation/network_location_provider.h"
 
 #include "base/json/json_reader.h"
 #include "base/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 159 matching lines @@
   static void ParseRequest(const std::string& request_data,
                            WifiData* wifi_data_out,
                            int* max_age_out,
                            std::string* access_token_out) {
     CHECK(wifi_data_out && max_age_out && access_token_out);
     scoped_ptr<Value> value(base::JSONReader::Read(request_data, false));
     EXPECT_TRUE(value != NULL);
     EXPECT_EQ(Value::TYPE_DICTIONARY, value->GetType());
     DictionaryValue* dictionary = static_cast<DictionaryValue*>(value.get());
     std::string attr_value;
-    EXPECT_TRUE(dictionary->GetString(L"version", &attr_value));
+    EXPECT_TRUE(dictionary->GetString("version", &attr_value));
     EXPECT_EQ(attr_value, "1.1.0");
-    EXPECT_TRUE(dictionary->GetString(L"host", &attr_value));
+    EXPECT_TRUE(dictionary->GetString("host", &attr_value));
     EXPECT_EQ(attr_value, kTestHost);
     // Everything else is optional.
     ListValue* wifi_aps;
     *max_age_out = kint32min;
-    if (dictionary->GetList(L"wifi_towers", &wifi_aps)) {
+    if (dictionary->GetList("wifi_towers", &wifi_aps)) {
       int i = 0;
       for (ListValue::const_iterator it = wifi_aps->begin();
            it < wifi_aps->end(); ++it, ++i) {
         EXPECT_EQ(Value::TYPE_DICTIONARY, (*it)->GetType());
         DictionaryValue* ap = static_cast<DictionaryValue*>(*it);
         AccessPointData data;
-        ap->GetStringAsUTF16(L"mac_address", &data.mac_address);
-        ap->GetInteger(L"signal_strength", &data.radio_signal_strength);
+        ap->GetString("mac_address", &data.mac_address);
+        ap->GetInteger("signal_strength", &data.radio_signal_strength);
         int age = kint32min;
-        ap->GetInteger(L"age", &age);
+        ap->GetInteger("age", &age);
         if (age > *max_age_out)
           *max_age_out = age;
-        ap->GetInteger(L"channel", &data.channel);
-        ap->GetInteger(L"signal_to_noise", &data.signal_to_noise);
-        ap->GetStringAsUTF16(L"ssid", &data.ssid);
+        ap->GetInteger("channel", &data.channel);
+        ap->GetInteger("signal_to_noise", &data.signal_to_noise);
+        ap->GetString("ssid", &data.ssid);
         wifi_data_out->access_point_data.insert(data);
       }
     } else {
       wifi_data_out->access_point_data.clear();
     }
-    if (!dictionary->GetString(L"access_token", access_token_out))
+    if (!dictionary->GetString("access_token", access_token_out))
       access_token_out->clear();
   }
 
   static void CheckEmptyRequestIsValid(const std::string& request_data) {
     WifiData wifi_aps;
     std::string access_token;
     int max_age;
     ParseRequest(request_data, &wifi_aps, &max_age, &access_token);
     EXPECT_EQ(kint32min, max_age);
     EXPECT_EQ(0, static_cast<int>(wifi_aps.access_point_data.size()));
@@ skipping 249 matching lines @@
   provider->OnPermissionGranted(GURL(kTestHostUrl));
 
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
 
   EXPECT_EQ(test_server_url_, fetcher->original_url());
 
   CheckRequestIsValid(fetcher->upload_data(), kScanCount,
                       REFERENCE_ACCESS_TOKEN);
 }