tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

MediaTransportParent.cpp (10755B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
      3 * You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #include "mozilla/dom/MediaTransportParent.h"
      6 
      7 #include "MediaEventSource.h"
      8 #include "common/browser_logging/CSFLog.h"
      9 #include "jsapi/MediaTransportHandler.h"
     10 #include "transport/sigslot.h"
     11 
     12 namespace mozilla {
     13 
     14 // Deals with the MediaTransportHandler interface, so MediaTransportParent
     15 // doesn't have to..
     16 class MediaTransportParent::Impl : public sigslot::has_slots<> {
     17 public:
     18  explicit Impl(MediaTransportParent* aParent)
     19      : mHandler(MediaTransportHandler::Create()), mParent(aParent) {
     20    mCandidateListener = mHandler->GetCandidateGathered().Connect(
     21        GetCurrentSerialEventTarget(), this,
     22        &MediaTransportParent::Impl::OnCandidate);
     23    mAlpnNegotiatedListener = mHandler->GetAlpnNegotiated().Connect(
     24        GetCurrentSerialEventTarget(), this,
     25        &MediaTransportParent::Impl::OnAlpnNegotiated);
     26    mGatheringStateChangeListener = mHandler->GetGatheringStateChange().Connect(
     27        GetCurrentSerialEventTarget(), this,
     28        &MediaTransportParent::Impl::OnGatheringStateChange);
     29    mConnectionStateChangeListener =
     30        mHandler->GetConnectionStateChange().Connect(
     31            GetCurrentSerialEventTarget(), this,
     32            &MediaTransportParent::Impl::OnConnectionStateChange);
     33    mRtpPacketListener = mHandler->GetRtpPacketReceived().Connect(
     34        GetCurrentSerialEventTarget(), this,
     35        &MediaTransportParent::Impl::OnPacketReceived);
     36    mSctpPacketListener = mHandler->GetSctpPacketReceived().Connect(
     37        GetCurrentSerialEventTarget(), this,
     38        &MediaTransportParent::Impl::OnPacketReceived);
     39    mEncryptedSendingListener = mHandler->GetEncryptedSending().Connect(
     40        GetCurrentSerialEventTarget(), this,
     41        &MediaTransportParent::Impl::OnEncryptedSending);
     42    mStateChangeListener = mHandler->GetStateChange().Connect(
     43        GetCurrentSerialEventTarget(), this,
     44        &MediaTransportParent::Impl::OnStateChange);
     45    mRtcpStateChangeListener = mHandler->GetRtcpStateChange().Connect(
     46        GetCurrentSerialEventTarget(), this,
     47        &MediaTransportParent::Impl::OnRtcpStateChange);
     48    mTarget = GetCurrentSerialEventTarget();
     49  }
     50 
     51  virtual ~Impl() {
     52    MOZ_ASSERT(mTarget->IsOnCurrentThread());
     53    mCandidateListener.DisconnectIfExists();
     54    mAlpnNegotiatedListener.DisconnectIfExists();
     55    mGatheringStateChangeListener.DisconnectIfExists();
     56    mConnectionStateChangeListener.DisconnectIfExists();
     57    mRtpPacketListener.DisconnectIfExists();
     58    mSctpPacketListener.DisconnectIfExists();
     59    mEncryptedSendingListener.DisconnectIfExists();
     60    mStateChangeListener.DisconnectIfExists();
     61    mRtcpStateChangeListener.DisconnectIfExists();
     62    mHandler = nullptr;
     63  }
     64 
     65  void OnCandidate(const std::string& aTransportId,
     66                   const CandidateInfo& aCandidateInfo) {
     67    NS_ENSURE_TRUE_VOID(mParent->SendOnCandidate(aTransportId, aCandidateInfo));
     68  }
     69 
     70  void OnAlpnNegotiated(const std::string& aAlpn, bool aPrivacyRequested) {
     71    NS_ENSURE_TRUE_VOID(mParent->SendOnAlpnNegotiated(aAlpn));
     72  }
     73 
     74  void OnGatheringStateChange(const std::string& aTransportId,
     75                              dom::RTCIceGathererState aState) {
     76    NS_ENSURE_TRUE_VOID(mParent->SendOnGatheringStateChange(
     77        aTransportId, static_cast<int>(aState)));
     78  }
     79 
     80  void OnConnectionStateChange(const std::string& aTransportId,
     81                               dom::RTCIceTransportState aState) {
     82    NS_ENSURE_TRUE_VOID(mParent->SendOnConnectionStateChange(
     83        aTransportId, static_cast<int>(aState)));
     84  }
     85 
     86  void OnPacketReceived(const std::string& aTransportId,
     87                        const MediaPacket& aPacket) {
     88    NS_ENSURE_TRUE_VOID(mParent->SendOnPacketReceived(aTransportId, aPacket));
     89  }
     90 
     91  void OnEncryptedSending(const std::string& aTransportId,
     92                          const MediaPacket& aPacket) {
     93    NS_ENSURE_TRUE_VOID(mParent->SendOnEncryptedSending(aTransportId, aPacket));
     94  }
     95 
     96  void OnStateChange(const std::string& aTransportId,
     97                     TransportLayer::State aState) {
     98    NS_ENSURE_TRUE_VOID(mParent->SendOnStateChange(aTransportId, aState));
     99  }
    100 
    101  void OnRtcpStateChange(const std::string& aTransportId,
    102                         TransportLayer::State aState) {
    103    NS_ENSURE_TRUE_VOID(mParent->SendOnRtcpStateChange(aTransportId, aState));
    104  }
    105 
    106  RefPtr<MediaTransportHandler> mHandler;
    107 
    108 private:
    109  MediaTransportParent* mParent;
    110  MediaEventListener mCandidateListener;
    111  MediaEventListener mAlpnNegotiatedListener;
    112  MediaEventListener mGatheringStateChangeListener;
    113  MediaEventListener mConnectionStateChangeListener;
    114  MediaEventListener mRtpPacketListener;
    115  MediaEventListener mSctpPacketListener;
    116  MediaEventListener mEncryptedSendingListener;
    117  MediaEventListener mStateChangeListener;
    118  MediaEventListener mRtcpStateChangeListener;
    119  RefPtr<nsISerialEventTarget> mTarget;
    120 };
    121 
    122 MediaTransportParent::MediaTransportParent() : mImpl(new Impl(this)) {}
    123 
    124 MediaTransportParent::~MediaTransportParent() {}
    125 
    126 mozilla::ipc::IPCResult MediaTransportParent::RecvGetIceLog(
    127    const nsCString& pattern, GetIceLogResolver&& aResolve) {
    128  mImpl->mHandler->GetIceLog(pattern)->Then(
    129      GetCurrentSerialEventTarget(), __func__,
    130      // IPDL doesn't give us a reject function, so we cannot reject async, so
    131      // we are forced to resolve with an empty result. Laaaaaaame.
    132      [aResolve = std::move(aResolve)](
    133          MediaTransportHandler::IceLogPromise::ResolveOrRejectValue&&
    134              aResult) mutable {
    135        WebrtcGlobalLog logLines;
    136        if (aResult.IsResolve()) {
    137          logLines = std::move(aResult.ResolveValue());
    138        }
    139        aResolve(logLines);
    140      });
    141 
    142  return ipc::IPCResult::Ok();
    143 }
    144 
    145 mozilla::ipc::IPCResult MediaTransportParent::RecvClearIceLog() {
    146  mImpl->mHandler->ClearIceLog();
    147  return ipc::IPCResult::Ok();
    148 }
    149 
    150 mozilla::ipc::IPCResult MediaTransportParent::RecvEnterPrivateMode() {
    151  mImpl->mHandler->EnterPrivateMode();
    152  return ipc::IPCResult::Ok();
    153 }
    154 
    155 mozilla::ipc::IPCResult MediaTransportParent::RecvExitPrivateMode() {
    156  mImpl->mHandler->ExitPrivateMode();
    157  return ipc::IPCResult::Ok();
    158 }
    159 
    160 mozilla::ipc::IPCResult MediaTransportParent::RecvCreateIceCtx(
    161    const string& name) {
    162  mImpl->mHandler->CreateIceCtx(name);
    163  return ipc::IPCResult::Ok();
    164 }
    165 
    166 mozilla::ipc::IPCResult MediaTransportParent::RecvSetIceConfig(
    167    nsTArray<RTCIceServer>&& iceServers,
    168    const RTCIceTransportPolicy& icePolicy) {
    169  nsresult rv = mImpl->mHandler->SetIceConfig(iceServers, icePolicy);
    170  if (NS_FAILED(rv)) {
    171    return ipc::IPCResult::Fail(WrapNotNull(this), __func__,
    172                                "MediaTransportHandler::SetIceConfig failed");
    173  }
    174  return ipc::IPCResult::Ok();
    175 }
    176 
    177 mozilla::ipc::IPCResult MediaTransportParent::RecvSetProxyConfig(
    178    const net::WebrtcProxyConfig& aProxyConfig) {
    179  mImpl->mHandler->SetProxyConfig(NrSocketProxyConfig(aProxyConfig));
    180  return ipc::IPCResult::Ok();
    181 }
    182 
    183 mozilla::ipc::IPCResult MediaTransportParent::RecvEnsureProvisionalTransport(
    184    const string& transportId, const string& localUfrag, const string& localPwd,
    185    const int& componentCount) {
    186  mImpl->mHandler->EnsureProvisionalTransport(transportId, localUfrag, localPwd,
    187                                              componentCount);
    188  return ipc::IPCResult::Ok();
    189 }
    190 
    191 mozilla::ipc::IPCResult
    192 MediaTransportParent::RecvSetTargetForDefaultLocalAddressLookup(
    193    const std::string& targetIp, uint16_t targetPort) {
    194  mImpl->mHandler->SetTargetForDefaultLocalAddressLookup(targetIp, targetPort);
    195  return ipc::IPCResult::Ok();
    196 }
    197 
    198 mozilla::ipc::IPCResult MediaTransportParent::RecvStartIceGathering(
    199    const bool& defaultRouteOnly, const bool& obfuscateHostAddresses,
    200    const net::NrIceStunAddrArray& stunAddrs) {
    201  mImpl->mHandler->StartIceGathering(defaultRouteOnly, obfuscateHostAddresses,
    202                                     stunAddrs);
    203  return ipc::IPCResult::Ok();
    204 }
    205 
    206 mozilla::ipc::IPCResult MediaTransportParent::RecvActivateTransport(
    207    const string& transportId, const string& localUfrag, const string& localPwd,
    208    const int& componentCount, const string& remoteUfrag,
    209    const string& remotePwd, nsTArray<uint8_t>&& keyDer,
    210    nsTArray<uint8_t>&& certDer, const int& authType, const bool& dtlsClient,
    211    const DtlsDigestList& digests, const bool& privacyRequested) {
    212  mImpl->mHandler->ActivateTransport(
    213      transportId, localUfrag, localPwd, componentCount, remoteUfrag, remotePwd,
    214      keyDer, certDer, static_cast<SSLKEAType>(authType), dtlsClient, digests,
    215      privacyRequested);
    216  return ipc::IPCResult::Ok();
    217 }
    218 
    219 mozilla::ipc::IPCResult MediaTransportParent::RecvRemoveTransportsExcept(
    220    const StringVector& transportIds) {
    221  std::set<std::string> ids(transportIds.begin(), transportIds.end());
    222  mImpl->mHandler->RemoveTransportsExcept(ids);
    223  return ipc::IPCResult::Ok();
    224 }
    225 
    226 mozilla::ipc::IPCResult MediaTransportParent::RecvStartIceChecks(
    227    const bool& isControlling, const StringVector& iceOptions) {
    228  mImpl->mHandler->StartIceChecks(isControlling, iceOptions);
    229  return ipc::IPCResult::Ok();
    230 }
    231 
    232 mozilla::ipc::IPCResult MediaTransportParent::RecvSendPacket(
    233    const string& transportId, MediaPacket&& packet) {
    234  mImpl->mHandler->SendPacket(transportId, std::move(packet));
    235  return ipc::IPCResult::Ok();
    236 }
    237 
    238 mozilla::ipc::IPCResult MediaTransportParent::RecvAddIceCandidate(
    239    const string& transportId, const string& candidate, const string& ufrag,
    240    const string& obfuscatedAddr) {
    241  mImpl->mHandler->AddIceCandidate(transportId, candidate, ufrag,
    242                                   obfuscatedAddr);
    243  return ipc::IPCResult::Ok();
    244 }
    245 
    246 mozilla::ipc::IPCResult MediaTransportParent::RecvUpdateNetworkState(
    247    const bool& online) {
    248  mImpl->mHandler->UpdateNetworkState(online);
    249  return ipc::IPCResult::Ok();
    250 }
    251 
    252 mozilla::ipc::IPCResult MediaTransportParent::RecvGetIceStats(
    253    const string& transportId, const double& now,
    254    GetIceStatsResolver&& aResolve) {
    255  mImpl->mHandler->GetIceStats(transportId, now)
    256      ->Then(
    257          GetCurrentSerialEventTarget(), __func__,
    258          // IPDL doesn't give us a reject function, so we cannot reject async,
    259          // so we are forced to resolve with an unmodified result. Laaaaaaame.
    260          [aResolve = std::move(aResolve)](
    261              dom::RTCStatsPromise::ResolveOrRejectValue&& aResult) {
    262            if (aResult.IsResolve()) {
    263              aResolve(aResult.ResolveValue());
    264            } else {
    265              aResolve(MakeUnique<dom::RTCStatsCollection>());
    266            }
    267          });
    268 
    269  return ipc::IPCResult::Ok();
    270 }
    271 
    272 }  // namespace mozilla