Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/datachannel.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/api/datachannel.h"
 
+#include <memory>
 #include <string>
 
 #include "webrtc/api/mediastreamprovider.h"
 #include "webrtc/api/sctputils.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/refcount.h"
 #include "webrtc/media/sctp/sctpdataengine.h"
 
 namespace webrtc {
 
@@ skipping 333 matching lines @@
 
   LOG(LS_VERBOSE) << "DataChannel received DATA message, sid = " << params.ssrc;
   // We can send unordered as soon as we receive any DATA message since the
   // remote side must have received the OPEN (and old clients do not send
   // OPEN_ACK).
   if (handshake_state_ == kHandshakeWaitingForAck) {
     handshake_state_ = kHandshakeReady;
   }
 
   bool binary = (params.type == cricket::DMT_BINARY);
-  rtc::scoped_ptr<DataBuffer> buffer(new DataBuffer(payload, binary));
+  std::unique_ptr<DataBuffer> buffer(new DataBuffer(payload, binary));
   if (state_ == kOpen && observer_) {
     observer_->OnMessage(*buffer.get());
   } else {
     if (queued_received_data_.byte_count() + payload.size() >
         kMaxQueuedReceivedDataBytes) {
       LOG(LS_ERROR) << "Queued received data exceeds the max buffer size.";
 
       queued_received_data_.Clear();
       if (data_channel_type_ != cricket::DCT_RTP) {
         Close();
@@ skipping 110 matching lines @@
     provider_->RemoveSctpDataStream(config_.id);
   }
 }
 
 void DataChannel::DeliverQueuedReceivedData() {
   if (!observer_) {
     return;
   }
 
   while (!queued_received_data_.Empty()) {
-    rtc::scoped_ptr<DataBuffer> buffer(queued_received_data_.Front());
+    std::unique_ptr<DataBuffer> buffer(queued_received_data_.Front());
     observer_->OnMessage(*buffer);
     queued_received_data_.Pop();
   }
 }
 
 void DataChannel::SendQueuedDataMessages() {
   if (queued_send_data_.Empty()) {
     return;
   }
 
@@ skipping 74 matching lines @@
     observer_->OnBufferedAmountChange(start_buffered_amount);
   }
   return true;
 }
 
 void DataChannel::SendQueuedControlMessages() {
   PacketQueue control_packets;
   control_packets.Swap(&queued_control_data_);
 
   while (!control_packets.Empty()) {
-    rtc::scoped_ptr<DataBuffer> buf(control_packets.Front());
+    std::unique_ptr<DataBuffer> buf(control_packets.Front());
     SendControlMessage(buf->data);
     control_packets.Pop();
   }
 }
 
 void DataChannel::QueueControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
   queued_control_data_.Push(new DataBuffer(buffer, true));
 }
 
 bool DataChannel::SendControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
@@ skipping 26 matching lines @@
     QueueControlMessage(buffer);
   } else {
     LOG(LS_ERROR) << "Closing the DataChannel due to a failure to send"
                   << " the CONTROL message, send_result = " << send_result;
     Close();
   }
   return retval;
 }
 
 }  // namespace webrtc