Reland Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

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.
  */
 
@@ skipping 306 matching lines @@
 void DataChannel::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_CHANNELREADY:
       OnChannelReady(true);
       break;
   }
 }
 
 void DataChannel::OnDataReceived(cricket::DataChannel* channel,
                                  const cricket::ReceiveDataParams& params,
-                                 const rtc::Buffer& payload) {
+                                 const rtc::CopyOnWriteBuffer& payload) {
   uint32_t expected_ssrc =
       (data_channel_type_ == cricket::DCT_RTP) ? receive_ssrc_ : config_.id;
   if (params.ssrc != expected_ssrc) {
     return;
   }
 
   if (params.type == cricket::DMT_CONTROL) {
     ASSERT(data_channel_type_ == cricket::DCT_SCTP);
     if (handshake_state_ != kHandshakeWaitingForAck) {
       // Ignore it if we are not expecting an ACK message.
@@ skipping 77 matching lines @@
   // clarity. OnChannelReady(true) will send any queued data and then invoke
   // UpdateState().
   switch (state_) {
     case kConnecting: {
       if (send_ssrc_set_ == receive_ssrc_set_) {
         if (data_channel_type_ == cricket::DCT_RTP && !connected_to_provider_) {
           connected_to_provider_ = provider_->ConnectDataChannel(this);
         }
         if (connected_to_provider_) {
           if (handshake_state_ == kHandshakeShouldSendOpen) {
-            rtc::Buffer payload;
+            rtc::CopyOnWriteBuffer payload;
             WriteDataChannelOpenMessage(label_, config_, &payload);
             SendControlMessage(payload);
           } else if (handshake_state_ == kHandshakeShouldSendAck) {
-            rtc::Buffer payload;
+            rtc::CopyOnWriteBuffer payload;
             WriteDataChannelOpenAckMessage(&payload);
             SendControlMessage(payload);
           }
           if (writable_ &&
               (handshake_state_ == kHandshakeReady ||
                handshake_state_ == kHandshakeWaitingForAck)) {
             SetState(kOpen);
             // If we have received buffers before the channel got writable.
             // Deliver them now.
             DeliverQueuedReceivedData();
@@ skipping 148 matching lines @@
   PacketQueue control_packets;
   control_packets.Swap(&queued_control_data_);
 
   while (!control_packets.Empty()) {
     rtc::scoped_ptr<DataBuffer> buf(control_packets.Front());
     SendControlMessage(buf->data);
     control_packets.Pop();
   }
 }
 
-void DataChannel::QueueControlMessage(const rtc::Buffer& buffer) {
+void DataChannel::QueueControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
   queued_control_data_.Push(new DataBuffer(buffer, true));
 }
 
-bool DataChannel::SendControlMessage(const rtc::Buffer& buffer) {
+bool DataChannel::SendControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
   bool is_open_message = handshake_state_ == kHandshakeShouldSendOpen;
 
   ASSERT(data_channel_type_ == cricket::DCT_SCTP &&
          writable_ &&
          config_.id >= 0 &&
          (!is_open_message || !config_.negotiated));
 
   cricket::SendDataParams send_params;
   send_params.ssrc = config_.id;
   // Send data as ordered before we receive any message from the remote peer to
@@ skipping 16 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