Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/api/datachannel.h

 /*
  *  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 13 matching lines @@
 #include "webrtc/pc/channel.h"
 
 namespace webrtc {
 
 class DataChannel;
 
 class DataChannelProviderInterface {
  public:
   // Sends the data to the transport.
   virtual bool SendData(const cricket::SendDataParams& params,
-                        const rtc::Buffer& payload,
+                        const rtc::CopyOnWriteBuffer& payload,
                         cricket::SendDataResult* result) = 0;
   // Connects to the transport signals.
   virtual bool ConnectDataChannel(DataChannel* data_channel) = 0;
   // Disconnects from the transport signals.
   virtual void DisconnectDataChannel(DataChannel* data_channel) = 0;
   // Adds the data channel SID to the transport for SCTP.
   virtual void AddSctpDataStream(int sid) = 0;
   // Removes the data channel SID from the transport for SCTP.
   virtual void RemoveSctpDataStream(int sid) = 0;
   // Returns true if the transport channel is ready to send data.
@@ skipping 91 matching lines @@
   virtual void OnMessage(rtc::Message* msg);
 
   // Called when the channel's ready to use.  That can happen when the
   // underlying DataMediaChannel becomes ready, or when this channel is a new
   // stream on an existing DataMediaChannel, and we've finished negotiation.
   void OnChannelReady(bool writable);
 
   // Sigslots from cricket::DataChannel
   void OnDataReceived(cricket::DataChannel* channel,
                       const cricket::ReceiveDataParams& params,
-                      const rtc::Buffer& payload);
+                      const rtc::CopyOnWriteBuffer& payload);
   void OnStreamClosedRemotely(uint32_t sid);
 
   // The remote peer request that this channel should be closed.
   void RemotePeerRequestClose();
 
   // The following methods are for SCTP only.
 
   // Sets the SCTP sid and adds to transport layer if not set yet. Should only
   // be called once.
   void SetSctpSid(int sid);
@@ skipping 72 matching lines @@
   void SetState(DataState state);
   void DisconnectFromProvider();
 
   void DeliverQueuedReceivedData();
 
   void SendQueuedDataMessages();
   bool SendDataMessage(const DataBuffer& buffer, bool queue_if_blocked);
   bool QueueSendDataMessage(const DataBuffer& buffer);
 
   void SendQueuedControlMessages();
-  void QueueControlMessage(const rtc::Buffer& buffer);
-  bool SendControlMessage(const rtc::Buffer& buffer);
+  void QueueControlMessage(const rtc::CopyOnWriteBuffer& buffer);
+  bool SendControlMessage(const rtc::CopyOnWriteBuffer& buffer);
 
   std::string label_;
   InternalDataChannelInit config_;
   DataChannelObserver* observer_;
   DataState state_;
   cricket::DataChannelType data_channel_type_;
   DataChannelProviderInterface* provider_;
   HandshakeState handshake_state_;
   bool connected_to_provider_;
   bool send_ssrc_set_;
@@ skipping 22 matching lines @@
   PROXY_CONSTMETHOD0(int, id)
   PROXY_CONSTMETHOD0(DataState, state)
   PROXY_CONSTMETHOD0(uint64_t, buffered_amount)
   PROXY_METHOD0(void, Close)
   PROXY_METHOD1(bool, Send, const DataBuffer&)
 END_PROXY()
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_DATACHANNEL_H_