node-datachannel 0.3.0 → 0.3.3

package/src/data-channel-wrapper.cpp

@@ -44,26 +44,8 @@ Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
 
 DataChannelWrapper::DataChannelWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<DataChannelWrapper>(info)
 {
-    mDataChannelPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::DataChannel>>>().Data());    
+    mDataChannelPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::DataChannel>>>().Data());
 
-    mDataChannelPtr->onClosed([&]()
-                              {                                  
-        if (mOnClosedCallback)
-            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
-                if(instances.find(this) == instances.end())
-                    throw ThreadSafeCallback::CancelException();
-
-                cleanCbsAndEraseInstance();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {};
-            });
-         else {
-             cleanCbsAndEraseInstance();
-         } });
-    
     instances.insert(this);
 }
 
@@ -79,17 +61,15 @@ void DataChannelWrapper::doClose()
         try
         {
             mDataChannelPtr->close();
+            mDataChannelPtr.reset();
         }
         catch (std::exception &ex)
         {
-            std::cout << std::string("libdatachannel error while closing dataChannel# ") + ex.what() << std::endl;
+            std::cerr << std::string("libdatachannel error while closing data channel: ") + ex.what() << std::endl;
             return;
         }
     }
-}
 
-void DataChannelWrapper::cleanCbsAndEraseInstance()
-{
     mOnOpenCallback.reset();
     mOnClosedCallback.reset();
     mOnErrorCallback.reset();
@@ -97,7 +77,6 @@ void DataChannelWrapper::cleanCbsAndEraseInstance()
     mOnMessageCallback.reset();
 
     instances.erase(this);
-    mDataChannelPtr.reset();
 }
 
 void DataChannelWrapper::close(const Napi::CallbackInfo &info)
