Make UTF16ToASCII and UTF16TOUTF8 take a StringPiece

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 163 matching lines @@
 
 void GetNativeRtcConfiguration(
     const blink::WebRTCConfiguration& blink_config,
     webrtc::PeerConnectionInterface::RTCConfiguration* webrtc_config) {
   if (blink_config.isNull() || !webrtc_config)
     return;
   for (size_t i = 0; i < blink_config.numberOfServers(); ++i) {
     webrtc::PeerConnectionInterface::IceServer server;
     const blink::WebRTCICEServer& webkit_server =
         blink_config.server(i);
-    server.username = base::UTF16ToUTF8(webkit_server.username());
-    server.password = base::UTF16ToUTF8(webkit_server.credential());
+    server.username =
+        base::UTF16ToUTF8(base::StringPiece16(webkit_server.username()));
+    server.password =
+        base::UTF16ToUTF8(base::StringPiece16(webkit_server.credential()));
     server.uri = webkit_server.uri().spec();
     webrtc_config->servers.push_back(server);
   }
 
   switch (blink_config.iceTransports()) {
     case blink::WebRTCIceTransportsNone:
       webrtc_config->type = webrtc::PeerConnectionInterface::kNone;
       break;
     case blink::WebRTCIceTransportsRelay:
       webrtc_config->type = webrtc::PeerConnectionInterface::kRelay;
@@ skipping 702 matching lines @@
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateAnswer(this, constraints);
 }
 
 void RTCPeerConnectionHandler::setLocalDescription(
     const blink::WebRTCVoidRequest& request,
     const blink::WebRTCSessionDescription& description) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::setLocalDescription");
 
-  std::string sdp = base::UTF16ToUTF8(description.sdp());
-  std::string type = base::UTF16ToUTF8(description.type());
+  std::string sdp = base::UTF16ToUTF8(base::StringPiece16(description.sdp()));
+  std::string type =
+      base::UTF16ToUTF8(base::StringPiece16(description.type()));
 
   webrtc::SdpParseError error;
   // Since CreateNativeSessionDescription uses the dependency factory, we need
   // to make this call on the current thread to be safe.
   webrtc::SessionDescriptionInterface* native_desc =
       CreateNativeSessionDescription(sdp, type, &error);
   if (!native_desc) {
     std::string reason_str = "Failed to parse SessionDescription. ";
     reason_str.append(error.line);
     reason_str.append(" ");
@@ skipping 20 matching lines @@
               native_peer_connection_, set_request,
               base::Unretained(native_desc)),
           "SetLocalDescription"));
 }
 
 void RTCPeerConnectionHandler::setRemoteDescription(
     const blink::WebRTCVoidRequest& request,
     const blink::WebRTCSessionDescription& description) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::setRemoteDescription");
-  std::string sdp = base::UTF16ToUTF8(description.sdp());
-  std::string type = base::UTF16ToUTF8(description.type());
+  std::string sdp = base::UTF16ToUTF8(base::StringPiece16(description.sdp()));
+  std::string type =
+      base::UTF16ToUTF8(base::StringPiece16(description.type()));
 
   webrtc::SdpParseError error;
   // Since CreateNativeSessionDescription uses the dependency factory, we need
   // to make this call on the current thread to be safe.
   webrtc::SessionDescriptionInterface* native_desc =
       CreateNativeSessionDescription(sdp, type, &error);
   if (!native_desc) {
     std::string reason_str = "Failed to parse SessionDescription. ";
     reason_str.append(error.line);
     reason_str.append(" ");
@@ skipping 94 matching lines @@
   // On failure callback will be triggered.
   return true;
 }
 
 bool RTCPeerConnectionHandler::addICECandidate(
     const blink::WebRTCICECandidate& candidate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::addICECandidate");
   scoped_ptr<webrtc::IceCandidateInterface> native_candidate(
       dependency_factory_->CreateIceCandidate(
-          base::UTF16ToUTF8(candidate.sdpMid()),
+          base::UTF16ToUTF8(base::StringPiece16(candidate.sdpMid())),
           candidate.sdpMLineIndex(),
-          base::UTF16ToUTF8(candidate.candidate())));
+          base::UTF16ToUTF8(base::StringPiece16(candidate.candidate()))));
   bool return_value = false;
 
   if (native_candidate) {
     return_value =
         native_peer_connection_->AddIceCandidate(native_candidate.get());
     LOG_IF(ERROR, !return_value) << "Error processing ICE candidate.";
   } else {
     LOG(ERROR) << "Could not create native ICE candidate.";
   }
 
@@ skipping 133 matching lines @@
 void RTCPeerConnectionHandler::CloseClientPeerConnection() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (client_)
     client_->closePeerConnection();
 }
 
 blink::WebRTCDataChannelHandler* RTCPeerConnectionHandler::createDataChannel(
     const blink::WebString& label, const blink::WebRTCDataChannelInit& init) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::createDataChannel");
-  DVLOG(1) << "createDataChannel label " << base::UTF16ToUTF8(label);
+  DVLOG(1) << "createDataChannel label "
+           << base::UTF16ToUTF8(base::StringPiece16(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 = base::UTF16ToUTF8(init.protocol);
+  config.protocol = base::UTF16ToUTF8(base::StringPiece16(init.protocol));
 
   rtc::scoped_refptr<webrtc::DataChannelInterface> webrtc_channel(
-      native_peer_connection_->CreateDataChannel(base::UTF16ToUTF8(label),
-                                                 &config));
+      native_peer_connection_->CreateDataChannel(
+          base::UTF16ToUTF8(base::StringPiece16(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);
   }
 
   ++num_data_channels_created_;
@@ skipping 267 matching lines @@
     base::WaitableEvent event(false, false);
     thread->PostTask(FROM_HERE,
         base::Bind(&RunSynchronousClosure, closure,
                    base::Unretained(trace_event_name),
                    base::Unretained(&event)));
     event.Wait();
   }
 }
 
 }  // namespace content