Bug 1974444: Move RTCDataChannel's const attrs to the DOM object, and associated cleanup. r=mjf

Differential Revision: https://phabricator.services.mozilla.com/D255376

Author: docfaraday

dom/base/nsDOMDataChannel.cpp

@@ -71,13 +71,23 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMDataChannel)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 
 nsDOMDataChannel::nsDOMDataChannel(
+    const nsAString& aLabel, bool aOrdered,
+    mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+    mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+    const nsAString& aProtocol, bool aNegotiated,
     already_AddRefed<mozilla::DataChannel>& aDataChannel,
     nsPIDOMWindowInner* aWindow)
     : DOMEventTargetHelper(aWindow),
       mDataChannel(aDataChannel),
       mBinaryType(DC_BINARY_TYPE_BLOB),
       mCheckMustKeepAlive(true),
-      mSentClose(false) {}
+      mSentClose(false),
+      mLabel(aLabel),
+      mOrdered(aOrdered),
+      mMaxPacketLifeTime(aMaxLifeTime),
+      mMaxRetransmits(aMaxRetransmits),
+      mProtocol(aProtocol),
+      mNegotiated(aNegotiated) {}
 
 nsresult nsDOMDataChannel::Init(nsPIDOMWindowInner* aDOMWindow) {
   nsresult rv;
@@ -111,12 +121,10 @@ nsresult nsDOMDataChannel::Init(nsPIDOMWindowInner* aDOMWindow) {
 
 // Most of the GetFoo()/SetFoo()s don't need to touch shared resources and
 // are safe after Close()
-void nsDOMDataChannel::GetLabel(nsAString& aLabel) {
-  mDataChannel->GetLabel(aLabel);
-}
+void nsDOMDataChannel::GetLabel(nsAString& aLabel) const { aLabel = mLabel; }
 
-void nsDOMDataChannel::GetProtocol(nsAString& aProtocol) {
-  mDataChannel->GetProtocol(aProtocol);
+void nsDOMDataChannel::GetProtocol(nsAString& aProtocol) const {
+  aProtocol = mProtocol;
 }
 
 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetId() const {
@@ -127,26 +135,18 @@ mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetId() const {
   return result;
 }
 
-// XXX should be GetType()?  Open question for the spec
-bool nsDOMDataChannel::Reliable() const {
-  return mDataChannel->GetType() ==
-         mozilla::DataChannelReliabilityPolicy::Reliable;
-}
-
 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetMaxPacketLifeTime()
     const {
-  return mDataChannel->GetMaxPacketLifeTime();
+  return mMaxPacketLifeTime;
 }
 
 mozilla::dom::Nullable<uint16_t> nsDOMDataChannel::GetMaxRetransmits() const {
-  return mDataChannel->GetMaxRetransmits();
+  return mMaxRetransmits;
 }
 
-bool nsDOMDataChannel::Negotiated() const {
-  return mDataChannel->GetNegotiated();
-}
+bool nsDOMDataChannel::Negotiated() const { return mNegotiated; }
 
-bool nsDOMDataChannel::Ordered() const { return mDataChannel->GetOrdered(); }
+bool nsDOMDataChannel::Ordered() const { return mOrdered; }
 
 RTCDataChannelState nsDOMDataChannel::ReadyState() const {
   return static_cast<RTCDataChannelState>(mDataChannel->GetReadyState());
@@ -493,8 +493,14 @@ void nsDOMDataChannel::EventListenerRemoved(nsAtom* aType) {
 /* static */
 nsresult NS_NewDOMDataChannel(
     already_AddRefed<mozilla::DataChannel>&& aDataChannel,
-    nsPIDOMWindowInner* aWindow, nsDOMDataChannel** aDomDataChannel) {
-  RefPtr<nsDOMDataChannel> domdc = new nsDOMDataChannel(aDataChannel, aWindow);
+    const nsAString& aLabel, bool aOrdered,
+    mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+    mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+    const nsAString& aProtocol, bool aNegotiated, nsPIDOMWindowInner* aWindow,
+    nsDOMDataChannel** aDomDataChannel) {
+  RefPtr<nsDOMDataChannel> domdc =
+      new nsDOMDataChannel(aLabel, aOrdered, aMaxLifeTime, aMaxRetransmits,
+                           aProtocol, aNegotiated, aDataChannel, aWindow);
 
   nsresult rv = domdc->Init(aWindow);
   NS_ENSURE_SUCCESS(rv, rv);

dom/base/nsDOMDataChannel.h

@@ -9,6 +9,7 @@
 
 #include "mozilla/Attributes.h"
 #include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/Nullable.h"
 #include "mozilla/dom/RTCDataChannelBinding.h"
 #include "mozilla/dom/TypedArray.h"
 #include "mozilla/net/DataChannelListener.h"
@@ -24,7 +25,11 @@ class DataChannel;
 class nsDOMDataChannel final : public mozilla::DOMEventTargetHelper,
                                public mozilla::DataChannelListener {
  public:
-  nsDOMDataChannel(already_AddRefed<mozilla::DataChannel>& aDataChannel,
+  nsDOMDataChannel(const nsAString& aLabel, bool aOrdered,
+                   mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+                   mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+                   const nsAString& aProtocol, bool aNegotiated,
+                   already_AddRefed<mozilla::DataChannel>& aDataChannel,
                    nsPIDOMWindowInner* aWindow);
 
   nsresult Init(nsPIDOMWindowInner* aDOMWindow);
@@ -45,9 +50,8 @@ class nsDOMDataChannel final : public mozilla::DOMEventTargetHelper,
   nsIGlobalObject* GetParentObject() const { return GetOwnerGlobal(); }
 
   // WebIDL
-  void GetLabel(nsAString& aLabel);
-  void GetProtocol(nsAString& aProtocol);
-  bool Reliable() const;
+  void GetLabel(nsAString& aLabel) const;
+  void GetProtocol(nsAString& aProtocol) const;
   mozilla::dom::Nullable<uint16_t> GetMaxPacketLifeTime() const;
   mozilla::dom::Nullable<uint16_t> GetMaxRetransmits() const;
   mozilla::dom::RTCDataChannelState ReadyState() const;
@@ -123,6 +127,13 @@ class nsDOMDataChannel final : public mozilla::DOMEventTargetHelper,
   DataChannelBinaryType mBinaryType;
   bool mCheckMustKeepAlive;
   bool mSentClose;
+
+  const nsString mLabel;
+  const bool mOrdered;
+  const mozilla::dom::Nullable<uint16_t> mMaxPacketLifeTime;
+  const mozilla::dom::Nullable<uint16_t> mMaxRetransmits;
+  const nsString mProtocol;
+  const bool mNegotiated;
 };
 
 #endif  // nsDOMDataChannel_h

dom/base/nsDOMDataChannelDeclarations.h

@@ -11,16 +11,22 @@
 // gets used with MOZ_INTERNAL_API not set for media/webrtc/signaling/testing
 
 #include "nsCOMPtr.h"
+#include "nsStringFwd.h"
+#include "mozilla/dom/Nullable.h"
 
 namespace mozilla {
 class DataChannel;
-}
+}  // namespace mozilla
 
 class nsDOMDataChannel;
 class nsPIDOMWindowInner;
 
 nsresult NS_NewDOMDataChannel(
-    already_AddRefed<mozilla::DataChannel>&& dataChannel,
-    nsPIDOMWindowInner* aWindow, nsDOMDataChannel** domDataChannel);
+    already_AddRefed<mozilla::DataChannel>&& aDataChannel,
+    const nsAString& aLabel, bool aOrdered,
+    mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+    mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+    const nsAString& aProtocol, bool aNegotiated, nsPIDOMWindowInner* aWindow,
+    nsDOMDataChannel** aDomDataChannel);
 
 #endif  // nsDOMDataChannelDeclarations_h

dom/media/webrtc/jsapi/PeerConnectionImpl.cpp

@@ -1012,15 +1012,19 @@ PeerConnectionImpl::CreateDataChannel(
 
   RefPtr<DataChannel> dataChannel;
   DataChannelReliabilityPolicy prPolicy;
+  Nullable<uint16_t> maxLifeTime;
+  Nullable<uint16_t> maxRetransmits;
   switch (aType) {
     case IPeerConnection::kDataChannelReliable:
       prPolicy = DataChannelReliabilityPolicy::Reliable;
       break;
     case IPeerConnection::kDataChannelPartialReliableRexmit:
       prPolicy = DataChannelReliabilityPolicy::LimitedRetransmissions;
+      maxRetransmits.SetValue(aMaxNum);
       break;
     case IPeerConnection::kDataChannelPartialReliableTimed:
       prPolicy = DataChannelReliabilityPolicy::LimitedLifetime;
+      maxLifeTime.SetValue(aMaxTime);
       break;
     default:
       MOZ_ASSERT(false);
@@ -1065,8 +1069,9 @@ PeerConnectionImpl::CreateDataChannel(
   }
 
   RefPtr<nsDOMDataChannel> retval;
-  rv = NS_NewDOMDataChannel(dataChannel.forget(), mWindow,
-                            getter_AddRefs(retval));
+  rv = NS_NewDOMDataChannel(dataChannel.forget(), aLabel, ordered, maxLifeTime,
+                            maxRetransmits, aProtocol, aExternalNegotiated,
+                            mWindow, getter_AddRefs(retval));
   if (NS_FAILED(rv)) {
     return rv;
   }
@@ -1350,16 +1355,20 @@ RefPtr<dom::RTCRtpTransceiver> PeerConnectionImpl::GetTransceiver(
 }
 
 void PeerConnectionImpl::NotifyDataChannel(
-    already_AddRefed<DataChannel> aChannel) {
+    already_AddRefed<DataChannel> aChannel, const nsAString& aLabel,
+    bool aOrdered, mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+    mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+    const nsAString& aProtocol, bool aNegotiated) {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
 
   RefPtr<DataChannel> channel(aChannel);
   MOZ_ASSERT(channel);
   CSFLogDebug(LOGTAG, "%s: channel: %p", __FUNCTION__, channel.get());
 
   RefPtr<nsDOMDataChannel> domchannel;
-  nsresult rv = NS_NewDOMDataChannel(channel.forget(), mWindow,
-                                     getter_AddRefs(domchannel));
+  nsresult rv = NS_NewDOMDataChannel(
+      channel.forget(), aLabel, aOrdered, aMaxLifeTime, aMaxRetransmits,
+      aProtocol, aNegotiated, mWindow, getter_AddRefs(domchannel));
   NS_ENSURE_SUCCESS_VOID(rv);
 
   JSErrorResult jrv;

dom/media/webrtc/jsapi/PeerConnectionImpl.h

@@ -202,7 +202,11 @@ class PeerConnectionImpl final
     return DefaultCodecPreferences(aOverrideRtxPreference);
   }
   // DataConnection observers
-  void NotifyDataChannel(already_AddRefed<mozilla::DataChannel> aChannel)
+  void NotifyDataChannel(already_AddRefed<DataChannel> aChannel,
+                         const nsAString& aLabel, bool aOrdered,
+                         mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+                         mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+                         const nsAString& aProtocol, bool aNegotiated)
       // PeerConnectionImpl only inherits from mozilla::DataChannelConnection
       // inside libxul.
       override;

dom/media/webrtc/tests/mochitests/dataChannel.js

@@ -162,11 +162,6 @@ var commandsCheckDataChannel = [
         options.protocol,
         result.local + " protocol is:" + result.local.protocol
       );
-      is(
-        result.local.reliable,
-        false,
-        result.local + " reliable is:" + result.local.reliable
-      );
       is(
         result.local.ordered,
         options.ordered,
@@ -198,11 +193,6 @@ var commandsCheckDataChannel = [
         options.protocol,
         result.remote + " protocol is:" + result.remote.protocol
       );
-      is(
-        result.remote.reliable,
-        false,
-        result.remote + " reliable is:" + result.remote.reliable
-      );
       is(
         result.remote.ordered,
         options.ordered,
@@ -254,11 +244,6 @@ var commandsCheckDataChannel = [
         "",
         result.local + " protocol is:" + result.local.protocol
       );
-      is(
-        result.local.reliable,
-        false,
-        result.local + " reliable is:" + result.local.reliable
-      );
       is(
         result.local.ordered,
         options.ordered,
@@ -285,11 +270,6 @@ var commandsCheckDataChannel = [
         "",
         result.remote + " protocol is:" + result.remote.protocol
       );
-      is(
-        result.remote.reliable,
-        false,
-        result.remote + " reliable is:" + result.remote.reliable
-      );
       is(
         result.remote.ordered,
         options.ordered,

dom/media/webrtc/tests/mochitests/pc.js

@@ -764,15 +764,6 @@ DataChannelWrapper.prototype = {
     return this._channel.id;
   },
 
-  /**
-   * Returns the reliable state of the underlying data channel
-   *
-   * @returns {bool} The stream's reliable state
-   */
-  get reliable() {
-    return this._channel.reliable;
-  },
-
   /**
    * Returns the ordered attribute of the data channel
    *

netwerk/sctp/datachannel/DataChannel.cpp

@@ -537,7 +537,6 @@ void DataChannelConnection::HandleOpenRequestMessage(
     const struct rtcweb_datachannel_open_request* req, uint32_t length,
     uint16_t stream) {
   MOZ_ASSERT(mSTS->IsOnCurrentThread());
-  uint32_t prValue;
   DataChannelReliabilityPolicy prPolicy;
 
   const size_t requiredLength = (sizeof(*req) - 1) + ntohs(req->label_length) +
@@ -581,7 +580,7 @@ void DataChannelConnection::HandleOpenRequestMessage(
     return;
   }
 
-  prValue = ntohl(req->reliability_param);
+  const uint32_t prValue = ntohl(req->reliability_param);
   const bool ordered = !(req->channel_type & 0x80);
   const nsCString label(&req->label[0], ntohs(req->label_length));
   const nsCString protocol(&req->label[ntohs(req->label_length)],
@@ -622,9 +621,30 @@ void DataChannelConnection::HandleOpenRequestMessage(
 
         DC_DEBUG(("%s: sending ON_CHANNEL_CREATED for %s/%s: %u", __FUNCTION__,
                   channel->mLabel.get(), channel->mProtocol.get(), stream));
+
+        // Awkward. If we convert over to using Maybe for this in DataChannel,
+        // we won't need to have this extra conversion, since Nullable converts
+        // easily to Maybe.
+        dom::Nullable<uint16_t> maxLifeTime;
+        dom::Nullable<uint16_t> maxRetransmits;
+        if (prPolicy == DataChannelReliabilityPolicy::LimitedLifetime) {
+          maxLifeTime.SetValue(std::min(std::numeric_limits<uint16_t>::max(),
+                                        (uint16_t)prValue));
+        } else if (prPolicy ==
+                   DataChannelReliabilityPolicy::LimitedRetransmissions) {
+          maxRetransmits.SetValue(std::min(std::numeric_limits<uint16_t>::max(),
+                                           (uint16_t)prValue));
+        }
+
         if (mListener) {
           // important to give it an already_AddRefed pointer!
-          mListener->NotifyDataChannel(do_AddRef(channel));
+          // TODO(bug 1974443): Have nsDOMDataChannel create the DataChannel
+          // object, or have DataChannel take an nsDOMDataChannel, to avoid
+          // passing this param list more than once?
+          mListener->NotifyDataChannel(do_AddRef(channel),
+                                       NS_ConvertUTF8toUTF16(label), ordered,
+                                       maxLifeTime, maxRetransmits,
+                                       NS_ConvertUTF8toUTF16(protocol), false);
           // Spec says to queue this in the queued task for ondatachannel
           channel->AnnounceOpen();
         }
@@ -1690,20 +1710,6 @@ void DataChannel::SendBinaryBlob(dom::Blob& aBlob, ErrorResult& aRv) {
   }
 }
 
-dom::Nullable<uint16_t> DataChannel::GetMaxPacketLifeTime() const {
-  if (mPrPolicy == DataChannelReliabilityPolicy::LimitedLifetime) {
-    return dom::Nullable<uint16_t>(mPrValue);
-  }
-  return dom::Nullable<uint16_t>();
-}
-
-dom::Nullable<uint16_t> DataChannel::GetMaxRetransmits() const {
-  if (mPrPolicy == DataChannelReliabilityPolicy::LimitedRetransmissions) {
-    return dom::Nullable<uint16_t>(mPrValue);
-  }
-  return dom::Nullable<uint16_t>();
-}
-
 uint32_t DataChannel::GetBufferedAmountLowThreshold() const {
   return mBufferedThreshold;
 }

netwerk/sctp/datachannel/DataChannel.h

@@ -145,7 +145,11 @@ class DataChannelConnection : public net::NeckoTargetHolder {
     virtual ~DataConnectionListener() = default;
 
     // Called when a new DataChannel has been opened by the other side.
-    virtual void NotifyDataChannel(already_AddRefed<DataChannel> channel) = 0;
+    virtual void NotifyDataChannel(
+        already_AddRefed<DataChannel> aChannel, const nsAString& aLabel,
+        bool aOrdered, mozilla::dom::Nullable<uint16_t> aMaxLifeTime,
+        mozilla::dom::Nullable<uint16_t> aMaxRetransmits,
+        const nsAString& aProtocol, bool aNegotiated) = 0;
 
     // Called when a DataChannel transitions to state open
     virtual void NotifyDataChannelOpen(DataChannel* aChannel) = 0;
@@ -424,16 +428,6 @@ class DataChannel {
   // Send a binary blob
   void SendBinaryBlob(dom::Blob& aBlob, ErrorResult& aRv);
 
-  DataChannelReliabilityPolicy GetType() const { return mPrPolicy; }
-
-  dom::Nullable<uint16_t> GetMaxPacketLifeTime() const;
-
-  dom::Nullable<uint16_t> GetMaxRetransmits() const;
-
-  bool GetNegotiated() const { return mNegotiated; }
-
-  bool GetOrdered() const { return mOrdered; }
-
   void IncrementBufferedAmount(uint32_t aSize, ErrorResult& aRv);
   void DecrementBufferedAmount(uint32_t aSize);