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

content/renderer/media/rtc_peer_connection_handler.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/rtc_peer_connection_handler.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 103 matching lines @@
     LOG(ERROR) << "Native session description is null.";
     return description;
   }
 
   std::string sdp;
   if (!native_desc->ToString(&sdp)) {
     LOG(ERROR) << "Failed to get SDP string of native session description.";
     return description;
   }
 
-  description.initialize(UTF8ToUTF16(native_desc->type()), UTF8ToUTF16(sdp));
+  description.initialize(base::UTF8ToUTF16(native_desc->type()),
+                         base::UTF8ToUTF16(sdp));
   return description;
 }
 
 // Converter functions from WebKit types to libjingle types.
 
 static void GetNativeIceServers(
     const blink::WebRTCConfiguration& server_configuration,
     webrtc::PeerConnectionInterface::IceServers* servers) {
   if (server_configuration.isNull() || !servers)
     return;
   for (size_t i = 0; i < server_configuration.numberOfServers(); ++i) {
     webrtc::PeerConnectionInterface::IceServer server;
     const blink::WebRTCICEServer& webkit_server =
         server_configuration.server(i);
-    server.username = UTF16ToUTF8(webkit_server.username());
-    server.password = UTF16ToUTF8(webkit_server.credential());
+    server.username = base::UTF16ToUTF8(webkit_server.username());
+    server.password = base::UTF16ToUTF8(webkit_server.credential());
     server.uri = webkit_server.uri().spec();
     servers->push_back(server);
   }
 }
 
 class SessionDescriptionRequestTracker {
  public:
   SessionDescriptionRequestTracker(RTCPeerConnectionHandler* handler,
                                    PeerConnectionTracker::Action action)
       : handler_(handler), action_(action) {}
@@ skipping 30 matching lines @@
       RTCPeerConnectionHandler* handler,
       PeerConnectionTracker::Action action)
       : webkit_request_(request), tracker_(handler, action) {}
 
   virtual void OnSuccess(webrtc::SessionDescriptionInterface* desc) OVERRIDE {
     tracker_.TrackOnSuccess(desc);
     webkit_request_.requestSucceeded(CreateWebKitSessionDescription(desc));
   }
   virtual void OnFailure(const std::string& error) OVERRIDE {
     tracker_.TrackOnFailure(error);
-    webkit_request_.requestFailed(UTF8ToUTF16(error));
+    webkit_request_.requestFailed(base::UTF8ToUTF16(error));
   }
 
  protected:
   virtual ~CreateSessionDescriptionRequest() {}
 
  private:
   blink::WebRTCSessionDescriptionRequest webkit_request_;
   SessionDescriptionRequestTracker tracker_;
 };
 
 // Class mapping responses from calls to libjingle
 // SetLocalDescription/SetRemoteDescription and a blink::WebRTCVoidRequest.
 class SetSessionDescriptionRequest
     : public webrtc::SetSessionDescriptionObserver {
  public:
   explicit SetSessionDescriptionRequest(
       const blink::WebRTCVoidRequest& request,
       RTCPeerConnectionHandler* handler,
       PeerConnectionTracker::Action action)
       : webkit_request_(request), tracker_(handler, action) {}
 
   virtual void OnSuccess() OVERRIDE {
     tracker_.TrackOnSuccess(NULL);
     webkit_request_.requestSucceeded();
   }
   virtual void OnFailure(const std::string& error) OVERRIDE {
     tracker_.TrackOnFailure(error);
-    webkit_request_.requestFailed(UTF8ToUTF16(error));
+    webkit_request_.requestFailed(base::UTF8ToUTF16(error));
   }
 
  protected:
   virtual ~SetSessionDescriptionRequest() {}
 
  private:
   blink::WebRTCVoidRequest webkit_request_;
   SessionDescriptionRequestTracker tracker_;
 };
 
