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

content/renderer/media/peer_connection_tracker.cc

 // Copyright (c) 2013 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/renderer/media/peer_connection_tracker.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 46 matching lines @@
       if (i != optional.size() - 1)
         result += ", ";
     }
     result += "}";
   }
   return result;
 }
 
 static string SerializeMediaStreamComponent(
     const blink::WebMediaStreamTrack component) {
-  string id = UTF16ToUTF8(component.source().id());
+  string id = base::UTF16ToUTF8(component.source().id());
   return id;
 }
 
 static string SerializeMediaDescriptor(
     const blink::WebMediaStream& stream) {
-  string label = UTF16ToUTF8(stream.id());
+  string label = base::UTF16ToUTF8(stream.id());
   string result = "label: " + label;
   blink::WebVector<blink::WebMediaStreamTrack> tracks;
   stream.audioTracks(tracks);
   if (!tracks.isEmpty()) {
     result += ", audio: [";
     for (size_t i = 0; i < tracks.size(); ++i) {
       result += SerializeMediaStreamComponent(tracks[i]);
       if (i != tracks.size() - 1)
         result += ", ";
     }
@@ skipping 215 matching lines @@
     const RTCMediaConstraints& constraints) {
   SendPeerConnectionUpdate(
       pc_handler, "createAnswer",
       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 }
 
 void PeerConnectionTracker::TrackSetSessionDescription(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebRTCSessionDescription& desc,
     Source source) {
-  string sdp = UTF16ToUTF8(desc.sdp());
-  string type = UTF16ToUTF8(desc.type());
+  string sdp = base::UTF16ToUTF8(desc.sdp());
+  string type = base::UTF16ToUTF8(desc.type());
 
   string value = "type: " + type + ", sdp: " + sdp;
   SendPeerConnectionUpdate(
       pc_handler,
       source == SOURCE_LOCAL ? "setLocalDescription" : "setRemoteDescription",
       value);
 }
 
 void PeerConnectionTracker::TrackUpdateIce(
       RTCPeerConnectionHandler* pc_handler,
       const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
       const RTCMediaConstraints& options) {
   string servers_string = "servers: " + SerializeServers(servers);
   string constraints =
       "constraints: {" + SerializeMediaConstraints(options) + "}";
 
   SendPeerConnectionUpdate(
       pc_handler, "updateIce", servers_string + ", " + constraints);
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
       const blink::WebRTCICECandidate& candidate,
       Source source) {
-  string value = "mid: " + UTF16ToUTF8(candidate.sdpMid()) + ", " +
-                 "candidate: " + UTF16ToUTF8(candidate.candidate());
+  string value = "mid: " + base::UTF16ToUTF8(candidate.sdpMid()) + ", " +
+                 "candidate: " + base::UTF16ToUTF8(candidate.candidate());
   SendPeerConnectionUpdate(
       pc_handler,
       source == SOURCE_LOCAL ? "onIceCandidate" : "addIceCandidate", value);
 }
 
 void PeerConnectionTracker::TrackAddStream(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStream& stream,
     Source source){
   SendPeerConnectionUpdate(
@@ skipping 77 matching lines @@
 
 void PeerConnectionTracker::TrackOnRenegotiationNeeded(
     RTCPeerConnectionHandler* pc_handler) {
   SendPeerConnectionUpdate(pc_handler, "onRenegotiationNeeded", std::string());
 }
 
 void PeerConnectionTracker::TrackCreateDTMFSender(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStreamTrack& track) {
   SendPeerConnectionUpdate(pc_handler, "createDTMFSender",
-                           UTF16ToUTF8(track.id()));
+                           base::UTF16ToUTF8(track.id()));
 }
 
 int PeerConnectionTracker::GetNextLocalID() {
   return next_lid_++;
 }
 
 void PeerConnectionTracker::SendPeerConnectionUpdate(
     RTCPeerConnectionHandler* pc_handler,
     const std::string& type,
     const std::string& value) {
   if (peer_connection_id_map_.find(pc_handler) == peer_connection_id_map_.end())
     return;
 
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_UpdatePeerConnection(
           peer_connection_id_map_[pc_handler], type, value));
 }
 
 }  // namespace content