Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/media/sctp/sctpdataengine.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MEDIA_SCTP_SCTPDATAENGINE_H_
 #define WEBRTC_MEDIA_SCTP_SCTPDATAENGINE_H_
 
 #include <errno.h>
 #include <string>
 #include <vector>
 
 namespace cricket {
 // Some ERRNO values get re-#defined to WSA* equivalents in some talk/
 // headers.  We save the original ones in an enum.
 enum PreservedErrno {
   SCTP_EINPROGRESS = EINPROGRESS,
   SCTP_EWOULDBLOCK = EWOULDBLOCK
 };
 }  // namespace cricket
 
-#include "webrtc/base/buffer.h"
+#include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/mediaengine.h"
 
 // Defined by "usrsctplib/usrsctp.h"
 struct sockaddr_conn;
 struct sctp_assoc_change;
 struct sctp_stream_reset_event;
 // Defined by <sys/socket.h>
 struct socket;
@@ skipping 99 matching lines @@
   virtual bool AddRecvStream(const StreamParams& sp);
   virtual bool RemoveRecvStream(uint32_t ssrc);
 
   // Called when Sctp gets data. The data may be a notification or data for
   // OnSctpInboundData. Called from the worker thread.
   virtual void OnMessage(rtc::Message* msg);
   // Send data down this channel (will be wrapped as SCTP packets then given to
   // sctp that will then post the network interface by OnMessage).
   // Returns true iff successful data somewhere on the send-queue/network.
   virtual bool SendData(const SendDataParams& params,
-                        const rtc::Buffer& payload,
+                        const rtc::CopyOnWriteBuffer& payload,
                         SendDataResult* result = NULL);
   // A packet is received from the network interface. Posted to OnMessage.
-  virtual void OnPacketReceived(rtc::Buffer* packet,
+  virtual void OnPacketReceived(rtc::CopyOnWriteBuffer* packet,
                                 const rtc::PacketTime& packet_time);
 
   // Exposed to allow Post call from c-callbacks.
   rtc::Thread* worker_thread() const { return worker_thread_; }
 
   // Many of these things are unused by SCTP, but are needed to fulfill
   // the MediaChannel interface.
-  virtual void OnRtcpReceived(rtc::Buffer* packet,
+  virtual void OnRtcpReceived(rtc::CopyOnWriteBuffer* packet,
                               const rtc::PacketTime& packet_time) {}
   virtual void OnReadyToSend(bool ready) {}
 
   void OnSendThresholdCallback();
   // Helper for debugging.
   void set_debug_name(const std::string& debug_name) {
     debug_name_ = debug_name;
   }
   const std::string& debug_name() const { return debug_name_; }
   const struct socket* socket() const { return sock_; }
@@ skipping 16 matching lines @@
 
   // Sends a SCTP_RESET_STREAM for all streams in closing_ssids_.
   bool SendQueuedStreamResets();
 
   // Adds a stream.
   bool AddStream(const StreamParams &sp);
   // Queues a stream for reset.
   bool ResetStream(uint32_t ssrc);
 
   // Called by OnMessage to send packet on the network.
-  void OnPacketFromSctpToNetwork(rtc::Buffer* buffer);
+  void OnPacketFromSctpToNetwork(rtc::CopyOnWriteBuffer* buffer);
   // Called by OnMessage to decide what to do with the packet.
   void OnInboundPacketFromSctpToChannel(SctpInboundPacket* packet);
   void OnDataFromSctpToChannel(const ReceiveDataParams& params,
-                               rtc::Buffer* buffer);
-  void OnNotificationFromSctp(rtc::Buffer* buffer);
+                               const rtc::CopyOnWriteBuffer& buffer);
+  void OnNotificationFromSctp(const rtc::CopyOnWriteBuffer& buffer);
   void OnNotificationAssocChange(const sctp_assoc_change& change);
 
   void OnStreamResetEvent(const struct sctp_stream_reset_event* evt);
 
   // Responsible for marshalling incoming data to the channels listeners, and
   // outgoing data to the network interface.
   rtc::Thread* worker_thread_;
   // The local and remote SCTP port to use. These are passed along the wire
   // and the listener and connector must be using the same port. It is not
   // related to the ports at the IP level.  If set to -1, we default to
@@ skipping 18 matching lines @@
   StreamSet queued_reset_streams_;
   StreamSet sent_reset_streams_;
 
   // A human-readable name for debugging messages.
   std::string debug_name_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_SCTP_SCTPDATAENGINE_H_