Update uses of UTF conversions in content/ to use the base:: namespace.

content/browser/browser_plugin/browser_plugin_guest.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 "content/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 203 matching lines @@
 class BrowserPluginGuest::JavaScriptDialogRequest : public PermissionRequest {
  public:
   JavaScriptDialogRequest(const DialogClosedCallback& callback)
       : callback_(callback) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.JSDialog"));
   }
 
   virtual void Respond(bool should_allow,
                        const std::string& user_input) OVERRIDE {
-    callback_.Run(should_allow, UTF8ToUTF16(user_input));
+    callback_.Run(should_allow, base::UTF8ToUTF16(user_input));
   }
 
  private:
   virtual ~JavaScriptDialogRequest() {}
   DialogClosedCallback callback_;
 };
 
 class BrowserPluginGuest::PointerLockRequest : public PermissionRequest {
  public:
   PointerLockRequest(BrowserPluginGuest* guest)
@@ skipping 587 matching lines @@
 
 void BrowserPluginGuest::WebContentsCreated(WebContents* source_contents,
                                             int64 source_frame_id,
                                             const base::string16& frame_name,
                                             const GURL& target_url,
                                             WebContents* new_contents) {
   WebContentsImpl* new_contents_impl =
       static_cast<WebContentsImpl*>(new_contents);
   BrowserPluginGuest* guest = new_contents_impl->GetBrowserPluginGuest();
   guest->opener_ = AsWeakPtr();
-  std::string guest_name = UTF16ToUTF8(frame_name);
+  std::string guest_name = base::UTF16ToUTF8(frame_name);
   guest->name_ = guest_name;
   // Take ownership of the new guest until it is attached to the embedder's DOM
   // tree to avoid leaking a guest if this guest is destroyed before attaching
   // the new guest.
   pending_new_windows_.insert(
       std::make_pair(guest, NewWindowInfo(target_url, guest_name)));
 }
 
 void BrowserPluginGuest::RendererUnresponsive(WebContents* source) {
   RecordAction(UserMetricsAction("BrowserPlugin.Guest.Hung"));
@@ skipping 228 matching lines @@
 void BrowserPluginGuest::DidStopLoading(RenderViewHost* render_view_host) {
   bool enable_dragdrop = delegate_ && delegate_->IsDragAndDropEnabled();
   if (!enable_dragdrop) {
     // Initiating a drag from inside a guest is currently not supported without
     // the kEnableBrowserPluginDragDrop flag on a linux platform. So inject some
     // JS to disable it. http://crbug.com/161112
     const char script[] = "window.addEventListener('dragstart', function() { "
                           "  window.event.preventDefault(); "
                           "});";
     render_view_host->ExecuteJavascriptInWebFrame(base::string16(),
-                                                  ASCIIToUTF16(script));
+                                                  base::ASCIIToUTF16(script));
   }
 }
 
 void BrowserPluginGuest::RenderViewReady() {
   RenderViewHost* rvh = GetWebContents()->GetRenderViewHost();
   // The guest RenderView should always live in a guest process.
   CHECK(rvh->GetProcess()->IsGuest());
   // TODO(fsamuel): Investigate whether it's possible to update state earlier
   // here (see http://crbug.com/158151).
   Send(new InputMsg_SetFocus(routing_id(), focused_));
@@ skipping 209 matching lines @@
   Send(new InputMsg_ExecuteEditCommand(routing_id(), name, std::string()));
 }
 
 void BrowserPluginGuest::OnImeSetComposition(
     int instance_id,
     const std::string& text,
     const std::vector<blink::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   Send(new ViewMsg_ImeSetComposition(routing_id(),
-                                     UTF8ToUTF16(text), underlines,
+                                     base::UTF8ToUTF16(text), underlines,
                                      selection_start, selection_end));
 }
 
 void BrowserPluginGuest::OnImeConfirmComposition(
     int instance_id,
     const std::string& text,
     bool keep_selection) {
   Send(new ViewMsg_ImeConfirmComposition(routing_id(),
-                                         UTF8ToUTF16(text),
+                                         base::UTF8ToUTF16(text),
                                          gfx::Range::InvalidRange(),
                                          keep_selection));
 }
 
 void BrowserPluginGuest::OnExtendSelectionAndDelete(
     int instance_id,
     int before,
     int after) {
   Send(new ViewMsg_ExtendSelectionAndDelete(routing_id(), before, after));
 }
@@ skipping 377 matching lines @@
     const GURL& origin_url,
     const std::string& accept_lang,
     JavaScriptMessageType javascript_message_type,
     const base::string16& message_text,
     const base::string16& default_prompt_text,
     const DialogClosedCallback& callback,
     bool* did_suppress_message) {
   base::DictionaryValue request_info;
   request_info.Set(
       browser_plugin::kDefaultPromptText,
-      base::Value::CreateStringValue(UTF16ToUTF8(default_prompt_text)));
+      base::Value::CreateStringValue(base::UTF16ToUTF8(default_prompt_text)));
   request_info.Set(
       browser_plugin::kMessageText,
-      base::Value::CreateStringValue(UTF16ToUTF8(message_text)));
+      base::Value::CreateStringValue(base::UTF16ToUTF8(message_text)));
   request_info.Set(
       browser_plugin::kMessageType,
       base::Value::CreateStringValue(
           JavaScriptMessageTypeToString(javascript_message_type)));
   request_info.Set(
       browser_plugin::kURL,
       base::Value::CreateStringValue(origin_url.spec()));
 
   RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG,
                     new JavaScriptDialogRequest(callback),
@@ skipping 124 matching lines @@
   request_info.Set(browser_plugin::kRequestMethod,
                    base::Value::CreateStringValue(request_method));
   request_info.Set(browser_plugin::kURL, base::Value::CreateStringValue(url));
 
   RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD,
                     new DownloadRequest(callback),
                     request_info);
 }
 
 }  // namespace content