Use explicit WebString <-> string16 conversion methods in media files

content/renderer/media/rtc_data_channel_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_data_channel_handler.h"
 
 #include <limits>
 #include <string>
 #include <utility>
 
@@ skipping 159 matching lines @@
   DVLOG(3) << "setClient " << client;
   webkit_client_ = client;
   if (!client && observer_.get()) {
     observer_->Unregister();
     observer_ = nullptr;
   }
 }
 
 blink::WebString RtcDataChannelHandler::label() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::UTF8ToUTF16(channel()->label());
+  return blink::WebString::fromUTF8(channel()->label());
 }
 
 bool RtcDataChannelHandler::isReliable() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->reliable();
 }
 
 bool RtcDataChannelHandler::ordered() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->ordered();
 }
 
 unsigned short RtcDataChannelHandler::maxRetransmitTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->maxRetransmitTime();
 }
 
 unsigned short RtcDataChannelHandler::maxRetransmits() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->maxRetransmits();
 }
 
 blink::WebString RtcDataChannelHandler::protocol() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::UTF8ToUTF16(channel()->protocol());
+  return blink::WebString::fromUTF8(channel()->protocol());
 }
 
 bool RtcDataChannelHandler::negotiated() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->negotiated();
 }
 
 unsigned short RtcDataChannelHandler::id() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->id();
@@ skipping 31 matching lines @@
   }
 }
 
 unsigned long RtcDataChannelHandler::bufferedAmount() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return channel()->buffered_amount();
 }
 
 bool RtcDataChannelHandler::sendStringData(const blink::WebString& data) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  std::string utf8_buffer = base::UTF16ToUTF8(base::StringPiece16(data));
+  std::string utf8_buffer = data.utf8();
   webrtc::DataBuffer data_buffer(utf8_buffer);
   RecordMessageSent(data_buffer.size());
   return channel()->Send(data_buffer);
 }
 
 bool RtcDataChannelHandler::sendRawData(const char* data, size_t length) {
   DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CopyOnWriteBuffer buffer(data, length);
   webrtc::DataBuffer data_buffer(buffer, true);
   RecordMessageSent(data_buffer.size());
@@ skipping 60 matching lines @@
   if (buffer->binary) {
     webkit_client_->didReceiveRawData(buffer->data.data<char>(),
                                       buffer->data.size());
   } else {
     base::string16 utf16;
     if (!base::UTF8ToUTF16(buffer->data.data<char>(), buffer->data.size(),
                            &utf16)) {
       LOG(ERROR) << "Failed convert received data to UTF16";
       return;
     }
-    webkit_client_->didReceiveStringData(utf16);
+    webkit_client_->didReceiveStringData(blink::WebString::fromUTF16(utf16));
   }
 }
 
 void RtcDataChannelHandler::RecordMessageSent(size_t num_bytes) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Currently, messages are capped at some fairly low limit (16 Kb?)
   // but we may allow unlimited-size messages at some point, so making
   // the histogram maximum quite large (100 Mb) to have some
   // granularity at the higher end in that eventuality. The histogram
   // buckets are exponentially growing in size, so we'll still have
   // good granularity at the low end.
 
   // This makes the last bucket in the histogram count messages from
   // 100 Mb to infinity.
   const int kMaxBucketSize = 100 * 1024 * 1024;
   const int kNumBuckets = 50;
 
   if (channel()->reliable()) {
     UMA_HISTOGRAM_CUSTOM_COUNTS("WebRTC.ReliableDataChannelMessageSize",
                                 num_bytes,
                                 1, kMaxBucketSize, kNumBuckets);
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS("WebRTC.UnreliableDataChannelMessageSize",
                                 num_bytes,
                                 1, kMaxBucketSize, kNumBuckets);
   }
 }
 
 }  // namespace content