Reland Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/media/base/rtpdataengine_unittest.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 <memory>
 #include <string>
 
-#include "webrtc/base/buffer.h"
+#include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/timing.h"
 #include "webrtc/media/base/fakenetworkinterface.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtpdataengine.h"
 #include "webrtc/media/base/rtputils.h"
 
 class FakeTiming : public rtc::Timing {
@@ skipping 92 matching lines @@
   cricket::ReceiveDataParams GetReceivedDataParams() {
     return receiver_->last_received_data_params();
   }
 
   bool HasSentData(int count) {
     return (iface_->NumRtpPackets() > count);
   }
 
   std::string GetSentData(int index) {
     // Assume RTP header of length 12
-    std::unique_ptr<const rtc::Buffer> packet(
+    std::unique_ptr<const rtc::CopyOnWriteBuffer> packet(
         iface_->GetRtpPacket(index));
     if (packet->size() > 12) {
       return std::string(packet->data<char>() + 12, packet->size() - 12);
     } else {
       return "";
     }
   }
 
   cricket::RtpHeader GetSentDataHeader(int index) {
-    std::unique_ptr<const rtc::Buffer> packet(
+    std::unique_ptr<const rtc::CopyOnWriteBuffer> packet(
         iface_->GetRtpPacket(index));
     cricket::RtpHeader header;
     GetRtpHeader(packet->data(), packet->size(), &header);
     return header;
   }
 
  private:
   std::unique_ptr<cricket::RtpDataEngine> dme_;
   // Timing passed into dme_.  Owned by dme_;
   FakeTiming* timing_;
@@ skipping 65 matching lines @@
   EXPECT_TRUE(dmc->RemoveRecvStream(41));
   EXPECT_TRUE(dmc->RemoveRecvStream(42));
 }
 
 TEST_F(RtpDataMediaChannelTest, SendData) {
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::SendDataParams params;
   params.ssrc = 42;
   unsigned char data[] = "food";
-  rtc::Buffer payload(data, 4);
+  rtc::CopyOnWriteBuffer payload(data, 4);
   unsigned char padded_data[] = {
     0x00, 0x00, 0x00, 0x00,
     'f', 'o', 'o', 'd',
   };
   cricket::SendDataResult result;
 
   // Not sending
   EXPECT_FALSE(dmc->SendData(params, payload, &result));
   EXPECT_EQ(cricket::SDR_ERROR, result);
   EXPECT_FALSE(HasSentData(0));
@@ skipping 16 matching lines @@
   cricket::DataCodec codec;
   codec.id = 103;
   codec.name = cricket::kGoogleRtpDataCodecName;
   cricket::DataSendParameters parameters;
   parameters.codecs.push_back(codec);
   ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
   // Length too large;
   std::string x10000(10000, 'x');
   EXPECT_FALSE(dmc->SendData(
-      params, rtc::Buffer(x10000.data(), x10000.length()), &result));
+      params, rtc::CopyOnWriteBuffer(x10000.data(), x10000.length()), &result));
   EXPECT_EQ(cricket::SDR_ERROR, result);
   EXPECT_FALSE(HasSentData(0));
 
   // Finally works!
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
   EXPECT_EQ(cricket::SDR_SUCCESS, result);
   ASSERT_TRUE(HasSentData(0));
   EXPECT_EQ(sizeof(padded_data), GetSentData(0).length());
   EXPECT_EQ(0, memcmp(
       padded_data, GetSentData(0).data(), sizeof(padded_data)));
@@ skipping 47 matching lines @@
   parameters.codecs.push_back(codec);
   ASSERT_TRUE(dmc1->SetSendParameters(parameters));
   ASSERT_TRUE(dmc2->SetSendParameters(parameters));
 
   cricket::SendDataParams params1;
   params1.ssrc = 41;
   cricket::SendDataParams params2;
   params2.ssrc = 42;
 
   unsigned char data[] = "foo";
-  rtc::Buffer payload(data, 3);
+  rtc::CopyOnWriteBuffer payload(data, 3);
   cricket::SendDataResult result;
 
   EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
   EXPECT_TRUE(dmc2->SendData(params2, payload, &result));
 
   // Should bump timestamp by 90000 because the clock rate is 90khz.
   timing1->set_now(1);
   // Should bump timestamp by 180000 because the clock rate is 90khz.
   timing2->set_now(2);
 
@@ skipping 26 matching lines @@
   parameters.codecs.push_back(codec);
   ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
   cricket::StreamParams stream;
   stream.add_ssrc(42);
   ASSERT_TRUE(dmc->AddSendStream(stream));
 
   cricket::SendDataParams params;
   params.ssrc = 42;
   unsigned char data[] = "food";
-  rtc::Buffer payload(data, 4);
+  rtc::CopyOnWriteBuffer payload(data, 4);
   cricket::SendDataResult result;
 
   // With rtp overhead of 32 bytes, each one of our packets is 36
   // bytes, or 288 bits.  So, a limit of 872bps will allow 3 packets,
   // but not four.
   parameters.max_bandwidth_bps = 872;
   ASSERT_TRUE(dmc->SetSendParameters(parameters));
 
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
   EXPECT_TRUE(dmc->SendData(params, payload, &result));
@@ skipping 17 matching lines @@
   EXPECT_FALSE(dmc->SendData(params, payload, &result));
 }
 
 TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   // PT= 103, SN=2, TS=3, SSRC = 4, data = "abcde"
   unsigned char data[] = {
     0x80, 0x67, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2A,
     0x00, 0x00, 0x00, 0x00,
     'a', 'b', 'c', 'd', 'e'
   };
-  rtc::Buffer packet(data, sizeof(data));
+  rtc::CopyOnWriteBuffer packet(data, sizeof(data));
 
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // SetReceived not called.
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   dmc->SetReceive(true);
 
   // Unknown payload id
@@ skipping 19 matching lines @@
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_TRUE(HasReceivedData());
   EXPECT_EQ("abcde", GetReceivedData());
   EXPECT_EQ(5U, GetReceivedDataLen());
 }
 
 TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
   unsigned char data[] = {
     0x80, 0x65, 0x00, 0x02
   };
-  rtc::Buffer packet(data, sizeof(data));
+  rtc::CopyOnWriteBuffer packet(data, sizeof(data));
 
   std::unique_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // Too short
   dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 }