@@ skipping 270 matching lines @@
       base::Bind(&RTCPeerConnectionHandler::OnaddICECandidateResult,
                  base::Unretained(this), request, result));
   // On failure callback will be triggered.
   return true;
 }
 
 bool RTCPeerConnectionHandler::addICECandidate(
     const blink::WebRTCICECandidate& candidate) {
   scoped_ptr<webrtc::IceCandidateInterface> native_candidate(
       dependency_factory_->CreateIceCandidate(
-          UTF16ToUTF8(candidate.sdpMid()),
+          base::UTF16ToUTF8(candidate.sdpMid()),
           candidate.sdpMLineIndex(),
-          UTF16ToUTF8(candidate.candidate())));
+          base::UTF16ToUTF8(candidate.candidate())));
   if (!native_candidate) {
     LOG(ERROR) << "Could not create native ICE candidate.";
     return false;
   }
 
   bool return_value =
       native_peer_connection_->AddIceCandidate(native_candidate.get());
   LOG_IF(ERROR, !return_value) << "Error processing ICE candidate.";
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackAddIceCandidate(
         this, candidate, PeerConnectionTracker::SOURCE_REMOTE);
 
   return return_value;
 }
 
 void RTCPeerConnectionHandler::OnaddICECandidateResult(
     const blink::WebRTCVoidRequest& webkit_request, bool result) {
   if (!result) {
     // We don't have the actual error code from the libjingle, so for now
     // using a generic error string.
     return webkit_request.requestFailed(
-        UTF8ToUTF16("Error processing ICE candidate"));
+        base::UTF8ToUTF16("Error processing ICE candidate"));
   }
 
   return webkit_request.requestSucceeded();
 }
 
 bool RTCPeerConnectionHandler::addStream(
     const blink::WebMediaStream& stream,
     const blink::WebMediaConstraints& options) {
   RTCMediaConstraints constraints(options);
 
@@ skipping 54 matching lines @@
     DVLOG(1) << "GetStats failed.";
     // TODO(hta): Consider how to get an error back.
     std::vector<webrtc::StatsReport> no_reports;
     observer->OnComplete(no_reports);
     return;
   }
 }
 
 blink::WebRTCDataChannelHandler* RTCPeerConnectionHandler::createDataChannel(
     const blink::WebString& label, const blink::WebRTCDataChannelInit& init) {
-  DVLOG(1) << "createDataChannel label " << UTF16ToUTF8(label);
+  DVLOG(1) << "createDataChannel label " << base::UTF16ToUTF8(label);
 
   webrtc::DataChannelInit config;
   // TODO(jiayl): remove the deprecated reliable field once Libjingle is updated
   // to handle that.
   config.reliable = false;
   config.id = init.id;
   config.ordered = init.ordered;
   config.negotiated = init.negotiated;
   config.maxRetransmits = init.maxRetransmits;
   config.maxRetransmitTime = init.maxRetransmitTime;
-  config.protocol = UTF16ToUTF8(init.protocol);
+  config.protocol = base::UTF16ToUTF8(init.protocol);
 
   talk_base::scoped_refptr<webrtc::DataChannelInterface> webrtc_channel(
-      native_peer_connection_->CreateDataChannel(UTF16ToUTF8(label), &config));
+      native_peer_connection_->CreateDataChannel(base::UTF16ToUTF8(label),
+                                                 &config));
   if (!webrtc_channel) {
     DLOG(ERROR) << "Could not create native data channel.";
     return NULL;
   }
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateDataChannel(
         this, webrtc_channel.get(), PeerConnectionTracker::SOURCE_LOCAL);
 
   return new RtcDataChannelHandler(webrtc_channel);
 }
@@ skipping 114 matching lines @@
 
 void RTCPeerConnectionHandler::OnIceCandidate(
     const webrtc::IceCandidateInterface* candidate) {
   DCHECK(candidate);
   std::string sdp;
   if (!candidate->ToString(&sdp)) {
     NOTREACHED() << "OnIceCandidate: Could not get SDP string.";
     return;
   }
   blink::WebRTCICECandidate web_candidate;
-  web_candidate.initialize(UTF8ToUTF16(sdp),
-                           UTF8ToUTF16(candidate->sdp_mid()),
+  web_candidate.initialize(base::UTF8ToUTF16(sdp),
+                           base::UTF8ToUTF16(candidate->sdp_mid()),
                            candidate->sdp_mline_index());
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackAddIceCandidate(
         this, web_candidate, PeerConnectionTracker::SOURCE_LOCAL);
 
   client_->didGenerateICECandidate(web_candidate);
 }
 
 void RTCPeerConnectionHandler::OnDataChannel(
     webrtc::DataChannelInterface* data_channel) {
@@ skipping 13 matching lines @@
 }
 
 PeerConnectionTracker* RTCPeerConnectionHandler::peer_connection_tracker() {
   return peer_connection_tracker_;
 }
 
 webrtc::SessionDescriptionInterface*
 RTCPeerConnectionHandler::CreateNativeSessionDescription(
     const blink::WebRTCSessionDescription& description,
     webrtc::SdpParseError* error) {
-  std::string sdp = UTF16ToUTF8(description.sdp());
-  std::string type = UTF16ToUTF8(description.type());
+  std::string sdp = base::UTF16ToUTF8(description.sdp());
+  std::string type = base::UTF16ToUTF8(description.type());
   webrtc::SessionDescriptionInterface* native_desc =
       dependency_factory_->CreateSessionDescription(type, sdp, error);
 
   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
                               << " Type: " << type << " SDP: " << sdp;
 
   return native_desc;
 }
 
 }  // namespace content