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

content/renderer/media/media_stream_dependency_factory.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/renderer/media/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 380 matching lines @@
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     blink::WebMediaStream* web_stream) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
   if (!EnsurePeerConnectionFactory()) {
     DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
     return;
   }
 
-  std::string label = UTF16ToUTF8(web_stream->id());
+  std::string label = base::UTF16ToUTF8(web_stream->id());
   scoped_refptr<webrtc::MediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
   MediaStreamExtraData* extra_data =
       new MediaStreamExtraData(native_stream.get(), true);
   web_stream->setExtraData(extra_data);
 
   // Add audio tracks.
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   web_stream->audioTracks(audio_tracks);
   for (size_t i = 0; i < audio_tracks.size(); ++i) {
@@ skipping 43 matching lines @@
       source_data =
           static_cast<MediaStreamSourceExtraData*>(source.extraData());
     } else {
       // TODO(perkj): Implement support for sources from
       // remote MediaStreams.
       NOTIMPLEMENTED();
       return NULL;
     }
   }
 
-  std::string track_id = UTF16ToUTF8(track.id());
+  std::string track_id = base::UTF16ToUTF8(track.id());
   scoped_refptr<WebRtcAudioCapturer> capturer;
   if (GetWebRtcAudioDevice())
     capturer = GetWebRtcAudioDevice()->GetDefaultCapturer();
 
   scoped_refptr<webrtc::AudioTrackInterface> audio_track(
       CreateLocalAudioTrack(track_id,
                             capturer,
                             webaudio_source.get(),
                             source_data->local_audio_source(),
                             &track_constraints));
@@ skipping 17 matching lines @@
   MediaStreamSourceExtraData* source_data =
       static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
   if (!source_data) {
     // TODO(perkj): Implement support for sources from
     // remote MediaStreams.
     NOTIMPLEMENTED();
     return NULL;
   }
 
-  std::string track_id = UTF16ToUTF8(track.id());
+  std::string track_id = base::UTF16ToUTF8(track.id());
   scoped_refptr<webrtc::VideoTrackInterface> video_track(
       CreateLocalVideoTrack(track_id, source_data->video_source()));
   AddNativeTrackToBlinkTrack(video_track.get(), track, true);
 
   video_track->set_enabled(track.isEnabled());
 
   return video_track;
 }
 
 void MediaStreamDependencyFactory::CreateNativeMediaStreamTrack(
@@ skipping 61 matching lines @@
 
   // Add the native track to native stream
   webrtc::MediaStreamInterface* native_stream =
       GetNativeMediaStream(*stream);
   DCHECK(native_stream);
   native_stream->AddTrack(native_track.get());
 
   // Create a new webkit video track.
   blink::WebMediaStreamTrack webkit_track;
   blink::WebMediaStreamSource webkit_source;
-  blink::WebString webkit_track_id(UTF8ToUTF16(track_id));
+  blink::WebString webkit_track_id(base::UTF8ToUTF16(track_id));
   blink::WebMediaStreamSource::Type type =
       blink::WebMediaStreamSource::TypeVideo;
   webkit_source.initialize(webkit_track_id, type, webkit_track_id);
 
   webkit_track.initialize(webkit_track_id, webkit_source);
   AddNativeTrackToBlinkTrack(native_track.get(), webkit_track, true);
 
   // Add the track to WebMediaStream.
   stream->addTrack(webkit_track);
   return true;
 }
 
 bool MediaStreamDependencyFactory::RemoveNativeMediaStreamTrack(
     const blink::WebMediaStream& stream,
     const blink::WebMediaStreamTrack& track) {
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream.extraData());
   webrtc::MediaStreamInterface* native_stream = extra_data->stream().get();
   DCHECK(native_stream);
-  std::string track_id = UTF16ToUTF8(track.id());
+  std::string track_id = base::UTF16ToUTF8(track.id());
   switch (track.source().type()) {
     case blink::WebMediaStreamSource::TypeAudio:
       return native_stream->RemoveTrack(
           native_stream->FindAudioTrack(track_id));
     case blink::WebMediaStreamSource::TypeVideo:
       return native_stream->RemoveTrack(
           native_stream->FindVideoTrack(track_id));
   }
   return false;
 }
@@ skipping 427 matching lines @@
   if (!aec_dump_file_stream) {
     VLOG(1) << "Could not open AEC dump file.";
     base::ClosePlatformFile(aec_dump_file);
   } else {
     // |pc_factory_| takes ownership of |aec_dump_file_stream|.
     pc_factory_->StartAecDump(aec_dump_file_stream);
   }
 }
 
 }  // namespace content