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

webrtc/media/base/fakenetworkinterface.h

Index: webrtc/media/base/fakenetworkinterface.h
diff --git a/webrtc/media/base/fakenetworkinterface.h b/webrtc/media/base/fakenetworkinterface.h
index 65dac2529b4ae778af9b3205180a4223eafb8fec..d9caac0197910281dd93ba31e3fe98151dc19844 100644
--- a/webrtc/media/base/fakenetworkinterface.h
+++ b/webrtc/media/base/fakenetworkinterface.h
@@ -14,8 +14,8 @@
 #include <map>
 #include <vector>
 
+#include "webrtc/base/buffer.h"
 #include "webrtc/base/byteorder.h"
-#include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/messagehandler.h"
@@ -84,12 +84,12 @@
   }
 
   // Note: callers are responsible for deleting the returned buffer.
-  const rtc::CopyOnWriteBuffer* GetRtpPacket(int index) {
+  const rtc::Buffer* GetRtpPacket(int index) {
     rtc::CritScope cs(&crit_);
     if (index >= NumRtpPackets()) {
       return NULL;
     }
-    return new rtc::CopyOnWriteBuffer(rtp_packets_[index]);
+    return new rtc::Buffer(rtp_packets_[index]);
   }
 
   int NumRtcpPackets() {
@@ -98,12 +98,12 @@
   }
 
   // Note: callers are responsible for deleting the returned buffer.
-  const rtc::CopyOnWriteBuffer* GetRtcpPacket(int index) {
+  const rtc::Buffer* GetRtcpPacket(int index) {
     rtc::CritScope cs(&crit_);
     if (index >= NumRtcpPackets()) {
       return NULL;
     }
-    return new rtc::CopyOnWriteBuffer(rtcp_packets_[index]);
+    return new rtc::Buffer(rtcp_packets_[index]);
   }
 
   int sendbuf_size() const { return sendbuf_size_; }
@@ -111,7 +111,7 @@
   rtc::DiffServCodePoint dscp() const { return dscp_; }
 
  protected:
-  virtual bool SendPacket(rtc::CopyOnWriteBuffer* packet,
+  virtual bool SendPacket(rtc::Buffer* packet,
                           const rtc::PacketOptions& options) {
     rtc::CritScope cs(&crit_);
 
@@ -123,12 +123,13 @@
 
     rtp_packets_.push_back(*packet);
     if (conf_) {
+      rtc::Buffer buffer_copy(*packet);
       for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) {
-        if (!SetRtpSsrc(packet->data(), packet->size(),
+        if (!SetRtpSsrc(buffer_copy.data(), buffer_copy.size(),
                         conf_sent_ssrcs_[i])) {
           return false;
         }
-        PostMessage(ST_RTP, *packet);
+        PostMessage(ST_RTP, buffer_copy);
       }
     } else {
       PostMessage(ST_RTP, *packet);
@@ -136,7 +137,7 @@
     return true;
   }
 
-  virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
+  virtual bool SendRtcp(rtc::Buffer* packet,
                         const rtc::PacketOptions& options) {
     rtc::CritScope cs(&crit_);
     rtcp_packets_.push_back(*packet);
@@ -159,13 +160,13 @@
     return 0;
   }
 
-  void PostMessage(int id, const rtc::CopyOnWriteBuffer& packet) {
+  void PostMessage(int id, const rtc::Buffer& packet) {
     thread_->Post(this, id, rtc::WrapMessageData(packet));
   }
 
   virtual void OnMessage(rtc::Message* msg) {
-    rtc::TypedMessageData<rtc::CopyOnWriteBuffer>* msg_data =
-        static_cast<rtc::TypedMessageData<rtc::CopyOnWriteBuffer>*>(
+    rtc::TypedMessageData<rtc::Buffer>* msg_data =
+        static_cast<rtc::TypedMessageData<rtc::Buffer>*>(
             msg->pdata);
     if (dest_) {
       if (msg->message_id == ST_RTP) {
@@ -215,8 +216,8 @@
   // Map to track packet-number that needs to be dropped per ssrc.
   std::map<uint32_t, std::set<uint32_t> > drop_map_;
   rtc::CriticalSection crit_;
-  std::vector<rtc::CopyOnWriteBuffer> rtp_packets_;
-  std::vector<rtc::CopyOnWriteBuffer> rtcp_packets_;
+  std::vector<rtc::Buffer> rtp_packets_;
+  std::vector<rtc::Buffer> rtcp_packets_;
   int sendbuf_size_;
   int recvbuf_size_;
   rtc::DiffServCodePoint dscp_;