Add utf_string_conversions to base namespace.

chrome/browser/password_manager/password_store_mac_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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 141 matching lines @@
   form->preferred = form_data.preferred;
   form->ssl_valid = form_data.ssl_valid;
   form->date_created = base::Time::FromDoubleT(form_data.creation_time);
   if (form_data.signon_realm)
     form->signon_realm = std::string(form_data.signon_realm);
   if (form_data.origin)
     form->origin = GURL(form_data.origin);
   if (form_data.action)
     form->action = GURL(form_data.action);
   if (form_data.submit_element)
-    form->submit_element = WideToUTF16(form_data.submit_element);
+    form->submit_element = base::WideToUTF16(form_data.submit_element);
   if (form_data.username_element)
-    form->username_element = WideToUTF16(form_data.username_element);
+    form->username_element = base::WideToUTF16(form_data.username_element);
   if (form_data.password_element)
-    form->password_element = WideToUTF16(form_data.password_element);
+    form->password_element = base::WideToUTF16(form_data.password_element);
   if (form_data.username_value) {
-    form->username_value = WideToUTF16(form_data.username_value);
+    form->username_value = base::WideToUTF16(form_data.username_value);
     if (form_data.password_value)
-      form->password_value = WideToUTF16(form_data.password_value);
+      form->password_value = base::WideToUTF16(form_data.password_value);
   } else {
     form->blacklisted_by_user = true;
   }
   return form;
 }
 
 // Macro to simplify calling CheckFormsAgainstExpectations with a useful label.
 #define CHECK_FORMS(forms, expectations, i) \
     CheckFormsAgainstExpectations(forms, expectations, #forms, i)
 
@@ skipping 16 matching lines @@
   for (unsigned int i = 0; i < expectations.size(); ++i) {
     snprintf(test_label, kBufferSize, "%s in test %u, item %u",
              forms_label, test_number, i);
     PasswordForm* form = forms[i];
     PasswordFormData* expectation = expectations[i];
     EXPECT_EQ(expectation->scheme, form->scheme) << test_label;
     EXPECT_EQ(std::string(expectation->signon_realm), form->signon_realm)
         << test_label;
     EXPECT_EQ(GURL(expectation->origin), form->origin) << test_label;
     EXPECT_EQ(GURL(expectation->action), form->action) << test_label;
-    EXPECT_EQ(WideToUTF16(expectation->submit_element), form->submit_element)
-        << test_label;
-    EXPECT_EQ(WideToUTF16(expectation->username_element),
+    EXPECT_EQ(base::WideToUTF16(expectation->submit_element),
+              form->submit_element) << test_label;
+    EXPECT_EQ(base::WideToUTF16(expectation->username_element),
               form->username_element) << test_label;
-    EXPECT_EQ(WideToUTF16(expectation->password_element),
+    EXPECT_EQ(base::WideToUTF16(expectation->password_element),
               form->password_element) << test_label;
     if (expectation->username_value) {
-      EXPECT_EQ(WideToUTF16(expectation->username_value),
+      EXPECT_EQ(base::WideToUTF16(expectation->username_value),
                 form->username_value) << test_label;
-      EXPECT_EQ(WideToUTF16(expectation->password_value),
+      EXPECT_EQ(base::WideToUTF16(expectation->password_value),
                 form->password_value) << test_label;
     } else {
       EXPECT_TRUE(form->blacklisted_by_user) << test_label;
     }
     EXPECT_EQ(expectation->preferred, form->preferred)  << test_label;
     EXPECT_EQ(expectation->ssl_valid, form->ssl_valid) << test_label;
     EXPECT_DOUBLE_EQ(expectation->creation_time,
                      form->date_created.ToDoubleT()) << test_label;
   }
 }
@@ skipping 57 matching lines @@
         *keychain_, keychain_item, &form);
 
     EXPECT_TRUE(parsed) << "In iteration " << i;
 
     EXPECT_EQ(expected[i].scheme, form.scheme) << "In iteration " << i;
     EXPECT_EQ(GURL(expected[i].origin), form.origin) << "In iteration " << i;
     EXPECT_EQ(expected[i].ssl_valid, form.ssl_valid) << "In iteration " << i;
     EXPECT_EQ(std::string(expected[i].signon_realm), form.signon_realm)
         << "In iteration " << i;
     if (expected[i].username) {
-      EXPECT_EQ(WideToUTF16(expected[i].username), form.username_value)
+      EXPECT_EQ(base::WideToUTF16(expected[i].username), form.username_value)
           << "In iteration " << i;
-      EXPECT_EQ(WideToUTF16(expected[i].password), form.password_value)
+      EXPECT_EQ(base::WideToUTF16(expected[i].password), form.password_value)
           << "In iteration " << i;
       EXPECT_FALSE(form.blacklisted_by_user) << "In iteration " << i;
     } else {
       EXPECT_TRUE(form.blacklisted_by_user) << "In iteration " << i;
     }
     base::Time::Exploded exploded_time;
     form.date_created.UTCExplode(&exploded_time);
     EXPECT_EQ(expected[i].creation_year, exploded_time.year)
          << "In iteration " << i;
     EXPECT_EQ(expected[i].creation_month, exploded_time.month)
@@ skipping 714 matching lines @@
       EXPECT_EQ(0U, matching_items.size()) << "iteration " << i;
     }
     STLDeleteElements(&matching_items);
 
     login_db_->GetLogins(*query_form, &matching_items);
     EXPECT_EQ(updates[i].password ? 1U : 0U, matching_items.size())
         << "iteration " << i;
     STLDeleteElements(&matching_items);
   }
 }