Address some format and naming issues.

Author: jianjunz

source/agent/addons/quic/QuicFactory.cc

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <mutex>
 #include "QuicFactory.h"
 #include "owt/quic/quic_transport_factory.h"
+#include <mutex>
 
 DEFINE_LOGGER(QuicFactory, "QuicFactory");
 
@@ -17,18 +17,13 @@ std::shared_ptr<QuicFactory> QuicFactory::s_quicFactory = nullptr;
 QuicFactory::QuicFactory()
     : m_quicTransportFactory(std::shared_ptr<owt::quic::QuicTransportFactory>(owt::quic::QuicTransportFactory::Create()))
 {
-    ELOG_DEBUG("QuicFactory ctor.");
 }
 
 std::shared_ptr<owt::quic::QuicTransportFactory> QuicFactory::getQuicTransportFactory()
 {
-    ELOG_DEBUG("Before call once.");
     std::call_once(getQuicFactoryOnce, []() {
-        ELOG_DEBUG("Before new.");
-        QuicFactory* factory=new QuicFactory();
-        ELOG_DEBUG("After new.");
+        QuicFactory* factory = new QuicFactory();
         s_quicFactory = std::shared_ptr<QuicFactory>(factory);
     });
-    ELOG_DEBUG("After call once.");
     return s_quicFactory->m_quicTransportFactory;
 }

source/agent/addons/quic/QuicTransportStream.cc

@@ -17,7 +17,7 @@ DEFINE_LOGGER(QuicTransportStream, "QuicTransportStream");
 
 Nan::Persistent<v8::Function> QuicTransportStream::s_constructor;
 
-const int uuidSizeInByte = 16;
+const int uuidSizeInBytes = 16;
 
 QuicTransportStream::QuicTransportStream()
     : QuicTransportStream(nullptr)
@@ -70,7 +70,6 @@ NAN_MODULE_INIT(QuicTransportStream::init)
 
     Nan::SetPrototypeMethod(tpl, "write", write);
     Nan::SetPrototypeMethod(tpl, "addDestination", addDestination);
-    //Nan::SetPrototypeMethod(tpl, "write", write);
 
     s_constructor.Reset(Nan::GetFunction(tpl).ToLocalChecked());
     Nan::Set(target, Nan::New("QuicTransportStream").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
@@ -89,13 +88,14 @@ NAN_METHOD(QuicTransportStream::newInstance)
     info.GetReturnValue().Set(info.This());
 }
 
