Moving to WebTransport over HTTP/3.

This change updates the QUIC SDK to support WebTransport over HTTP/3.

Author: jianjunz

doc/design/quic-programming-guide.md

@@ -3,7 +3,7 @@
 
 # Overview
 
-OWT QUIC SDK and Client SDKs provides the APIs for enabling QUIC Transport for reliable data transmission over QUIC protocol with OWT Conference Server.
+OWT QUIC SDK and Client SDKs provides the APIs for enabling WebTransport for reliable data transmission over QUIC protocol with OWT Conference Server.
 
 # Scope
 
@@ -12,7 +12,7 @@ This document describes the programming models and API interfaces for following
 - Deploying a QUIC conference server that is capable of forwarding data over QUIC channel.
 - Implementing client application that is capable of sending data to QUIC server or receiving data from it.
 
-Description of the details of QUIC transport is outside the scope of this document.
+Description of the details of WebTransport is outside the scope of this document.
 
 # Related Repos
 
@@ -29,19 +29,19 @@ The topology of components is shown in below diagram:
 
 ![plot](./pics/quic_block_diagram.png)
 
-There are a few components involved and their relationships with streaming using QuicTransport are described as below:
+There are a few components involved and their relationships with streaming using WebTransport are described as below:
 
 ## OWT QUIC C++ SDK
 
-This is the foundation of QUIC implementation in OWT. It provides the APIs to create QUIC transport clients and server forming a C/S architecture. Basically you can directly build your QUICTransport applications using the QUIC C++ SDK client API if you're not using the OWT native SDK.
+This is the foundation of WebTransport implementation in OWT. It provides the APIs to create WebTransport over HTTP/3 clients and server forming a C/S architecture. Basically you can directly build your WebTransport applications using the QUIC C++ SDK client API if you're not using the OWT native SDK.
 
 ## OWT Native SDK for Conference
 
-The OWT conference SDK built upon OWT QUIC C++ SDK client API. It is used in combination with OWT QUIC conference server when you rely on OWT signaling protocol for QUIC connection setup as well as stream forwarding.
+The OWT conference SDK built upon OWT QUIC C++ SDK client API. It is used in combination with OWT QUIC conference server when you rely on OWT signaling protocol for WebTransport connection setup as well as stream forwarding.
 
 ## OWT QUIC Conference Server
 
-The OWT QUIC conference server implements the signaling protocol for QUIC connection setup, as well as QUIC stream forwarding.
+The OWT QUIC conference server implements the signaling protocol for WebTransport connection setup, as well as QUIC stream forwarding.
 
 ## OWT QUIC JavaScript SDK
 
@@ -63,33 +63,33 @@ The server API calling flow is shown in below diagram and table.
 
 | Step # | API calling flow |
 | --- | --- |
-| 1 | Application calls the factory method of QuicTransportFactory::Create() to get an instance of QuicTransportFactory |
-| 2 | Application calls QuicTransportFactory::CreateQuicTransportServer() on the QuicTransportFactory instance got in step #1, specifying the server port, certificate path either in the form of .pkcs12 or .pfx format. |
-| 3 | Application Creates the Visitor instance of QuicTransportServerInterface |
-| 4 | Application calls SetVisitor on the QuicTransportServerInterface instance got in step #2. |
-| 5 | Application calls Start() method on the QuicTransportServerInterface instance got in step #2 |
-| 6 | OnSession() callback will be invoked once the quictransportserver gets a connection request from client, and an QuicTransportSession instance is passed from the callback. |
-| 7 | Application calls CreateBidirectionalStream on the QuicTransportSession got in step 6 and get a QuicTransportStreamInterface instance. |
-| 8 | Application creates QuicTransportStream::Visitor instance and invokes QuicTransportStreamInterface::SetVisitor(). |
-| 9 | Application reads the QuicTransportStream when OnCanRead is invoked on the QuicTransportStream::Visitor; or write to the QuicTransportStream when OnCanWrite is invoked on the QuicTransportStreamVisitor; |
+| 1 | Application calls the factory method of WebTransportFactory::Create() to get an instance of WebTransportFactory |
+| 2 | Application calls WebTransportFactory::CreateWebTransportServer() on the WebTransportFactory instance got in step #1, specifying the server port, certificate path either in the form of .pkcs12 or .pfx format. |
+| 3 | Application Creates the Visitor instance of WebTransportServerInterface |
+| 4 | Application calls SetVisitor on the WebTransportServerInterface instance got in step #2. |
+| 5 | Application calls Start() method on the WebTransportServerInterface instance got in step #2 |
+| 6 | OnSession() callback will be invoked once the WebTransportserver gets a connection request from client, and an WebTransportSession instance is passed from the callback. |
+| 7 | Application calls CreateBidirectionalStream on the WebTransportSession got in step 6 and get a WebTransportStreamInterface instance. |
+| 8 | Application creates WebTransportStream::Visitor instance and invokes WebTransportStreamInterface::SetVisitor(). |
+| 9 | Application reads the WebTransportStream when OnCanRead is invoked on the WebTransportStream::Visitor; or write to the WebTransportStream when OnCanWrite is invoked on the WebTransportStreamVisitor; |
 
 ## OWT QUIC C++ SDK Client API Calling Flow
 
