Update uses of UTF conversions in chrome_frame/, chromeos/, components/ to use the base:: namespace.

chrome_frame/urlmon_url_request.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_frame/urlmon_url_request.h"
 
 #include <urlmon.h>
 #include <wininet.h>
 
 #include "base/bind.h"
@@ skipping 228 matching lines @@
     return S_OK;
 
   if (!delegate_) {
     DVLOG(1) << "Invalid delegate";
     return S_OK;
   }
 
   switch (status_code) {
     case BINDSTATUS_CONNECTING: {
       if (status_text) {
-        socket_address_.set_host(WideToUTF8(status_text));
+        socket_address_.set_host(base::WideToUTF8(status_text));
       }
       break;
     }
 
     case BINDSTATUS_REDIRECTING: {
       // If we receive a redirect for the initial pending request initiated
       // when our document loads we should stash it away and inform Chrome
       // accordingly when it requests data for the original URL.
       base::win::ScopedComPtr<BindContextInfo> info;
       BindContextInfo::FromBindContext(bind_context_, info.Receive());
       DCHECK(info);
       GURL previously_redirected(info ? info->GetUrl() : std::wstring());
       if (GURL(status_text) != previously_redirected) {
         DVLOG(1) << __FUNCTION__ << me() << "redirect from " << url()
                  << " to " << status_text;
         // Fetch the redirect status as they aren't all equal (307 in particular
         // retains the HTTP request verb).
         int http_code = GetHttpResponseStatusFromBinding(binding_);
-        status_.SetRedirected(http_code, WideToUTF8(status_text));
+        status_.SetRedirected(http_code, base::WideToUTF8(status_text));
         // Abort. We will inform Chrome in OnStopBinding callback.
         binding_->Abort();
         return E_ABORT;
       }
       break;
     }
 
     case BINDSTATUS_COOKIE_SENT:
       delegate_->AddPrivacyDataForUrl(url(), "", COOKIEACTION_READ);
       break;
@@ skipping 63 matching lines @@
       // For certain requests like empty POST requests the server can return
       // back a HTTP success code in the range 200 to 299. We need to flag
       // these requests as succeeded.
       if (IS_HTTP_SUCCESS_CODE(http_code)) {
         // If this DCHECK fires it means that the server returned a HTTP
         // success code outside the standard range 200-206. We need to confirm
         // if the following code path is correct.
         DCHECK_LE(http_code, 206);
         status_.set_result(S_OK);
         std::string headers = GetHttpHeadersFromBinding(binding_);
-        OnResponse(0, UTF8ToWide(headers).c_str(), NULL, NULL);
+        OnResponse(0, base::UTF8ToWide(headers).c_str(), NULL, NULL);
       } else if (net::HttpResponseHeaders::IsRedirectResponseCode(http_code) &&
                  result == E_ACCESSDENIED) {
         // Special case. If the last request was a redirect and the current OS
         // error value is E_ACCESSDENIED, that means an unsafe redirect was
         // attempted. In that case, correct the OS error value to be the more
         // specific ERR_UNSAFE_REDIRECT error value.
         status_.set_result(net::URLRequestStatus::FAILED,
                            net::ERR_UNSAFE_REDIRECT);
       }
     }
@@ skipping 23 matching lines @@
     NotifyDelegateAndDie();
     return S_OK;
   }
 
   // Status::ABORTING
   if (status_.was_redirected()) {
     // Just release bindings here. Chrome will issue EndRequest(request_id)
     // after processing headers we had provided.
     if (!pending_) {
       std::string headers = GetHttpHeadersFromBinding(binding_);
-      OnResponse(0, UTF8ToWide(headers).c_str(), NULL, NULL);
+      OnResponse(0, base::UTF8ToWide(headers).c_str(), NULL, NULL);
     }
     ReleaseBindings();
     return S_OK;
   }
 
   // Stop invoked.
   NotifyDelegateAndDie();
   return S_OK;
 }
 