@@ -109,7 +88,7 @@ Napi::Value DataChannelWrapper::getLabel(const Napi::CallbackInfo &info)
 {
     if (!mDataChannelPtr)
     {
-        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "getLabel() called on destroyed channel").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -120,7 +99,7 @@ Napi::Value DataChannelWrapper::getId(const Napi::CallbackInfo &info)
 {
     if (!mDataChannelPtr)
     {
-        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "getId() called on destroyed channel").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -131,7 +110,7 @@ Napi::Value DataChannelWrapper::getProtocol(const Napi::CallbackInfo &info)
 {
     if (!mDataChannelPtr)
     {
-        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "getProtocol() called on destroyed channel").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -142,7 +121,7 @@ Napi::Value DataChannelWrapper::sendMessage(const Napi::CallbackInfo &info)
 {
     if (!mDataChannelPtr)
     {
-        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "sendMessage() called on destroyed channel").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -162,7 +141,7 @@ Napi::Value DataChannelWrapper::sendMessage(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while sending dataChannel msg# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -171,7 +150,7 @@ Napi::Value DataChannelWrapper::sendMessageBinary(const Napi::CallbackInfo &info
 {
     if (!mDataChannelPtr)
     {
-        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "sendMessagBinary() called on destroyed channel").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -191,7 +170,7 @@ Napi::Value DataChannelWrapper::sendMessageBinary(const Napi::CallbackInfo &info
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while sending dataChannel msg# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -199,6 +178,7 @@ Napi::Value DataChannelWrapper::sendMessageBinary(const Napi::CallbackInfo &info
 Napi::Value DataChannelWrapper::isOpen(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mDataChannelPtr)
     {
         return Napi::Boolean::New(info.Env(), false);
@@ -210,7 +190,7 @@ Napi::Value DataChannelWrapper::isOpen(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -218,6 +198,7 @@ Napi::Value DataChannelWrapper::isOpen(const Napi::CallbackInfo &info)
 Napi::Value DataChannelWrapper::bufferedAmount(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mDataChannelPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -229,7 +210,7 @@ Napi::Value DataChannelWrapper::bufferedAmount(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
@@ -237,6 +218,7 @@ Napi::Value DataChannelWrapper::bufferedAmount(const Napi::CallbackInfo &info)
 Napi::Value DataChannelWrapper::maxMessageSize(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mDataChannelPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -248,7 +230,7 @@ Napi::Value DataChannelWrapper::maxMessageSize(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
@@ -257,7 +239,7 @@ void DataChannelWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo
 {
     if (!mDataChannelPtr)
     {
-        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "setBufferedAmountLowThreshold() called on destroyed channel").ThrowAsJavaScriptException();
         return;
     }
 
@@ -276,13 +258,19 @@ void DataChannelWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
 
 void DataChannelWrapper::onOpen(const Napi::CallbackInfo &info)
 {
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "onOpen() called on destroyed channel").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -295,11 +283,10 @@ void DataChannelWrapper::onOpen(const Napi::CallbackInfo &info)
     // Callback
     mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mDataChannelPtr->onOpen([&]()
-                            {
+    mDataChannelPtr->onOpen([&]() {
         if (mOnOpenCallback)
             mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+                // Check the data channel is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -311,6 +298,12 @@ void DataChannelWrapper::onOpen(const Napi::CallbackInfo &info)
 
 void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
 {
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "onClosed() called on destroyed channel").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -323,11 +316,25 @@ void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    // Object cb call moved to the constructor    
+    mDataChannelPtr->onClosed([&]() {
+        if (mOnClosedCallback)
+            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // Do not check if the data channel has been closed here
+
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {};
+            }); });
 }
 
 void DataChannelWrapper::onError(const Napi::CallbackInfo &info)
 {
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "onError() called on destroyed channel").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -340,11 +347,10 @@ void DataChannelWrapper::onError(const Napi::CallbackInfo &info)
     // Callback
     mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mDataChannelPtr->onError([&](const std::string &error)
-                             {
+    mDataChannelPtr->onError([&](std::string error) {
         if (mOnErrorCallback)
-            mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+            mOnErrorCallback->call([this, error = std::move(error)](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the data channel is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -356,6 +362,12 @@ void DataChannelWrapper::onError(const Napi::CallbackInfo &info)
 
 void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
 {
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "onBufferedAmountLow() called on destroyed channel").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -368,11 +380,10 @@ void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
     // Callback
     mOnBufferedAmountLowCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mDataChannelPtr->onBufferedAmountLow([&]()
-                                         {
+    mDataChannelPtr->onBufferedAmountLow([&]() {
         if (mOnBufferedAmountLowCallback)
             mOnBufferedAmountLowCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+                // Check the data channel is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -384,6 +395,12 @@ void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
 
 void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
 {
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "onMessage() called on destroyed channel").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -396,24 +413,23 @@ void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
     // Callback
     mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mDataChannelPtr->onMessage([&](const std::variant<rtc::binary, std::string> &message)
-                               {
+    mDataChannelPtr->onMessage([&](std::variant<rtc::binary, std::string> message) {
         if (mOnMessageCallback)
-            mOnMessageCallback->call([this, message](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+            mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the data channel is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
                 // This will run in main thread and needs to construct the
                 // arguments for the call
-                Napi::Object payload = Napi::Object::New(env);
                 if (std::holds_alternative<std::string>(message))
                 {
                     args = {Napi::String::New(env, std::get<std::string>(message))};
                 }
                 else
                 {
-                    args = {Napi::Buffer<std::byte>::Copy(env, std::get<rtc::binary>(message).data(), std::get<rtc::binary>(message).size())};
+                    auto bin = std::get<rtc::binary>(std::move(message));
+                    args = {Napi::Buffer<std::byte>::Copy(env, bin.data(), bin.size())};
                 }
             }); });
 }

package/src/data-channel-wrapper.h

@@ -46,7 +46,6 @@ private:
   static std::unordered_set<DataChannelWrapper*> instances;
 
   void doClose();
-  void cleanCbsAndEraseInstance();
 
   std::string mLabel;
   std::shared_ptr<rtc::DataChannel> mDataChannelPtr = nullptr;

package/src/media-track-wrapper.cpp

@@ -46,26 +46,8 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 
 TrackWrapper::TrackWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<TrackWrapper>(info)
 {
-    mTrackPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::Track>>>().Data());    
+    mTrackPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::Track>>>().Data());
 
-    mTrackPtr->onClosed([&]()
-                        {
-        if (mOnClosedCallback)
-            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
-                if(instances.find(this) == instances.end())
-                    throw ThreadSafeCallback::CancelException();
-
-                cleanCbsAndEraseInstance();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {};
-            }); 
-            else {
-             cleanCbsAndEraseInstance();
-         } });
-    
     instances.insert(this);
 }
 
@@ -81,24 +63,21 @@ void TrackWrapper::doClose()
         try
         {
             mTrackPtr->close();
+            mTrackPtr.reset();
         }
         catch (std::exception &ex)
         {
-            std::cout << std::string("libdatachannel error while closing track# ") + ex.what() << std::endl;
+            std::cerr << std::string("libdatachannel error while closing track: ") + ex.what() << std::endl;
             return;
         }
     }
-}
 
-void TrackWrapper::cleanCbsAndEraseInstance()
-{
     mOnOpenCallback.reset();
     mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnMessageCallback.reset();
 
     instances.erase(this);
-    mTrackPtr.reset();
 }
 
 void TrackWrapper::close(const Napi::CallbackInfo &info)
@@ -108,18 +87,36 @@ void TrackWrapper::close(const Napi::CallbackInfo &info)
 
 Napi::Value TrackWrapper::direction(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "direction() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::String::New(env, directionToStr(mTrackPtr->direction()));
 }
 
 Napi::Value TrackWrapper::mid(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "mid() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::String::New(env, mTrackPtr->mid());
 }
 
 Napi::Value TrackWrapper::type(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "type() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::String::New(env, mTrackPtr->description().type());
 }
@@ -128,7 +125,7 @@ Napi::Value TrackWrapper::sendMessage(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
     {
-        Napi::Error::New(info.Env(), "It seems track is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "sendMessage() called on destroyed track").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -148,7 +145,7 @@ Napi::Value TrackWrapper::sendMessage(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while sending track msg# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending track message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -157,7 +154,7 @@ Napi::Value TrackWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
     {
-        Napi::Error::New(info.Env(), "It seems track is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "sendMessageBinary() called on destroyed track").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
@@ -177,7 +174,7 @@ Napi::Value TrackWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while sending track msg# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending track message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -185,18 +182,31 @@ Napi::Value TrackWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
 Napi::Value TrackWrapper::isOpen(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
+    if (!mTrackPtr)
+    {
+        return Napi::Boolean::New(env, false);
+    }
+
     return Napi::Boolean::New(env, mTrackPtr->isOpen());
 }
 
 Napi::Value TrackWrapper::isClosed(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
+    if (!mTrackPtr)
+    {
+        return Napi::Boolean::New(env, true);
+    }
+
     return Napi::Boolean::New(env, mTrackPtr->isClosed());
 }
 
 Napi::Value TrackWrapper::maxMessageSize(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mTrackPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -208,13 +218,19 @@ Napi::Value TrackWrapper::maxMessageSize(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
 
 Napi::Value TrackWrapper::requestKeyframe(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "requestKeyframe() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
     Napi::Env env = info.Env();
     return Napi::Boolean::New(env, mTrackPtr->requestKeyframe());
 }
@@ -223,7 +239,7 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)
     {
-        Napi::Error::New(info.Env(), "It seems track is destroyed!").ThrowAsJavaScriptException();
+        Napi::Error::New(info.Env(), "setMediaHandler() called on destroyed track").ThrowAsJavaScriptException();
         return;
     }
 
@@ -232,7 +248,7 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
 
     if (length < 1 || !info[0].IsObject())
     {
-        Napi::TypeError::New(env, "Mediahandler class instance expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "MediaHandler class instance expected").ThrowAsJavaScriptException();
         return;
     }
 
@@ -242,6 +258,12 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onOpen() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -254,11 +276,10 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
     // Callback
     mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onOpen([&]()
-                      {
+    mTrackPtr->onOpen([&]() {
         if (mOnOpenCallback)
             mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+                // Check the track is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -270,6 +291,12 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onClosed() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -282,11 +309,25 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    // Object cb call moved to the constructor    
+    mTrackPtr->onClosed([&]() {
+        if (mOnClosedCallback)
+            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
+                // Do not check if the data channel has been closed here
+
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {};
+            }); });
 }
 
 void TrackWrapper::onError(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onError() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -299,11 +340,10 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
     // Callback
     mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onError([&](const std::string &error)
-                       {
+    mTrackPtr->onError([&](const std::string &error) {
         if (mOnErrorCallback)
             mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+                // Check the track is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
@@ -315,6 +355,12 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
 
 void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
 {
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "onMessage() called on destroyed track").ThrowAsJavaScriptException();
+        return;
+    }
+
     Napi::Env env = info.Env();
     int length = info.Length();
 
@@ -327,26 +373,19 @@ void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
     // Callback
     mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onMessage([&](const std::variant<rtc::binary, std::string> &message)
-                         {
+    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message) {
         if (mOnMessageCallback)
-            mOnMessageCallback->call([this, message](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
+            mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the track is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
 
                 // This will run in main thread and needs to construct the
                 // arguments for the call
-                Napi::Object payload = Napi::Object::New(env);
-                if (std::holds_alternative<std::string>(message))
-                {
-                    // Track will always send message as binary
-                    // So this code is not needed actually 
-                    args = {Napi::String::New(env, std::get<std::string>(message))};
-                }
-                else
+                if (std::holds_alternative<rtc::binary>(message)) // Track will always receive messages as binary
                 {
-                    args = {Napi::Buffer<std::byte>::Copy(env, std::get<rtc::binary>(message).data(), std::get<rtc::binary>(message).size())};
+                    auto bin = std::get<rtc::binary>(std::move(message));
+                    args = {Napi::Buffer<std::byte>::Copy(env, bin.data(), bin.size())};
                 }
             }); });
-}
+}

package/src/media-track-wrapper.h

@@ -46,7 +46,6 @@ private:
   static std::unordered_set<TrackWrapper *> instances;
 
   void doClose();
-  void cleanCbsAndEraseInstance();
 
   std::shared_ptr<rtc::Track> mTrackPtr = nullptr;