-The client API calling flow is shown in below diagram and table. It's similar as the server side calling flow except the QuicTransportFactory creates a QuicTransportClientInterface, instead of a QUICTransportServerInterface, and client needs to call Connect() instead of Start() to get a QuicTransportSession.
+The client API calling flow is shown in below diagram and table. It's similar as the server side calling flow except the WebTransportFactory creates a WebTransportClientInterface, instead of a WebTransportServerInterface, and client needs to call Connect() instead of Start() to get a WebTransportSession.
 
 ![plot](./pics/client_API.png)
 
 | Step # | API calling flow |
 | --- | --- |
-| 1 | Application calls the factory method of QuicTransportFactory::Create() to get an instance of QuicTransportFactory |
-| 2 | Application calls QuicTransportFactory::CreateQuicTransportClient() on the QuicTransportFactory instance got in step #1, specifying the server URL to connect to. |
-| 3 | Application Creates the Visitor instance of QuicTransportClientInterface |
-| 4 | Application calls SetVisitor on the QuicTransportClientInterface instance got in step #2. |
-| 5 | Application calls Connect() method on the QuicTransportClientInterface instance got in step #2, passing the URL of the server. |
-| 6 | OnSession() callback will be invoked once the quictransportclient successfully connects to server, and an QuicTransportSession instance is passed from the callback. |
-| 7 | Application calls CreateBidirectionalStream on the QuicTransportSession got in step 6 and get a QuicTransportStreamInterface instance. |
-| 8 | Application creates QuicTransportStream::Visitor instance and invokes QuicTransportStreamInterface::SetVisitor(). |
-| 9 | Application reads the QuicTransportStream when OnCanRead is invoked on the QuicTransportStream::Visitor; or write to the QuicTransportStream when OnCanWrite is invoked on the QuicTransportStreamVisitor; |
+| 1 | Application calls the factory method of WebTransportFactory::Create() to get an instance of WebTransportFactory |
+| 2 | Application calls WebTransportFactory::CreateWebTransportClient() on the WebTransportFactory instance got in step #1, specifying the server URL to connect to. |
+| 3 | Application Creates the Visitor instance of WebTransportClientInterface |
+| 4 | Application calls SetVisitor on the WebTransportClientInterface instance got in step #2. |
+| 5 | Application calls Connect() method on the WebTransportClientInterface instance got in step #2, passing the URL of the server. |
+| 6 | OnSession() callback will be invoked once the WebTransportclient successfully connects to server, and an WebTransportSession instance is passed from the callback. |
+| 7 | Application calls CreateBidirectionalStream on the WebTransportSession got in step 6 and get a WebTransportStreamInterface instance. |
+| 8 | Application creates WebTransportStream::Visitor instance and invokes WebTransportStreamInterface::SetVisitor(). |
+| 9 | Application reads the WebTransportStream when OnCanRead is invoked on the WebTransportStream::Visitor; or write to the WebTransportStream when OnCanWrite is invoked on the WebTransportStreamVisitor; |
 
 ## Details of Callbacks and Data Structures of QUIC C++ SDK
 
@@ -139,7 +139,7 @@ The Windows sample will be provided in OWT repo separately. More details will be
 
 # How to Replace the Certificate for QUIC
 
-OWT Conference Server is using a self-signed certificate during development phase, which would be only valid for 14 days. You can use a CA-signed certificate to avoid refreshing the certificate periodically. QUIC connection will fail if certificate is not valid or expires.
+OWT Conference Server is using a self-signed certificate during development phase, which would be only valid for 14 days. You can use a CA-signed certificate to avoid refreshing the certificate periodically. WebTransport connection will fail if certificate is not valid or expires.
 
 ## Precondition
 

source/agent/addons/quic/QuicFactory.cc

@@ -5,7 +5,7 @@
  */
 
 #include "QuicFactory.h"