@@ skipping 16 matching lines @@
   if (load_flags_ & net::LOAD_BYPASS_CACHE)
     *bind_flags |= BINDF_GETNEWESTVERSION;
 
   if (LowerCaseEqualsASCII(method(), "get")) {
     bind_info->dwBindVerb = BINDVERB_GET;
   } else if (LowerCaseEqualsASCII(method(), "post")) {
     bind_info->dwBindVerb = BINDVERB_POST;
   } else if (LowerCaseEqualsASCII(method(), "put")) {
     bind_info->dwBindVerb = BINDVERB_PUT;
   } else {
-    std::wstring verb(ASCIIToWide(StringToUpperASCII(method())));
+    std::wstring verb(base::ASCIIToWide(StringToUpperASCII(method())));
     bind_info->dwBindVerb = BINDVERB_CUSTOM;
     bind_info->szCustomVerb = reinterpret_cast<wchar_t*>(
         ::CoTaskMemAlloc((verb.length() + 1) * sizeof(wchar_t)));
     lstrcpyW(bind_info->szCustomVerb, verb.c_str());
   }
 
   if (bind_info->dwBindVerb == BINDVERB_POST ||
       bind_info->dwBindVerb == BINDVERB_PUT ||
       post_data_len() > 0) {
     // Bypass caching proxies on upload requests and avoid writing responses to
@@ skipping 138 matching lines @@
   new_headers += ReplaceOrAddUserAgent(current_headers, user_agent);
 
   if (!new_headers.empty()) {
     *additional_headers = reinterpret_cast<wchar_t*>(
         CoTaskMemAlloc((new_headers.size() + 1) * sizeof(wchar_t)));
 
     if (*additional_headers == NULL) {
       NOTREACHED();
       hr = E_OUTOFMEMORY;
     } else {
-      lstrcpynW(*additional_headers, ASCIIToWide(new_headers).c_str(),
+      lstrcpynW(*additional_headers, base::ASCIIToWide(new_headers).c_str(),
                 new_headers.size());
     }
   }
   request_headers_ = new_headers;
   return hr;
 }
 
 STDMETHODIMP UrlmonUrlRequest::OnResponse(DWORD dwResponseCode,
     const wchar_t* response_headers, const wchar_t* request_headers,
     wchar_t** additional_headers) {
@@ skipping 98 matching lines @@
   }
   return hr;
 }
 
 HRESULT UrlmonUrlRequest::StartAsyncDownload() {
   DVLOG(1) << __FUNCTION__ << me() << url();
   HRESULT hr = E_FAIL;
   DCHECK((moniker_ && bind_context_) || (!moniker_ && !bind_context_));
 
   if (!moniker_.get()) {
-    std::wstring wide_url = UTF8ToWide(url());
+    std::wstring wide_url = base::UTF8ToWide(url());
     hr = CreateURLMonikerEx(NULL, wide_url.c_str(), moniker_.Receive(),
                             URL_MK_UNIFORM);
     if (FAILED(hr)) {
       NOTREACHED() << "CreateURLMonikerEx failed. Error: " << hr;
       return hr;
     }
   }
 
   if (bind_context_.get() == NULL)  {
     hr = ::CreateAsyncBindCtxEx(NULL, 0, this, NULL,
@@ skipping 218 matching lines @@
 
   if (!privacy_info_.privacy_impacted) {
     if (flags & (COOKIEACTION_ACCEPT | COOKIEACTION_REJECT |
                  COOKIEACTION_DOWNGRADE)) {
       privacy_info_.privacy_impacted = true;
       fire_privacy_event = true;
     }
   }
 
   PrivacyInfo::PrivacyEntry& privacy_entry =
-      privacy_info_.privacy_records[UTF8ToWide(url)];
+      privacy_info_.privacy_records[base::UTF8ToWide(url)];
 
   privacy_entry.flags |= flags;
-  privacy_entry.policy_ref = UTF8ToWide(policy_ref);
+  privacy_entry.policy_ref = base::UTF8ToWide(policy_ref);
 
   if (fire_privacy_event && IsWindow(notification_window_)) {
     PostMessage(notification_window_, WM_FIRE_PRIVACY_CHANGE_NOTIFICATION, 1,
                 0);
   }
 }