Reland Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/media/sctp/sctpdataengine.cc

 /*
  *  Copyright (c) 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/media/sctp/sctpdataengine.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 
 #include <memory>
 #include <sstream>
 #include <vector>
 
 #include "usrsctplib/usrsctp.h"
 #include "webrtc/base/arraysize.h"
-#include "webrtc/base/buffer.h"
+#include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/streamparams.h"
 
 namespace {
 typedef cricket::SctpDataMediaChannel::StreamSet StreamSet;
 // Returns a comma-separated, human-readable list of the stream IDs in 's'
@@ skipping 49 matching lines @@
     } else {
       result << array[i];
     }
   }
   return result.str();
 }
 }  // namespace
 
 namespace cricket {
 typedef rtc::ScopedMessageData<SctpInboundPacket> InboundPacketMessage;
-typedef rtc::ScopedMessageData<rtc::Buffer> OutboundPacketMessage;
+typedef rtc::ScopedMessageData<rtc::CopyOnWriteBuffer> OutboundPacketMessage;
 
 // The biggest SCTP packet.  Starting from a 'safe' wire MTU value of 1280,
 // take off 80 bytes for DTLS/TURN/TCP/IP overhead.
 static const size_t kSctpMtu = 1200;
 
 // The size of the SCTP association send buffer.  256kB, the usrsctp default.
 static const int kSendBufferSize = 262144;
 enum {
   MSG_SCTPINBOUNDPACKET = 1,   // MessageData is SctpInboundPacket
   MSG_SCTPOUTBOUNDPACKET = 2,  // MessageData is rtc:Buffer
 };
 
 struct SctpInboundPacket {
-  rtc::Buffer buffer;
+  rtc::CopyOnWriteBuffer buffer;
   ReceiveDataParams params;
   // The |flags| parameter is used by SCTP to distinguish notification packets
   // from other types of packets.
   int flags;
 };
 
 // Helper for logging SCTP messages.
 static void debug_sctp_printf(const char *format, ...) {
   char s[255];
   va_list ap;
@@ skipping 41 matching lines @@
     case SctpDataMediaChannel::PPID_NONE:
       *dest = cricket::DMT_NONE;
       return true;
 
     default:
       return false;
   }
 }
 
 // Log the packet in text2pcap format, if log level is at LS_VERBOSE.
-static void VerboseLogPacket(void *data, size_t length, int direction) {
+static void VerboseLogPacket(const void *data, size_t length, int direction) {
   if (LOG_CHECK_LEVEL(LS_VERBOSE) && length > 0) {
     char *dump_buf;
+    // Some downstream project uses an older version of usrsctp that expects
+    // a non-const "void*" as first parameter when dumping the packet, so we
+    // need to cast the const away here to avoid a compiler error.
     if ((dump_buf = usrsctp_dumppacket(
-             data, length, direction)) != NULL) {
+        const_cast<void*>(data), length, direction)) != NULL) {

[joachim, 2016/03/20 10:14:10]

This is the change compared to https://codereview.webrtc.org/1785713005/

Also added a comment above as to why this has changed.

       LOG(LS_VERBOSE) << dump_buf;
       usrsctp_freedumpbuffer(dump_buf);
     }
   }
 }
 
 // This is the callback usrsctp uses when there's data to send on the network
 // that has been wrapped appropriatly for the SCTP protocol.
 static int OnSctpOutboundPacket(void* addr, void* data, size_t length,
                                 uint8_t tos, uint8_t set_df) {
   SctpDataMediaChannel* channel = static_cast<SctpDataMediaChannel*>(addr);
   LOG(LS_VERBOSE) << "global OnSctpOutboundPacket():"
                   << "addr: " << addr << "; length: " << length
                   << "; tos: " << std::hex << static_cast<int>(tos)
                   << "; set_df: " << std::hex << static_cast<int>(set_df);
 
   VerboseLogPacket(addr, length, SCTP_DUMP_OUTBOUND);
   // Note: We have to copy the data; the caller will delete it.
   auto* msg = new OutboundPacketMessage(
-      new rtc::Buffer(reinterpret_cast<uint8_t*>(data), length));
+      new rtc::CopyOnWriteBuffer(reinterpret_cast<uint8_t*>(data), length));
   channel->worker_thread()->Post(channel, MSG_SCTPOUTBOUNDPACKET, msg);
   return 0;
 }
 
 // This is the callback called from usrsctp when data has been received, after
 // a packet has been interpreted and parsed by usrsctp and found to contain
 // payload data. It is called by a usrsctp thread. It is assumed this function
 // will free the memory used by 'data'.
 static int OnSctpInboundPacket(struct socket* sock, union sctp_sockstore addr,
                                void* data, size_t length,
@@ skipping 371 matching lines @@
 
 bool SctpDataMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   // SCTP DataChannels are always bi-directional and calling RemoveSendStream
   // will disable both sending and receiving on the stream. So RemoveRecvStream
   // is a no-op.
   return true;
 }
 
 bool SctpDataMediaChannel::SendData(
     const SendDataParams& params,
-    const rtc::Buffer& payload,
+    const rtc::CopyOnWriteBuffer& payload,
     SendDataResult* result) {
   if (result) {
     // Preset |result| to assume an error.  If SendData succeeds, we'll
     // overwrite |*result| once more at the end.
     *result = SDR_ERROR;
   }
 
   if (!sending_) {
     LOG(LS_WARNING) << debug_name_ << "->SendData(...): "
                     << "Not sending packet with ssrc=" << params.ssrc
@@ skipping 49 matching lines @@
   }
   if (result) {
     // Only way out now is success.
     *result = SDR_SUCCESS;
   }
   return true;
 }
 
 // Called by network interface when a packet has been received.
 void SctpDataMediaChannel::OnPacketReceived(
-    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
+    rtc::CopyOnWriteBuffer* packet, const rtc::PacketTime& packet_time) {
   RTC_DCHECK(rtc::Thread::Current() == worker_thread_);
   LOG(LS_VERBOSE) << debug_name_ << "->OnPacketReceived(...): "
                   << " length=" << packet->size() << ", sending: " << sending_;
   // Only give receiving packets to usrsctp after if connected. This enables two
   // peers to each make a connect call, but for them not to receive an INIT
   // packet before they have called connect; least the last receiver of the INIT
   // packet will have called connect, and a connection will be established.
   if (sending_) {
     // Pass received packet to SCTP stack. Once processed by usrsctp, the data
     // will be will be given to the global OnSctpInboundData, and then,
     // marshalled by a Post and handled with OnMessage.
-    VerboseLogPacket(packet->data(), packet->size(), SCTP_DUMP_INBOUND);
-    usrsctp_conninput(this, packet->data(), packet->size(), 0);
+    VerboseLogPacket(packet->cdata(), packet->size(), SCTP_DUMP_INBOUND);
+    usrsctp_conninput(this, packet->cdata(), packet->size(), 0);
   } else {
     // TODO(ldixon): Consider caching the packet for very slightly better
     // reliability.
   }
 }
 
 void SctpDataMediaChannel::OnInboundPacketFromSctpToChannel(
     SctpInboundPacket* packet) {
   LOG(LS_VERBOSE) << debug_name_ << "->OnInboundPacketFromSctpToChannel(...): "
                   << "Received SCTP data:"
                   << " ssrc=" << packet->params.ssrc
                   << " notification: " << (packet->flags & MSG_NOTIFICATION)
                   << " length=" << packet->buffer.size();
   // Sending a packet with data == NULL (no data) is SCTPs "close the
   // connection" message. This sets sock_ = NULL;
   if (!packet->buffer.size() || !packet->buffer.data()) {
     LOG(LS_INFO) << debug_name_ << "->OnInboundPacketFromSctpToChannel(...): "
                                    "No data, closing.";
     return;
   }
   if (packet->flags & MSG_NOTIFICATION) {
-    OnNotificationFromSctp(&packet->buffer);
+    OnNotificationFromSctp(packet->buffer);
   } else {
-    OnDataFromSctpToChannel(packet->params, &packet->buffer);
+    OnDataFromSctpToChannel(packet->params, packet->buffer);
   }
 }
 
 void SctpDataMediaChannel::OnDataFromSctpToChannel(
-    const ReceiveDataParams& params, rtc::Buffer* buffer) {
+    const ReceiveDataParams& params, const rtc::CopyOnWriteBuffer& buffer) {
   if (receiving_) {
     LOG(LS_VERBOSE) << debug_name_ << "->OnDataFromSctpToChannel(...): "
-                    << "Posting with length: " << buffer->size()
+                    << "Posting with length: " << buffer.size()
                     << " on stream " << params.ssrc;
     // Reports all received messages to upper layers, no matter whether the sid
     // is known.
-    SignalDataReceived(params, buffer->data<char>(), buffer->size());
+    SignalDataReceived(params, buffer.data<char>(), buffer.size());
   } else {
     LOG(LS_WARNING) << debug_name_ << "->OnDataFromSctpToChannel(...): "
                     << "Not receiving packet with sid=" << params.ssrc
-                    << " len=" << buffer->size() << " before SetReceive(true).";
+                    << " len=" << buffer.size() << " before SetReceive(true).";
   }
 }
 
 bool SctpDataMediaChannel::AddStream(const StreamParams& stream) {
   if (!stream.has_ssrcs()) {
     return false;
   }
 
   const uint32_t ssrc = stream.first_ssrc();
   if (ssrc >= cricket::kMaxSctpSid) {
@@ skipping 42 matching lines @@
   // SendQueuedStreamResets().
   queued_reset_streams_.insert(ssrc);
 
   // Signal our stream-reset logic that it should try to send now, if it can.
   SendQueuedStreamResets();
 
   // The stream will actually get removed when we get the acknowledgment.
   return true;
 }
 
-void SctpDataMediaChannel::OnNotificationFromSctp(rtc::Buffer* buffer) {
+void SctpDataMediaChannel::OnNotificationFromSctp(
+    const rtc::CopyOnWriteBuffer& buffer) {
   const sctp_notification& notification =
-      reinterpret_cast<const sctp_notification&>(*buffer->data());
-  ASSERT(notification.sn_header.sn_length == buffer->size());
+      reinterpret_cast<const sctp_notification&>(*buffer.data());
+  ASSERT(notification.sn_header.sn_length == buffer.size());
 
   // TODO(ldixon): handle notifications appropriately.
   switch (notification.sn_header.sn_type) {
     case SCTP_ASSOC_CHANGE:
       LOG(LS_VERBOSE) << "SCTP_ASSOC_CHANGE";
       OnNotificationAssocChange(notification.sn_assoc_change);
       break;
     case SCTP_REMOTE_ERROR:
       LOG(LS_INFO) << "SCTP_REMOTE_ERROR";
       break;
@@ skipping 172 matching lines @@
       &remote_port_);
 }
 
 bool SctpDataMediaChannel::SetRecvCodecs(const std::vector<DataCodec>& codecs) {
   return GetCodecIntParameter(
       codecs, kGoogleSctpDataCodecId, kGoogleSctpDataCodecName, kCodecParamPort,
       &local_port_);
 }
 
 void SctpDataMediaChannel::OnPacketFromSctpToNetwork(
-    rtc::Buffer* buffer) {
+    rtc::CopyOnWriteBuffer* buffer) {
   // usrsctp seems to interpret the MTU we give it strangely -- it seems to
   // give us back packets bigger than that MTU, if only by a fixed amount.
   // This is that amount that we've observed.
   const int kSctpOverhead = 76;
   if (buffer->size() > (kSctpOverhead + kSctpMtu)) {
     LOG(LS_ERROR) << debug_name_ << "->OnPacketFromSctpToNetwork(...): "
                   << "SCTP seems to have made a packet that is bigger "
                   << "than its official MTU: " << buffer->size()
                   << " vs max of " << kSctpMtu
                   << " even after adding " << kSctpOverhead
@@ skipping 52 matching lines @@
     }
     case MSG_SCTPOUTBOUNDPACKET: {
       std::unique_ptr<OutboundPacketMessage> pdata(
           static_cast<OutboundPacketMessage*>(msg->pdata));
       OnPacketFromSctpToNetwork(pdata->data().get());
       break;
     }
   }
 }
 }  // namespace cricket