-NAN_METHOD(QuicTransportStream::write){
-    if(info.Length()<2){
+NAN_METHOD(QuicTransportStream::write)
+{
+    if (info.Length() < 2) {
         Nan::ThrowTypeError("Data is not provided.");
         return;
     }
     QuicTransportStream* obj = Nan::ObjectWrap::Unwrap<QuicTransportStream>(info.Holder());
-    uint8_t* buffer=(uint8_t*)node::Buffer::Data(info[0]->ToObject());
+    uint8_t* buffer = (uint8_t*)node::Buffer::Data(info[0]->ToObject());
     unsigned int length = info[1]->Uint32Value();
     obj->m_stream->Write(buffer, length);
     info.GetReturnValue().Set(info.This());
@@ -133,14 +133,14 @@ void QuicTransportStream::MaybeReadContentSessionId()
 {
     if (!m_receivedContentSessionId) {
         // Match to a content session.
-        if (m_stream->ReadableBytes() > 0 && m_stream->ReadableBytes() < uuidSizeInByte) {
+        if (m_stream->ReadableBytes() > 0 && m_stream->ReadableBytes() < uuidSizeInBytes) {
             ELOG_ERROR("No enough data to get content session ID.");
             m_stream->Close();
             return;
         }
-        uint8_t* data = new uint8_t[uuidSizeInByte];
-        m_stream->Read(data, uuidSizeInByte);
-        m_contentSessionId = std::vector<uint8_t>(data, data + uuidSizeInByte);
+        uint8_t* data = new uint8_t[uuidSizeInBytes];
+        m_stream->Read(data, uuidSizeInBytes);
+        m_contentSessionId = std::vector<uint8_t>(data, data + uuidSizeInBytes);
         m_receivedContentSessionId = true;
         m_asyncOnContentSessionId.data = this;
         uv_async_send(&m_asyncOnContentSessionId);
@@ -150,7 +150,8 @@ void QuicTransportStream::MaybeReadContentSessionId()
     }
 }
 
-NAUV_WORK_CB(QuicTransportStream::onData){
+NAUV_WORK_CB(QuicTransportStream::onData)
+{
     Nan::HandleScope scope;
     QuicTransportStream* obj = reinterpret_cast<QuicTransportStream*>(async->data);
     if (obj == nullptr) {
@@ -185,15 +186,15 @@ NAUV_WORK_CB(QuicTransportStream::onContentSessionId)
         if (onEventLocal->IsFunction()) {
             v8::Local<v8::Function> eventCallback = onEventLocal.As<Function>();
             Nan::AsyncResource* resource = new Nan::AsyncResource(Nan::New<v8::String>("oncontentsessionid").ToLocalChecked());
-            Local<Value> args[]={Nan::CopyBuffer((char*)obj->m_contentSessionId.data(),uuidSizeInByte).ToLocalChecked()};
+            Local<Value> args[] = { Nan::CopyBuffer((char*)obj->m_contentSessionId.data(), uuidSizeInBytes).ToLocalChecked() };
             resource->runInAsyncScope(Nan::GetCurrentContext()->Global(), eventCallback, 1, args);
         }
     }
 }
 
 void QuicTransportStream::SignalOnData()
 {
-    if(!m_isPiped){
+    if (!m_isPiped) {
         m_asyncOnData.data = this;
         uv_async_send(&m_asyncOnData);
         return;

source/agent/conference/roomController.js

@@ -1524,13 +1524,13 @@ module.exports.create = function (spec, on_init_ok, on_init_failed) {
                 on_error(error_reason);
             };
 
-            const createMapForSources=function(audioStreamId, videoStreamId, dataStreamId){
-                const sourceMap=new Map();
-                sourceMap['audio']=audioStreamId;
-                sourceMap['video']=videoStreamId;
-                sourceMap['data']=dataStreamId
+            const createMapForSources = function(audioStreamId, videoStreamId, dataStreamId) {
+                const sourceMap = new Map();
+                sourceMap['audio'] = audioStreamId;
+                sourceMap['video'] = videoStreamId;
+                sourceMap['data'] = dataStreamId;
                 return sourceMap;
-            }
+            };
 
             var finally_ok = function (audioStream, videoStream, dataStream) {
                 return function () {
@@ -1540,9 +1540,9 @@ module.exports.create = function (spec, on_init_ok, on_init_failed) {
                         (!dataStream || streams[dataStream])) {
 
                         terminals[terminal_id].subscribed[subscriptionId] = {};
-                        for(cosnt [kind, streamId] of createMapForSources(audioStream,videoStream,dataStream)){
-                            if(from){
-                                streams[streamId][kind].subscriber=streams[streamId][kind].subscribers||[];
+                        for (const [kind, streamId] of createMapForSources(audioStream, videoStream, dataStream)) {
+                            if (from) {
+                                streams[streamId][kind].subscriber = streams[streamId][kind].subscribers || [];
                                 streams[streamId][kind].subscribers.push(terminal_id);
                                 terminals[terminal_id].subscribed[subscriptionId].audio = streamId;
                             }

source/agent/quic/index.js

@@ -18,8 +18,9 @@
 const Connections = require('./connections');
 const InternalConnectionFactory = require('./InternalConnectionFactory');
 const logger = require('../logger').logger;
-const QuicTransportServer=require('./webtransport/quicTransportServer');
-const QuicTransportStreamPipeline=require('./webtransport/quicTransportStreamPipeline');
+const QuicTransportServer = require('./webtransport/quicTransportServer');
+const QuicTransportStreamPipeline =
+    require('./webtransport/quicTransportStreamPipeline');
 const log = logger.getLogger('QuicNode');
 const addon = require('./build/Release/quic');
 
@@ -34,7 +35,7 @@ module.exports = function (rpcClient, selfRpcId, parentRpcId, clusterWorkerIP) {
     var internalConnFactory = new InternalConnectionFactory;
     const incomingStreamPipelines =
         new Map();  // Key is publication ID, value is stream pipeline.
-    const outgoingStreamPipeline =
+    const outgoingStreamPipelines =
         new Map();  // Key is subscription ID, value is stream pipeline.
 
     var notifyStatus = (controller, sessionId, direction, status) => {
@@ -68,7 +69,7 @@ module.exports = function (rpcClient, selfRpcId, parentRpcId, clusterWorkerIP) {
       if (direction === 'in') {
         pipelineMap = incomingStreamPipelines;
       } else {
-        pipelineMap = outgoingStreamPipeline;
+        pipelineMap = outgoingStreamPipelines;
       }
       if (pipelineMap.has(streamId)) {
         return callback(