-#include "owt/quic/quic_transport_factory.h"
+#include "owt/quic/web_transport_factory.h"
 #include <mutex>
 
 DEFINE_LOGGER(QuicFactory, "QuicFactory");
@@ -15,11 +15,11 @@ std::once_flag getQuicFactoryOnce;
 std::shared_ptr<QuicFactory> QuicFactory::s_quicFactory = nullptr;
 
 QuicFactory::QuicFactory()
-    : m_quicTransportFactory(std::shared_ptr<owt::quic::QuicTransportFactory>(owt::quic::QuicTransportFactory::Create()))
+    : m_quicTransportFactory(std::shared_ptr<owt::quic::WebTransportFactory>(owt::quic::WebTransportFactory::Create()))
 {
 }
 
-std::shared_ptr<owt::quic::QuicTransportFactory> QuicFactory::getQuicTransportFactory()
+std::shared_ptr<owt::quic::WebTransportFactory> QuicFactory::getQuicTransportFactory()
 {
     std::call_once(getQuicFactoryOnce, []() {
         QuicFactory* factory = new QuicFactory();

source/agent/addons/quic/QuicFactory.h

@@ -12,21 +12,21 @@
 
 namespace owt {
 namespace quic {
-    class QuicTransportFactory;
+    class WebTransportFactory;
 }
 }
 
 class QuicFactory {
 public:
     DECLARE_LOGGER();
     virtual ~QuicFactory() = default;
-    static std::shared_ptr<owt::quic::QuicTransportFactory> getQuicTransportFactory();
+    static std::shared_ptr<owt::quic::WebTransportFactory> getQuicTransportFactory();
 
 private:
     explicit QuicFactory();
 
     static std::shared_ptr<QuicFactory> s_quicFactory;
-    std::shared_ptr<owt::quic::QuicTransportFactory> m_quicTransportFactory;
+    std::shared_ptr<owt::quic::WebTransportFactory> m_quicTransportFactory;
 };
 
 #endif

source/agent/addons/quic/QuicTransportConnection.cc

@@ -50,7 +50,7 @@ void QuicTransportConnection::setVisitor(Visitor* visitor)
     m_visitor = visitor;
 }
 
-void QuicTransportConnection::OnIncomingStream(owt::quic::QuicTransportStreamInterface* stream)
+void QuicTransportConnection::OnIncomingStream(owt::quic::WebTransportStreamInterface* stream)
 {
     ELOG_DEBUG("OnIncomingStream.");
     {
@@ -77,7 +77,7 @@ NAN_METHOD(QuicTransportConnection::newInstance)
     info.GetReturnValue().Set(info.This());
 }
 
-v8::Local<v8::Object> QuicTransportConnection::newInstance(owt::quic::QuicTransportSessionInterface* session)
+v8::Local<v8::Object> QuicTransportConnection::newInstance(owt::quic::WebTransportSessionInterface* session)
 {
     Local<Object> connectionObject = Nan::NewInstance(Nan::New(QuicTransportConnection::s_constructor)).ToLocalChecked();
     QuicTransportConnection* obj = Nan::ObjectWrap::Unwrap<QuicTransportConnection>(connectionObject);

source/agent/addons/quic/QuicTransportConnection.h

@@ -16,9 +16,9 @@
 #include <nan.h>
 
 #include "QuicTransportStream.h"
-#include "owt/quic/quic_transport_session_interface.h"
+#include "owt/quic/web_transport_session_interface.h"
 
-class QuicTransportConnection : public Nan::ObjectWrap, public owt::quic::QuicTransportSessionInterface::Visitor, QuicTransportStream::Visitor {
+class QuicTransportConnection : public Nan::ObjectWrap, public owt::quic::WebTransportSessionInterface::Visitor, QuicTransportStream::Visitor {
     DECLARE_LOGGER();
 
 public:
@@ -31,7 +31,7 @@ class QuicTransportConnection : public Nan::ObjectWrap, public owt::quic::QuicTr
     explicit QuicTransportConnection();
     ~QuicTransportConnection();
     void setVisitor(Visitor* visitor);
-    static v8::Local<v8::Object> newInstance(owt::quic::QuicTransportSessionInterface* session);
+    static v8::Local<v8::Object> newInstance(owt::quic::WebTransportSessionInterface* session);
 
     static NAN_MODULE_INIT(init);
     static NAN_METHOD(newInstance);
@@ -41,15 +41,16 @@ class QuicTransportConnection : public Nan::ObjectWrap, public owt::quic::QuicTr
     static Nan::Persistent<v8::Function> s_constructor;
 
 protected:
-    // Overrides owt::quic::QuicTransportSessionInterface::Visitor.
-    void OnIncomingStream(owt::quic::QuicTransportStreamInterface*) override;
+    // Overrides owt::quic::WebTransportSessionInterface::Visitor.
+    void OnIncomingStream(owt::quic::WebTransportStreamInterface*) override;
     void OnCanCreateNewOutgoingStream(bool unidirectional) override { }
+    void OnConnectionClosed() override { }
 
     // Overrides QuicTransportStream::Visitor.
     void onEnded() override;
 
 private:
-    owt::quic::QuicTransportSessionInterface* m_session;
+    owt::quic::WebTransportSessionInterface* m_session;
     Visitor* m_visitor;
     // Key is content session ID, i.e.: publication ID, subscription ID.
     std::unordered_map<std::string, std::unique_ptr<QuicTransportStream>> m_streams;
@@ -58,7 +59,7 @@ class QuicTransportConnection : public Nan::ObjectWrap, public owt::quic::QuicTr
 
     uv_async_t m_asyncOnStream;
     std::mutex m_streamQueueMutex;
-    std::queue<owt::quic::QuicTransportStreamInterface*> m_streamsToBeNotified;
+    std::queue<owt::quic::WebTransportStreamInterface*> m_streamsToBeNotified;
 };
 
 #endif

source/agent/addons/quic/QuicTransportServer.cc

@@ -8,8 +8,8 @@
 #include "QuicFactory.h"
 #include "QuicTransportStream.h"
 #include "Utils.h"
-#include "owt/quic/quic_transport_factory.h"
-#include "owt/quic/quic_transport_session_interface.h"
+#include "owt/quic/web_transport_factory.h"
+#include "owt/quic/web_transport_session_interface.h"
 
 using v8::Function;
 using v8::FunctionTemplate;
@@ -23,7 +23,7 @@ Nan::Persistent<v8::Function> QuicTransportServer::s_constructor;
 DEFINE_LOGGER(QuicTransportServer, "QuicTransportServer");
 
 QuicTransportServer::QuicTransportServer(int port, const std::string& pfxPath, const std::string& password)
-    : m_quicServer(QuicFactory::getQuicTransportFactory()->CreateQuicTransportServer(port, pfxPath.c_str(), password.c_str()))
+    : m_quicServer(QuicFactory::getQuicTransportFactory()->CreateWebTransportServer(port, pfxPath.c_str(), password.c_str()))
 {
     m_quicServer->SetVisitor(this);
     ELOG_DEBUG("QuicTransportServer::QuicTransportServer");
@@ -113,7 +113,7 @@ void QuicTransportServer::OnEnded()
     ELOG_DEBUG("QuicTransport server ended.");
 }
 
-void QuicTransportServer::OnSession(owt::quic::QuicTransportSessionInterface* session)
+void QuicTransportServer::OnSession(owt::quic::WebTransportSessionInterface* session)
 {
     ELOG_DEBUG("New session created. Connection ID: %s.", session->ConnectionId());
     {

source/agent/addons/quic/QuicTransportServer.h

@@ -8,23 +8,23 @@
 #define QUIC_QUICTRANSPORTSERVER_H_
 
 #include "QuicTransportConnection.h"
-#include "owt/quic/quic_transport_server_interface.h"
+#include "owt/quic/web_transport_server_interface.h"
 #include <logger.h>
 #include <mutex>
 #include <nan.h>
 #include <string>
 #include <unordered_map>
 
-class QuicTransportServer : public Nan::ObjectWrap, owt::quic::QuicTransportServerInterface::Visitor, QuicTransportConnection::Visitor {
+class QuicTransportServer : public Nan::ObjectWrap, owt::quic::WebTransportServerInterface::Visitor, QuicTransportConnection::Visitor {
     DECLARE_LOGGER();
 
 public:
     static NAN_MODULE_INIT(init);
 
 protected:
-    // Overrides owt::quic::QuicTransportServerInterface::Visitor.
+    // Overrides owt::quic::WebTransportServerInterface::Visitor.
     void OnEnded() override;
-    void OnSession(owt::quic::QuicTransportSessionInterface*) override;
+    void OnSession(owt::quic::WebTransportSessionInterface*) override;
 
     // Overrides QuicTransportConnection::Visitor.
     void onAuthentication(const std::string& id) override;
@@ -40,11 +40,11 @@ class QuicTransportServer : public Nan::ObjectWrap, owt::quic::QuicTransportServ
     static NAN_METHOD(stop);
     static NAUV_WORK_CB(onConnectionCallback);
 
-    std::unique_ptr<owt::quic::QuicTransportServerInterface> m_quicServer;
+    std::unique_ptr<owt::quic::WebTransportServerInterface> m_quicServer;
 
     uv_async_t m_asyncOnConnection;
     std::mutex m_connectionQueueMutex;
-    std::queue<owt::quic::QuicTransportSessionInterface*> m_connectionsToBeNotified;
+    std::queue<owt::quic::WebTransportSessionInterface*> m_connectionsToBeNotified;
 
     static Nan::Persistent<v8::Function> s_constructor;
 };

source/agent/addons/quic/QuicTransportStream.cc

@@ -23,7 +23,7 @@ QuicTransportStream::QuicTransportStream()
     : QuicTransportStream(nullptr)
 {
 }
-QuicTransportStream::QuicTransportStream(owt::quic::QuicTransportStreamInterface* stream)
+QuicTransportStream::QuicTransportStream(owt::quic::WebTransportStreamInterface* stream)
     : m_stream(stream)
     , m_contentSessionId()
     , m_receivedContentSessionId(false)
@@ -129,7 +129,7 @@ NAN_METHOD(QuicTransportStream::removeDestination)
 {
 }
 
-v8::Local<v8::Object> QuicTransportStream::newInstance(owt::quic::QuicTransportStreamInterface* stream)
+v8::Local<v8::Object> QuicTransportStream::newInstance(owt::quic::WebTransportStreamInterface* stream)
 {
     Local<Object> streamObject = Nan::NewInstance(Nan::New(QuicTransportStream::s_constructor)).ToLocalChecked();
     QuicTransportStream* obj = Nan::ObjectWrap::Unwrap<QuicTransportStream>(streamObject);

source/agent/addons/quic/QuicTransportStream.h

@@ -7,14 +7,14 @@
 #ifndef QUIC_QUICTRANSPORTSTREAM_H_
 #define QUIC_QUICTRANSPORTSTREAM_H_
 
-#include "owt/quic/quic_transport_stream_interface.h"
+#include "owt/quic/web_transport_stream_interface.h"
 #include "../../core/owt_base/MediaFramePipeline.h"
 #include <logger.h>
 #include <nan.h>
 #include <mutex>
 #include <string>
 
-class QuicTransportStream : public owt_base::FrameSource, public owt_base::FrameDestination, public Nan::ObjectWrap, public owt::quic::QuicTransportStreamInterface::Visitor {
+class QuicTransportStream : public owt_base::FrameSource, public owt_base::FrameDestination, public Nan::ObjectWrap, public owt::quic::WebTransportStreamInterface::Visitor {
     DECLARE_LOGGER();
 
 public:
@@ -24,10 +24,10 @@ class QuicTransportStream : public owt_base::FrameSource, public owt_base::Frame
     };
     explicit QuicTransportStream();
     // `sessionId` is the ID of publication or subscription, NOT the ID of QUIC session.
-    explicit QuicTransportStream(owt::quic::QuicTransportStreamInterface* stream);
+    explicit QuicTransportStream(owt::quic::WebTransportStreamInterface* stream);
     virtual ~QuicTransportStream();
 
-    static v8::Local<v8::Object> newInstance(owt::quic::QuicTransportStreamInterface* stream);
+    static v8::Local<v8::Object> newInstance(owt::quic::WebTransportStreamInterface* stream);
 
     static NAN_MODULE_INIT(init);
     static NAN_METHOD(newInstance);
@@ -48,7 +48,7 @@ class QuicTransportStream : public owt_base::FrameSource, public owt_base::Frame
     static Nan::Persistent<v8::Function> s_constructor;
 
 protected:
-    // Overrides owt::quic::QuicTransportStreamInterface::Visitor.
+    // Overrides owt::quic::WebTransportStreamInterface::Visitor.
     void OnCanRead() override;
     void OnCanWrite() override;
     void OnFinRead() override;
@@ -59,7 +59,7 @@ class QuicTransportStream : public owt_base::FrameSource, public owt_base::Frame
     void SignalOnData();
     void ReallocateBuffer(size_t size);
 
-    owt::quic::QuicTransportStreamInterface* m_stream;
+    owt::quic::WebTransportStreamInterface* m_stream;
     std::vector<uint8_t> m_contentSessionId;
     bool m_receivedContentSessionId;
     // True if it's piped to a receiver in C++ layer. In this case, data will not be sent to JavaScript code.