Remove media sinks from Channel.

talk/session/media/channel.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 484 matching lines @@
   }
 
   // Protect ourselves against crazy data.
   if (!ValidPacket(rtcp, packet)) {
     LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
                   << PacketType(rtcp)
                   << " packet: wrong size=" << packet->size();
     return false;
   }
 
-  // Signal to the media sink before protecting the packet.
-  {
-    rtc::CritScope cs(&signal_send_packet_cs_);
-    SignalSendPacketPreCrypto(packet->data(), packet->size(), rtcp);
-  }
-
   rtc::PacketOptions options(dscp);
   // Protect if needed.
   if (srtp_filter_.IsActive()) {
     bool res;
     uint8_t* data = packet->data();
     int len = static_cast<int>(packet->size());
     if (!rtcp) {
     // If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done
     // inside libsrtp for a RTP packet. A external HMAC module will be writing
     // a fake HMAC value. This is ONLY done for a RTP packet.
@@ skipping 48 matching lines @@
     packet->SetSize(len);
   } else if (secure_required_) {
     // This is a double check for something that supposedly can't happen.
     LOG(LS_ERROR) << "Can't send outgoing " << PacketType(rtcp)
                   << " packet when SRTP is inactive and crypto is required";
 
     ASSERT(false);
     return false;
   }
 
-  // Signal to the media sink after protecting the packet.
-  {
-    rtc::CritScope cs(&signal_send_packet_cs_);
-    SignalSendPacketPostCrypto(packet->data(), packet->size(), rtcp);
-  }
-
   // Bon voyage.
   int ret =
       channel->SendPacket(packet->data<char>(), packet->size(), options,
                           (secure() && secure_dtls()) ? PF_SRTP_BYPASS : 0);
   if (ret != static_cast<int>(packet->size())) {
     if (channel->GetError() == EWOULDBLOCK) {
       LOG(LS_WARNING) << "Got EWOULDBLOCK from socket.";
       SetReadyToSend(channel, false);
     }
     return false;
@@ skipping 20 matching lines @@
     return;
   }
 
   // We are only interested in the first rtp packet because that
   // indicates the media has started flowing.
   if (!has_received_packet_ && !rtcp) {
     has_received_packet_ = true;
     signaling_thread()->Post(this, MSG_FIRSTPACKETRECEIVED);
   }
 
-  // Signal to the media sink before unprotecting the packet.
-  {
-    rtc::CritScope cs(&signal_recv_packet_cs_);
-    SignalRecvPacketPostCrypto(packet->data(), packet->size(), rtcp);
-  }
-
   // Unprotect the packet, if needed.
   if (srtp_filter_.IsActive()) {
     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 ssrc = 0;
@@ skipping 25 matching lines @@
     //    channels, so we haven't yet extracted keys, even if DTLS did complete
     //    on the channel 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 " << PacketType(rtcp)
                     << " packet when SRTP is inactive and crypto is required";
     return;
   }
 
-  // Signal to the media sink after unprotecting the packet.
-  {
-    rtc::CritScope cs(&signal_recv_packet_cs_);
-    SignalRecvPacketPreCrypto(packet->data(), packet->size(), rtcp);
-  }
-
   // Push it down to the media channel.
   if (!rtcp) {
     media_channel_->OnPacketReceived(packet, packet_time);
   } else {
     media_channel_->OnRtcpReceived(packet, packet_time);
   }
 }
 
 void BaseChannel::OnNewLocalDescription(
     BaseSession* session, ContentAction action) {
@@ skipping 1834 matching lines @@
   return (data_channel_type_ == DCT_RTP);
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32 sid) {
   rtc::TypedMessageData<uint32>* message =
       new rtc::TypedMessageData<uint32>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
 }  // namespace cricket