Merge "Merge upstream-master and enable ARM64" into emu-master-devemu-31-stable-releaseemu-31-release

1 files changed, 76 insertions, 188 deletions

diff --git a/pc/channel.cc b/pc/channel.cc
index 5c0b204cf0..8630703be1 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -44,11 +44,6 @@ using ::webrtc::PendingTaskSafetyFlag;
 using ::webrtc::SdpType;
 using ::webrtc::ToQueuedTask;
 
-struct SendPacketMessageData : public rtc::MessageData {
-  rtc::CopyOnWriteBuffer packet;
-  rtc::PacketOptions options;
-};
-
 // Finds a stream based on target's Primary SSRC or RIDs.
 // This struct is used in BaseChannel::UpdateLocalStreams_w.
 struct StreamFinder {
@@ -84,14 +79,6 @@ struct StreamFinder {
 
 }  // namespace
 
-enum {
-  MSG_SEND_RTP_PACKET = 1,
-  MSG_SEND_RTCP_PACKET,
-  MSG_READYTOSENDDATA,
-  MSG_DATARECEIVED,
-  MSG_FIRSTPACKETRECEIVED,
-};
-
 static void SafeSetError(const std::string& message, std::string* error_desc) {
   if (error_desc) {
     *error_desc = message;
@@ -156,7 +143,6 @@ BaseChannel::~BaseChannel() {
 
   // Eats any outstanding messages or packets.
   alive_->SetNotAlive();
-  signaling_thread_->Clear(this);
   // The media channel is destroyed at the end of the destructor, since it
   // is a std::unique_ptr. The transport channel (rtp_transport) must outlive
   // the media channel.
@@ -210,33 +196,31 @@ void BaseChannel::DisconnectFromRtpTransport() {
 void BaseChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
   RTC_DCHECK_RUN_ON(worker_thread());
 
-  network_thread_->Invoke<void>(
-      RTC_FROM_HERE, [this, rtp_transport] { SetRtpTransport(rtp_transport); });
-
-  // Both RTP and RTCP channels should be set, we can call SetInterface on
-  // the media channel and it can set network options.
-  media_channel_->SetInterface(this);
+  network_thread_->Invoke<void>(RTC_FROM_HERE, [this, rtp_transport] {
+    SetRtpTransport(rtp_transport);
+    // Both RTP and RTCP channels should be set, we can call SetInterface on
+    // the media channel and it can set network options.
+    media_channel_->SetInterface(this);
+  });
 }
 
 void BaseChannel::Deinit() {
   RTC_DCHECK_RUN_ON(worker_thread());
-  media_channel_->SetInterface(/*iface=*/nullptr);
   // Packets arrive on the network thread, processing packets calls virtual
   // functions, so need to stop this process in Deinit that is called in
   // derived classes destructor.
   network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
     RTC_DCHECK_RUN_ON(network_thread());
-    FlushRtcpMessages_n();
+    media_channel_->SetInterface(/*iface=*/nullptr);
 
     if (rtp_transport_) {
       DisconnectFromRtpTransport();
     }
-    // Clear pending read packets/messages.
-    network_thread_->Clear(this);
   });
 }
 
 bool BaseChannel::SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) {
+  TRACE_EVENT0("webrtc", "BaseChannel::SetRtpTransport");
   RTC_DCHECK_RUN_ON(network_thread());
   if (rtp_transport == rtp_transport_) {
     return true;
@@ -271,56 +255,59 @@ bool BaseChannel::SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) {
   return true;
 }
 
-bool BaseChannel::Enable(bool enable) {
-  worker_thread_->Invoke<void>(RTC_FROM_HERE, [this, enable] {
+void BaseChannel::Enable(bool enable) {
+  RTC_DCHECK_RUN_ON(signaling_thread());
+
+  if (enable == enabled_s_)
+    return;
+
+  enabled_s_ = enable;
+
+  worker_thread_->PostTask(ToQueuedTask(alive_, [this, enable] {
     RTC_DCHECK_RUN_ON(worker_thread());
+    // Sanity check to make sure that enabled_ and enabled_s_
+    // stay in sync.
+    RTC_DCHECK_NE(enabled_, enable);
     if (enable) {
       EnableMedia_w();
     } else {
       DisableMedia_w();
     }
-  });
-  return true;
+  }));
 }
 
 bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
                                   SdpType type,
                                   std::string* error_desc) {
+  RTC_DCHECK_RUN_ON(worker_thread());
   TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent");
-  return InvokeOnWorker<bool>(RTC_FROM_HERE, [this, content, type, error_desc] {
-    RTC_DCHECK_RUN_ON(worker_thread());
-    return SetLocalContent_w(content, type, error_desc);
-  });
+  return SetLocalContent_w(content, type, error_desc);
 }
 
 bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
                                    SdpType type,
                                    std::string* error_desc) {
+  RTC_DCHECK_RUN_ON(worker_thread());
   TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent");
-  return InvokeOnWorker<bool>(RTC_FROM_HERE, [this, content, type, error_desc] {
-    RTC_DCHECK_RUN_ON(worker_thread());
-    return SetRemoteContent_w(content, type, error_desc);
-  });
+  return SetRemoteContent_w(content, type, error_desc);
 }
 
 bool BaseChannel::SetPayloadTypeDemuxingEnabled(bool enabled) {
+  RTC_DCHECK_RUN_ON(worker_thread());
   TRACE_EVENT0("webrtc", "BaseChannel::SetPayloadTypeDemuxingEnabled");
-  return InvokeOnWorker<bool>(RTC_FROM_HERE, [this, enabled] {
-    RTC_DCHECK_RUN_ON(worker_thread());
-    return SetPayloadTypeDemuxingEnabled_w(enabled);
-  });
+  return SetPayloadTypeDemuxingEnabled_w(enabled);
 }
 
 bool BaseChannel::IsReadyToReceiveMedia_w() const {
   // Receive data if we are enabled and have local content,
-  return enabled() &&
+  return enabled_ &&
          webrtc::RtpTransceiverDirectionHasRecv(local_content_direction_);
 }
 
 bool BaseChannel::IsReadyToSendMedia_w() const {
   // Send outgoing data if we are enabled, have local and remote content,
   // and we have had some form of connectivity.
-  return enabled() &&
+  return enabled_ &&
          webrtc::RtpTransceiverDirectionHasRecv(remote_content_direction_) &&
          webrtc::RtpTransceiverDirectionHasSend(local_content_direction_) &&
          was_ever_writable();
@@ -339,15 +326,7 @@ bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
 int BaseChannel::SetOption(SocketType type,
                            rtc::Socket::Option opt,
                            int value) {
-  return network_thread_->Invoke<int>(RTC_FROM_HERE, [this, type, opt, value] {
-    RTC_DCHECK_RUN_ON(network_thread());
-    return SetOption_n(type, opt, value);
-  });
-}
-
-int BaseChannel::SetOption_n(SocketType type,
-                             rtc::Socket::Option opt,
-                             int value) {
+  RTC_DCHECK_RUN_ON(network_thread());
   RTC_DCHECK(rtp_transport_);
   switch (type) {
     case ST_RTP:
@@ -387,9 +366,11 @@ void BaseChannel::OnNetworkRouteChanged(
   media_channel_->OnNetworkRouteChanged(transport_name_, new_route);
 }
 
-sigslot::signal1<ChannelInterface*>& BaseChannel::SignalFirstPacketReceived() {
-  RTC_DCHECK_RUN_ON(signaling_thread_);
-  return SignalFirstPacketReceived_;
+void BaseChannel::SetFirstPacketReceivedCallback(
+    std::function<void()> callback) {
+  RTC_DCHECK_RUN_ON(network_thread());
+  RTC_DCHECK(!on_first_packet_received_ || !callback);
+  on_first_packet_received_ = std::move(callback);
 }
 
 void BaseChannel::OnTransportReadyToSend(bool ready) {
@@ -400,6 +381,7 @@ void BaseChannel::OnTransportReadyToSend(bool ready) {
 bool BaseChannel::SendPacket(bool rtcp,
                              rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options) {
+  RTC_DCHECK_RUN_ON(network_thread());
   // Until all the code is migrated to use RtpPacketType instead of bool.
   RtpPacketType packet_type = rtcp ? RtpPacketType::kRtcp : RtpPacketType::kRtp;
   // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
@@ -409,16 +391,6 @@ bool BaseChannel::SendPacket(bool rtcp,
   // SRTP and the inner workings of the transport channels.
   // The only downside is that we can't return a proper failure code if
   // needed. Since UDP is unreliable anyway, this should be a non-issue.
-  if (!network_thread_->IsCurrent()) {
-    // Avoid a copy by transferring the ownership of the packet data.
-    int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
-    SendPacketMessageData* data = new SendPacketMessageData;
-    data->packet = std::move(*packet);
-    data->options = options;
-    network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
-    return true;
-  }
-  RTC_DCHECK_RUN_ON(network_thread());
 
   TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
 
@@ -466,16 +438,11 @@ bool BaseChannel::SendPacket(bool rtcp,
 }
 
 void BaseChannel::OnRtpPacket(const webrtc::RtpPacketReceived& parsed_packet) {
-  // Take packet time from the |parsed_packet|.
-  // RtpPacketReceived.arrival_time_ms = (timestamp_us + 500) / 1000;
-  int64_t packet_time_us = -1;
-  if (parsed_packet.arrival_time_ms() > 0) {
-    packet_time_us = parsed_packet.arrival_time_ms() * 1000;
-  }
+  RTC_DCHECK_RUN_ON(network_thread());
 
-  if (!has_received_packet_) {
-    has_received_packet_ = true;
-    signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
+  if (on_first_packet_received_) {
+    on_first_packet_received_();
+    on_first_packet_received_ = nullptr;
   }
 
   if (!srtp_active() && srtp_required_) {
@@ -496,7 +463,10 @@ void BaseChannel::OnRtpPacket(const webrtc::RtpPacketReceived& parsed_packet) {
     return;
   }
 
-  media_channel_->OnPacketReceived(parsed_packet.Buffer(), packet_time_us);
+  webrtc::Timestamp packet_time = parsed_packet.arrival_time();
+  media_channel_->OnPacketReceived(
+      parsed_packet.Buffer(),
+      packet_time.IsMinusInfinity() ? -1 : packet_time.us());
 }
 
 void BaseChannel::UpdateRtpHeaderExtensionMap(
@@ -555,6 +525,7 @@ void BaseChannel::DisableMedia_w() {
 }
 
 void BaseChannel::UpdateWritableState_n() {
+  TRACE_EVENT0("webrtc", "BaseChannel::UpdateWritableState_n");
   if (rtp_transport_->IsWritable(/*rtcp=*/true) &&
       rtp_transport_->IsWritable(/*rtcp=*/false)) {
     ChannelWritable_n();
@@ -564,6 +535,7 @@ void BaseChannel::UpdateWritableState_n() {
 }
 
 void BaseChannel::ChannelWritable_n() {
+  TRACE_EVENT0("webrtc", "BaseChannel::ChannelWritable_n");
   if (writable_) {
     return;
   }
@@ -583,6 +555,7 @@ void BaseChannel::ChannelWritable_n() {
 }
 
 void BaseChannel::ChannelNotWritable_n() {
+  TRACE_EVENT0("webrtc", "BaseChannel::ChannelNotWritable_n");
   if (!writable_) {
     return;
   }
@@ -779,39 +752,12 @@ bool BaseChannel::UpdateRemoteStreams_w(
   return ret;
 }
 
-RtpHeaderExtensions BaseChannel::GetFilteredRtpHeaderExtensions(
+RtpHeaderExtensions BaseChannel::GetDeduplicatedRtpHeaderExtensions(
     const RtpHeaderExtensions& extensions) {
-  if (crypto_options_.srtp.enable_encrypted_rtp_header_extensions) {
-    RtpHeaderExtensions filtered;
-    absl::c_copy_if(extensions, std::back_inserter(filtered),
-                    [](const webrtc::RtpExtension& extension) {
-                      return !extension.encrypt;
-                    });
-    return filtered;
-  }
-
-  return webrtc::RtpExtension::FilterDuplicateNonEncrypted(extensions);
-}
-
-void BaseChannel::OnMessage(rtc::Message* pmsg) {
-  TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
-  switch (pmsg->message_id) {
-    case MSG_SEND_RTP_PACKET:
-    case MSG_SEND_RTCP_PACKET: {
-      RTC_DCHECK_RUN_ON(network_thread());
-      SendPacketMessageData* data =
-          static_cast<SendPacketMessageData*>(pmsg->pdata);
-      bool rtcp = pmsg->message_id == MSG_SEND_RTCP_PACKET;
-      SendPacket(rtcp, &data->packet, data->options);
-      delete data;
-      break;
-    }
-    case MSG_FIRSTPACKETRECEIVED: {
-      RTC_DCHECK_RUN_ON(signaling_thread_);
-      SignalFirstPacketReceived_(this);
-      break;
-    }
-  }
+  return webrtc::RtpExtension::DeduplicateHeaderExtensions(
+      extensions, crypto_options_.srtp.enable_encrypted_rtp_header_extensions
+                      ? webrtc::RtpExtension::kPreferEncryptedExtension
+                      : webrtc::RtpExtension::kDiscardEncryptedExtension);
 }
 
 void BaseChannel::MaybeAddHandledPayloadType(int payload_type) {
@@ -828,35 +774,11 @@ void BaseChannel::ClearHandledPayloadTypes() {
   payload_types_.clear();
 }
 
-void BaseChannel::FlushRtcpMessages_n() {
-  // Flush all remaining RTCP messages. This should only be called in
-  // destructor.
-  rtc::MessageList rtcp_messages;
-  network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
-  for (const auto& message : rtcp_messages) {
-    network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
-                          message.pdata);
-  }
-}
-
 void BaseChannel::SignalSentPacket_n(const rtc::SentPacket& sent_packet) {
   RTC_DCHECK_RUN_ON(network_thread());
   media_channel()->OnPacketSent(sent_packet);
 }
 
-void BaseChannel::SetNegotiatedHeaderExtensions_w(
-    const RtpHeaderExtensions& extensions) {
-  TRACE_EVENT0("webrtc", __func__);
-  webrtc::MutexLock lock(&negotiated_header_extensions_lock_);
-  negotiated_header_extensions_ = extensions;
-}
-
-RtpHeaderExtensions BaseChannel::GetNegotiatedRtpHeaderExtensions() const {
-  RTC_DCHECK_RUN_ON(signaling_thread());
-  webrtc::MutexLock lock(&negotiated_header_extensions_lock_);
-  return negotiated_header_extensions_;
-}
-
 VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
                            rtc::Thread* network_thread,
                            rtc::Thread* signaling_thread,
@@ -904,26 +826,19 @@ bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
   RTC_DCHECK_RUN_ON(worker_thread());
   RTC_LOG(LS_INFO) << "Setting local voice description for " << ToString();
 
-  RTC_DCHECK(content);
-  if (!content) {
-    SafeSetError("Can't find audio content in local description.", error_desc);
-    return false;
-  }
-
-  const AudioContentDescription* audio = content->as_audio();
-
-  if (type == SdpType::kAnswer)
-    SetNegotiatedHeaderExtensions_w(audio->rtp_header_extensions());
-
   RtpHeaderExtensions rtp_header_extensions =
-      GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
+      GetDeduplicatedRtpHeaderExtensions(content->rtp_header_extensions());
+  // TODO(tommi): There's a hop to the network thread here.
+  // some of the below is also network thread related.
   UpdateRtpHeaderExtensionMap(rtp_header_extensions);
-  media_channel()->SetExtmapAllowMixed(audio->extmap_allow_mixed());
+  media_channel()->SetExtmapAllowMixed(content->extmap_allow_mixed());
 
   AudioRecvParameters recv_params = last_recv_params_;
   RtpParametersFromMediaDescription(
-      audio, rtp_header_extensions,
-      webrtc::RtpTransceiverDirectionHasRecv(audio->direction()), &recv_params);
+      content->as_audio(), rtp_header_extensions,
+      webrtc::RtpTransceiverDirectionHasRecv(content->direction()),
+      &recv_params);
+
   if (!media_channel()->SetRecvParameters(recv_params)) {
     SafeSetError(
         "Failed to set local audio description recv parameters for m-section "
@@ -933,8 +848,8 @@ bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
     return false;
   }
 
-  if (webrtc::RtpTransceiverDirectionHasRecv(audio->direction())) {
-    for (const AudioCodec& codec : audio->codecs()) {
+  if (webrtc::RtpTransceiverDirectionHasRecv(content->direction())) {
+    for (const AudioCodec& codec : content->as_audio()->codecs()) {
       MaybeAddHandledPayloadType(codec.id);
     }
     // Need to re-register the sink to update the handled payload.
@@ -950,7 +865,7 @@ bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
   // only give it to the media channel once we have a remote
   // description too (without a remote description, we won't be able
   // to send them anyway).
-  if (!UpdateLocalStreams_w(audio->streams(), type, error_desc)) {
+  if (!UpdateLocalStreams_w(content->as_audio()->streams(), type, error_desc)) {
     SafeSetError(
         "Failed to set local audio description streams for m-section with "
         "mid='" +
@@ -971,19 +886,10 @@ bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
   RTC_DCHECK_RUN_ON(worker_thread());
   RTC_LOG(LS_INFO) << "Setting remote voice description for " << ToString();
 
-  RTC_DCHECK(content);
-  if (!content) {
-    SafeSetError("Can't find audio content in remote description.", error_desc);
-    return false;
-  }
-
   const AudioContentDescription* audio = content->as_audio();
 
-  if (type == SdpType::kAnswer)
-    SetNegotiatedHeaderExtensions_w(audio->rtp_header_extensions());
-
   RtpHeaderExtensions rtp_header_extensions =
-      GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
+      GetDeduplicatedRtpHeaderExtensions(audio->rtp_header_extensions());
 
   AudioSendParameters send_params = last_send_params_;
   RtpSendParametersFromMediaDescription(
@@ -1070,9 +976,9 @@ void VideoChannel::UpdateMediaSendRecvState_w() {
 }
 
 void VideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
+  RTC_DCHECK_RUN_ON(worker_thread());
   VideoMediaChannel* mc = media_channel();
-  InvokeOnWorker<void>(RTC_FROM_HERE,
-                       [mc, bwe_info] { mc->FillBitrateInfo(bwe_info); });
+  mc->FillBitrateInfo(bwe_info);
 }
 
 bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
@@ -1082,26 +988,17 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
   RTC_DCHECK_RUN_ON(worker_thread());
   RTC_LOG(LS_INFO) << "Setting local video description for " << ToString();
 
-  RTC_DCHECK(content);
-  if (!content) {
-    SafeSetError("Can't find video content in local description.", error_desc);
-    return false;
-  }
-
-  const VideoContentDescription* video = content->as_video();
-
-  if (type == SdpType::kAnswer)
-    SetNegotiatedHeaderExtensions_w(video->rtp_header_extensions());
-
   RtpHeaderExtensions rtp_header_extensions =
-      GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
+      GetDeduplicatedRtpHeaderExtensions(content->rtp_header_extensions());
   UpdateRtpHeaderExtensionMap(rtp_header_extensions);
-  media_channel()->SetExtmapAllowMixed(video->extmap_allow_mixed());
+  media_channel()->SetExtmapAllowMixed(content->extmap_allow_mixed());
 
   VideoRecvParameters recv_params = last_recv_params_;
+
   RtpParametersFromMediaDescription(
-      video, rtp_header_extensions,
-      webrtc::RtpTransceiverDirectionHasRecv(video->direction()), &recv_params);
+      content->as_video(), rtp_header_extensions,
+      webrtc::RtpTransceiverDirectionHasRecv(content->direction()),
+      &recv_params);
 
   VideoSendParameters send_params = last_send_params_;
 
@@ -1134,8 +1031,8 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
     return false;
   }
 
-  if (webrtc::RtpTransceiverDirectionHasRecv(video->direction())) {
-    for (const VideoCodec& codec : video->codecs()) {
+  if (webrtc::RtpTransceiverDirectionHasRecv(content->direction())) {
+    for (const VideoCodec& codec : content->as_video()->codecs()) {
       MaybeAddHandledPayloadType(codec.id);
     }
     // Need to re-register the sink to update the handled payload.
@@ -1161,7 +1058,7 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
   // only give it to the media channel once we have a remote
   // description too (without a remote description, we won't be able
   // to send them anyway).
-  if (!UpdateLocalStreams_w(video->streams(), type, error_desc)) {
+  if (!UpdateLocalStreams_w(content->as_video()->streams(), type, error_desc)) {
     SafeSetError(
         "Failed to set local video description streams for m-section with "
         "mid='" +
@@ -1182,19 +1079,10 @@ bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
   RTC_DCHECK_RUN_ON(worker_thread());
   RTC_LOG(LS_INFO) << "Setting remote video description for " << ToString();
 
-  RTC_DCHECK(content);
-  if (!content) {
-    SafeSetError("Can't find video content in remote description.", error_desc);
-    return false;
-  }
-
   const VideoContentDescription* video = content->as_video();
 
-  if (type == SdpType::kAnswer)
-    SetNegotiatedHeaderExtensions_w(video->rtp_header_extensions());
-
   RtpHeaderExtensions rtp_header_extensions =
-      GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
+      GetDeduplicatedRtpHeaderExtensions(video->rtp_header_extensions());
 
   VideoSendParameters send_params = last_send_params_;
   RtpSendParametersFromMediaDescription(