Revert of Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/media/sctp/sctpdataengine_unittest.cc

 /*
  *  Copyright (c) 2013 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 <errno.h>
 #include <stdarg.h>
 #include <stdio.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/bind.h"
-#include "webrtc/base/copyonwritebuffer.h"
+#include "webrtc/base/buffer.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/sctp/sctpdataengine.h"
 
 enum {
   MSG_PACKET = 1,
 };
 
 // Fake NetworkInterface that sends/receives sctp packets.  The one in
 // webrtc/media/base/fakenetworkinterface.h only works with rtp/rtcp.
 class SctpFakeNetworkInterface : public cricket::MediaChannel::NetworkInterface,
                                  public rtc::MessageHandler {
  public:
   explicit SctpFakeNetworkInterface(rtc::Thread* thread)
     : thread_(thread),
       dest_(NULL) {
   }
 
   void SetDestination(cricket::DataMediaChannel* dest) { dest_ = dest; }
 
  protected:
   // Called to send raw packet down the wire (e.g. SCTP an packet).
-  virtual bool SendPacket(rtc::CopyOnWriteBuffer* packet,
+  virtual bool SendPacket(rtc::Buffer* packet,
                           const rtc::PacketOptions& options) {
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket";
 
-    rtc::CopyOnWriteBuffer* buffer = new rtc::CopyOnWriteBuffer(*packet);
+    // TODO(ldixon): Can/should we use Buffer.TransferTo here?
+    // Note: this assignment does a deep copy of data from packet.
+    rtc::Buffer* buffer = new rtc::Buffer(packet->data(), packet->size());
     thread_->Post(this, MSG_PACKET, rtc::WrapMessageData(buffer));
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket, Posted message.";
     return true;
   }
 
   // Called when a raw packet has been recieved. This passes the data to the
   // code that will interpret the packet. e.g. to get the content payload from
   // an SCTP packet.
   virtual void OnMessage(rtc::Message* msg) {
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::OnMessage";
-    std::unique_ptr<rtc::CopyOnWriteBuffer> buffer(
-        static_cast<rtc::TypedMessageData<rtc::CopyOnWriteBuffer*>*>(
+    std::unique_ptr<rtc::Buffer> buffer(
+        static_cast<rtc::TypedMessageData<rtc::Buffer*>*>(
             msg->pdata)->data());
     if (dest_) {
       dest_->OnPacketReceived(buffer.get(), rtc::PacketTime());
     }
     delete msg->pdata;
   }
 
   // Unsupported functions required to exist by NetworkInterface.
   // TODO(ldixon): Refactor parent NetworkInterface class so these are not
   // required. They are RTC specific and should be in an appropriate subclass.
-  virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
+  virtual bool SendRtcp(rtc::Buffer* packet,
                         const rtc::PacketOptions& options) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SendRtcp.";
     return false;
   }
   virtual int SetOption(SocketType type, rtc::Socket::Option opt,
                         int option) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
     return 0;
   }
   virtual void SetDefaultDSCPCode(rtc::DiffServCodePoint dscp) {
@@ skipping 186 matching lines @@
     return channel;
   }
 
   bool SendData(cricket::SctpDataMediaChannel* chan,
                 uint32_t ssrc,
                 const std::string& msg,
                 cricket::SendDataResult* result) {
     cricket::SendDataParams params;
     params.ssrc = ssrc;
 
-    return chan->SendData(params, rtc::CopyOnWriteBuffer(
+    return chan->SendData(params, rtc::Buffer(
         &msg[0], msg.length()), result);
   }
 
   bool ReceivedData(const SctpFakeDataReceiver* recv,
                     uint32_t ssrc,
                     const std::string& msg) {
     return (recv->received() &&
             recv->last_params().ssrc == ssrc &&
             recv->last_data() == msg);
   }
@@ skipping 98 matching lines @@
   SetupConnectedChannels();
 
   cricket::SendDataResult result;
   cricket::SendDataParams params;
   params.ssrc = 1;
 
   std::vector<char> buffer(1024 * 64, 0);
 
   for (size_t i = 0; i < 100; ++i) {
     channel1()->SendData(
-        params, rtc::CopyOnWriteBuffer(&buffer[0], buffer.size()), &result);
+        params, rtc::Buffer(&buffer[0], buffer.size()), &result);
     if (result == cricket::SDR_BLOCK)
       break;
   }
 
   EXPECT_EQ(cricket::SDR_BLOCK, result);
 }
 
 TEST_F(SctpDataMediaChannelTest, ClosesRemoteStream) {
   SetupConnectedChannels();
   SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
@@ skipping 102 matching lines @@
   // Channel 1 is gone now.
 
   // Create a new channel 1.
   AddStream(1);
   ASSERT_TRUE(SendData(channel1(), 1, "hi?", &result));
   EXPECT_EQ(cricket::SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), 1000);
   channel1()->RemoveSendStream(1);
   EXPECT_TRUE_WAIT(chan_2_sig_receiver.StreamCloseCount(1) == 2, 1000);
 }