Update some uses of UTF conversions in chrome/browser to use the base:: namespace.

chrome/browser/spellchecker/spelling_service_client_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 122 matching lines @@
     request_language_ = language;
   }
 
   void SetHTTPResponse(int status, const char* data) {
     response_status_ = status;
     response_data_.assign(data);
   }
 
   void SetExpectedTextCheckResult(bool success, const char* text) {
     success_ = success;
-    corrected_text_.assign(UTF8ToUTF16(text));
+    corrected_text_.assign(base::UTF8ToUTF16(text));
   }
 
   void CallOnURLFetchComplete() {
     ASSERT_TRUE(!!fetcher_);
     fetcher_->delegate()->OnURLFetchComplete(fetcher_);
     fetcher_ = NULL;
   }
 
   void VerifyResponse(bool success,
                       const base::string16& request_text,
                       const std::vector<SpellCheckResult>& results) {
     EXPECT_EQ(success_, success);
-    base::string16 text(UTF8ToUTF16(request_text_));
+    base::string16 text(base::UTF8ToUTF16(request_text_));
     EXPECT_EQ(text, request_text);
     for (std::vector<SpellCheckResult>::const_iterator it = results.begin();
          it != results.end(); ++it) {
       text.replace(it->location, it->length, it->replacement);
     }
     EXPECT_EQ(corrected_text_, text);
   }
 
   bool ParseResponseSuccess(const std::string& data) {
     std::vector<SpellCheckResult> results;
@@ skipping 140 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     client_.SetHTTPRequest(kTests[i].request_type, kTests[i].request_text,
                            kTests[i].language);
     client_.SetHTTPResponse(kTests[i].response_status, kTests[i].response_data);
     client_.SetExpectedTextCheckResult(kTests[i].success,
                                        kTests[i].corrected_text);
     pref->SetString(prefs::kSpellCheckDictionary, kTests[i].language);
     client_.RequestTextCheck(
         &profile_,
         kTests[i].request_type,
-        ASCIIToUTF16(kTests[i].request_text),
+        base::ASCIIToUTF16(kTests[i].request_text),
         base::Bind(&SpellingServiceClientTest::OnTextCheckComplete,
                    base::Unretained(this), 0));
     client_.CallOnURLFetchComplete();
   }
 }
 
 // Verify that SpellingServiceClient::IsAvailable() returns true only when it
 // can send suggest requests or spellcheck requests.
 TEST_F(SpellingServiceClientTest, AvailableServices) {
   const SpellingServiceClient::ServiceType kSuggest =
@@ skipping 51 matching lines @@
     EXPECT_FALSE(client_.IsAvailable(&profile_, kSpellcheck));
   }
 }
 
 // Verify that an error in JSON response from spelling service will result in
 // ParseResponse returning false.
 TEST_F(SpellingServiceClientTest, ResponseErrorTest) {
   EXPECT_TRUE(client_.ParseResponseSuccess("{\"result\": {}}"));
   EXPECT_FALSE(client_.ParseResponseSuccess("{\"error\": {}}"));
 }