SignalPacketReceived should pass packet as a pointer instead of a non-const reference.

webrtc/pc/channel.cc

 /*
  *  Copyright 2004 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 730 matching lines @@
   // Bon voyage.
   int flags = (secure() && secure_dtls()) ? PF_SRTP_BYPASS : PF_NORMAL;
   return rtp_transport_->SendPacket(rtcp, packet, updated_options, flags);
 }
 
 bool BaseChannel::HandlesPayloadType(int packet_type) const {
   return rtp_transport_->HandlesPayloadType(packet_type);
 }
 
 void BaseChannel::OnPacketReceived(bool rtcp,
-                                   rtc::CopyOnWriteBuffer& packet,
+                                   rtc::CopyOnWriteBuffer* packet,
                                    const rtc::PacketTime& packet_time) {
   if (!has_received_packet_ && !rtcp) {
     has_received_packet_ = true;
     signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
   }
 
   // Unprotect the packet, if needed.
   if (srtp_filter_.IsActive()) {
     TRACE_EVENT0("webrtc", "SRTP Decode");
-    char* data = packet.data<char>();
-    int len = static_cast<int>(packet.size());
+    char* data = packet->data<char>();
+    int len = static_cast<int>(packet->size());
     bool res;
     if (!rtcp) {
       res = srtp_filter_.UnprotectRtp(data, len, &len);
       if (!res) {
         int seq_num = -1;
         uint32_t ssrc = 0;
         GetRtpSeqNum(data, len, &seq_num);
         GetRtpSsrc(data, len, &ssrc);
         LOG(LS_ERROR) << "Failed to unprotect " << content_name_
                       << " RTP packet: size=" << len << ", seqnum=" << seq_num
                       << ", SSRC=" << ssrc;
         return;
       }
     } else {
       res = srtp_filter_.UnprotectRtcp(data, len, &len);
       if (!res) {
         int type = -1;
         GetRtcpType(data, len, &type);
         LOG(LS_ERROR) << "Failed to unprotect " << content_name_
                       << " RTCP packet: size=" << len << ", type=" << type;
         return;
       }
     }
 
-    packet.SetSize(len);
+    packet->SetSize(len);
   } else if (srtp_required_) {
     // Our session description indicates that SRTP is required, but we got a
     // packet before our SRTP filter is active. This means either that
     // a) we got SRTP packets before we received the SDES keys, in which case
     //    we can't decrypt it anyway, or
     // b) we got SRTP packets before DTLS completed on both the RTP and RTCP
     //    transports, so we haven't yet extracted keys, even if DTLS did
     //    complete on the transport that the packets are being sent on. It's
     //    really good practice to wait for both RTP and RTCP to be good to go
     //    before sending  media, to prevent weird failure modes, so it's fine
     //    for us to just eat packets here. This is all sidestepped if RTCP mux
     //    is used anyway.
     LOG(LS_WARNING) << "Can't process incoming " << RtpRtcpStringLiteral(rtcp)
                     << " packet when SRTP is inactive and crypto is required";
     return;
   }
 
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
-      Bind(&BaseChannel::ProcessPacket, this, rtcp, packet, packet_time));
+      Bind(&BaseChannel::ProcessPacket, this, rtcp, *packet, packet_time));
 }
 
 void BaseChannel::ProcessPacket(bool rtcp,
                                 const rtc::CopyOnWriteBuffer& packet,
                                 const rtc::PacketTime& packet_time) {
   RTC_DCHECK(worker_thread_->IsCurrent());
 
   // Need to copy variable because OnRtcpReceived/OnPacketReceived
   // requires non-const pointer to buffer. This doesn't memcpy the actual data.
   rtc::CopyOnWriteBuffer data(packet);
@@ skipping 853 matching lines @@
 
 int VoiceChannel::GetOutputLevel_w() {
   return media_channel()->GetOutputLevel();
 }
 
 void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
   media_channel()->GetActiveStreams(actives);
 }
 
 void VoiceChannel::OnPacketReceived(bool rtcp,
-                                    rtc::CopyOnWriteBuffer& packet,
+                                    rtc::CopyOnWriteBuffer* packet,
                                     const rtc::PacketTime& packet_time) {
   BaseChannel::OnPacketReceived(rtcp, packet, packet_time);
   // Set a flag when we've received an RTP packet. If we're waiting for early
   // media, this will disable the timeout.
   if (!received_media_ && !rtcp) {
     received_media_ = true;
   }
 }
 
 void BaseChannel::UpdateMediaSendRecvState() {
@@ skipping 756 matching lines @@
 
 void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
   // This is usded for congestion control to indicate that the stream is ready
   // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
   // that the transport channel is ready.
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 }  // namespace cricket