WIP setLocalDescription + createDataChannel

Author: Clément Charmet

binding.gyp

@@ -4,10 +4,12 @@
             'target_name': 'webrtc',
             'sources': [
                 'src/event/createsessiondescriptionevent.cc',
+                'src/event/setsessiondescriptionevent.cc',
                 'src/event/eventqueue.cc',
                 'src/globals.cc',
                 'src/module.cc',
                 'src/observer/createsessiondescriptionobserver.cc',
+                'src/observer/setsessiondescriptionobserver.cc',
                 'src/observer/peerconnectionobserver.cc',
                 'src/rtccertificate.cc',
                 'src/rtcicecandidate.cc',

src/common.h

@@ -122,6 +122,14 @@
   \
   Local<Function> N = info[I].As<v8::Function>();
 
+#define ASSERT_STRING_ARGUMENT(I, N) \
+  if (!info[I]->IsString()) { \
+    errorStream << ERROR_ARGUMENT_NOT_FUNCTION(I + 1, #N); \
+    return Nan::ThrowTypeError(errorStream.str().c_str()); \
+  } \
+  \
+  String::Utf8Value N(info[I]->ToString());
+
 #define ASSERT_REJECT_OBJECT_ARGUMENT(I, N) \
   if (!info[I]->IsObject()) { \
     errorStream << ERROR_ARGUMENT_NOT_OBJECT(I + 1, #N); \

src/event/setsessiondescriptionevent.cc

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2017 Axel Isouard <axel@isouard.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "common.h"
+#include "setsessiondescriptionevent.h"
+#include "rtcsessiondescription.h"
+
+using namespace v8;
+
+SetSessionDescriptionEvent::SetSessionDescriptionEvent(
+    Persistent<Function> *successCallback,
+    Persistent<Function> *failureCallback) :
+    _resolver(NULL),
+    _successCallback(successCallback),
+    _failureCallback(failureCallback) {
+}
+
+SetSessionDescriptionEvent::SetSessionDescriptionEvent(
+    Persistent<Promise::Resolver> *resolver) :
+    _resolver(resolver),
+    _successCallback(NULL),
+    _failureCallback(NULL) {
+}
+
+void SetSessionDescriptionEvent::Handle() {
+  Nan::HandleScope scope;
+
+  if (_resolver) {
+    Local<Promise::Resolver> resolver = Nan::New(*_resolver);
+
+    if (_succeeded) {
+      resolver->Resolve(Nan::Undefined());
+    } else {
+      resolver->Reject(Nan::Error(_errorMessage.c_str()));
+    }
+
+    Isolate::GetCurrent()->RunMicrotasks();
+    _resolver->Reset();
+    delete _resolver;
+    return;
+  }
+
+  if (_succeeded && _successCallback) {
+    Local<Function> successCallback = Nan::New(*_successCallback);
+    Nan::Callback cb(successCallback);
+    
+    const int argc = 0;
+    Local<Value> argv[0] = {};
+
+    cb.Call(argc, argv);
+  } else if (!_succeeded && _failureCallback) {
+    Local<Function> failureCallback = Nan::New(*_failureCallback);
+    Nan::Callback cb(failureCallback);
+
+    const int argc = 1;
+    Local<Value> argv[1] = { Nan::Error(_errorMessage.c_str()) };
+
+    cb.Call(argc, argv);
+  }
+
+  _successCallback->Reset();
+  _failureCallback->Reset();
+
+  delete _successCallback;
+  delete _failureCallback;
+}
+
+void SetSessionDescriptionEvent::SetSucceeded(bool succeeded) {
+  _succeeded = succeeded;
+}
+
+void SetSessionDescriptionEvent::SetErrorMessage(
+    const std::string &errorMessage) {
+  _errorMessage = errorMessage;
+}

src/event/setsessiondescriptionevent.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2017 Axel Isouard <axel@isouard.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef EVENT_SETSESSIONDESCRIPTIONEVENT_H_
+#define EVENT_SETSESSIONDESCRIPTIONEVENT_H_
+
+#include <nan.h>
+#include <webrtc/api/jsep.h>
+#include "event.h"
+
+using namespace v8;
+
+class SetSessionDescriptionEvent : public Event {
+ public:
+  explicit SetSessionDescriptionEvent(
+      Persistent<Promise::Resolver> *resolver);
+  SetSessionDescriptionEvent(Persistent<Function> *successCallback,
+                                Persistent<Function> *failureCallback);
+
+  void Handle();
+  void SetSucceeded(bool succeeded);
+  void SetErrorMessage(const std::string& errorMessage);
+  
+ private:
+  Persistent<Promise::Resolver> *_resolver;
+  Persistent<Function> *_successCallback;
+  Persistent<Function> *_failureCallback;
+  bool _succeeded;
+  std::string _errorMessage;
+};
+
+#endif  // EVENT_SETSESSIONDESCRIPTIONEVENT_H_

src/observer/createsessiondescriptionobserver.h

@@ -47,4 +47,4 @@ class CreateSessionDescriptionObserver :
                                       Persistent<Function> *failureCallback);
 };
 
-#endif  // OBSERVER_CREATESESSIONDESCRIPTIONOBSERVER_H_
+#endif  // OBSERVER_SETSESSIONDESCRIPTIONOBSERVER_H_

src/observer/setsessiondescriptionobserver.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2017 Axel Isouard <axel@isouard.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+#include "common.h"
+#include "setsessiondescriptionobserver.h"
+#include "event/setsessiondescriptionevent.h"
+#include "globals.h"
+
+using namespace v8;
+
+SetSessionDescriptionObserver::SetSessionDescriptionObserver(
+    Persistent<Promise::Resolver> *resolver) {
+  _event = new SetSessionDescriptionEvent(resolver);
+}
+
+SetSessionDescriptionObserver::SetSessionDescriptionObserver(
+    Persistent<Function> *successCallback,
+    Persistent<Function> *failureCallback) {
+  _event = new SetSessionDescriptionEvent(successCallback, failureCallback);
+}
+
+SetSessionDescriptionObserver *SetSessionDescriptionObserver::
+  Create(Persistent<Function> *successCallback,
+       Persistent<Function> *failureCallback) {
+  return new rtc::RefCountedObject<SetSessionDescriptionObserver>
+      (successCallback, failureCallback);
+}
+
+SetSessionDescriptionObserver *SetSessionDescriptionObserver::
+  Create(Persistent<Promise::Resolver> *resolver) {
+  return new rtc::RefCountedObject<SetSessionDescriptionObserver>
+      (resolver);
+}
+
+void SetSessionDescriptionObserver::OnSuccess() {
+  _event->SetSucceeded(true);
+  Globals::GetEventQueue()->PushEvent(_event);
+}
+
+void SetSessionDescriptionObserver::OnFailure(const std::string &error) {
+  _event->SetSucceeded(false);
+  _event->SetErrorMessage(error);
+  Globals::GetEventQueue()->PushEvent(_event);
+}

src/observer/setsessiondescriptionobserver.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2017 Axel Isouard <axel@isouard.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OBSERVER_SETSESSIONDESCRIPTIONOBSERVER_H_
+#define OBSERVER_SETSESSIONDESCRIPTIONOBSERVER_H_
+
+#include <nan.h>
+#include <string>
+#include <webrtc/api/peerconnectioninterface.h>
+
+using namespace v8;
+
+class SetSessionDescriptionEvent;
+class SetSessionDescriptionObserver :
+    public webrtc::SetSessionDescriptionObserver {
+ public:
+  static SetSessionDescriptionObserver *Create(
+      Persistent<Promise::Resolver> *resolver);
+  static SetSessionDescriptionObserver *Create(
+      Persistent<Function> *successCallback,
+      Persistent<Function> *failureCallback);
+
+  void OnSuccess();
+  void OnFailure(const std::string& error);
+
+ private:
+  SetSessionDescriptionEvent *_event;
+
+ protected:
+  explicit SetSessionDescriptionObserver(
+      Persistent<Promise::Resolver> *resolver);
+
+  SetSessionDescriptionObserver(Persistent<Function> *successCallback,
+                                      Persistent<Function> *failureCallback);
+};
+
+#endif  // OBSERVER_SETSESSIONDESCRIPTIONOBSERVER_H_

src/rtcpeerconnection.cc

@@ -21,15 +21,19 @@
 #include "common.h"
 #include "globals.h"
 #include "observer/createsessiondescriptionobserver.h"
+#include "observer/setsessiondescriptionobserver.h"
 #include "observer/peerconnectionobserver.h"
 #include "rtccertificate.h"
 #include "rtcpeerconnection.h"
+#include "rtcsessiondescription.h"
 
 Nan::Persistent<FunctionTemplate> RTCPeerConnection::constructor;
 
 static const char sRTCPeerConnection[] = "RTCPeerConnection";
 
 static const char kCreateOffer[] = "createOffer";
+static const char kSetLocalDescription[] = "setLocalDescription";
+static const char kCreateDataChannel[] = "createDataChannel";
 static const char kGenerateCertificate[] = "generateCertificate";
 
 static const char kIceServers[] = "iceServers";
@@ -90,6 +94,8 @@ NAN_MODULE_INIT(RTCPeerConnection::Init) {
 
   Local<ObjectTemplate> prototype = ctor->InstanceTemplate();
   Nan::SetMethod(prototype, kCreateOffer, CreateOffer);
+  Nan::SetMethod(prototype, kSetLocalDescription, SetLocalDescription);
+  Nan::SetMethod(prototype, kCreateDataChannel, CreateDataChannel);
 
   Local<ObjectTemplate> tpl = ctor->InstanceTemplate();
   Nan::SetAccessor(tpl, LOCAL_STRING(kConnectionState),
@@ -132,7 +138,6 @@ NAN_METHOD(RTCPeerConnection::New) {
   CONSTRUCTOR_HEADER("RTCPeerConnection")
   webrtc::FakeConstraints constraints;
   webrtc::PeerConnectionInterface::RTCConfiguration _config;
-  webrtc::PeerConnectionInterface::IceServer server;
 
   if (info.Length() > 0) {
     ASSERT_OBJECT_ARGUMENT(0, config);
@@ -223,6 +228,38 @@ NAN_METHOD(RTCPeerConnection::CreateOffer) {
   object->_peerConnection->CreateOffer(observer, &constraints);
 }
 
+NAN_METHOD(RTCPeerConnection::SetLocalDescription) {
+  METHOD_HEADER("RTCPeerConnection", "setLocalDescription");
+  UNWRAP_OBJECT(RTCPeerConnection, object);
+
+  rtc::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
+
+  // FIXME: Promise implementation only
+  DECLARE_PROMISE_RESOLVER;
+  ASSERT_REJECT_OBJECT_ARGUMENT(0, sessionDescription);
+
+  // FIXME: validate it's a RTCSessionDescription object
+  RTCSessionDescription* _sessionDescription = Nan::ObjectWrap::Unwrap<RTCSessionDescription>(sessionDescription);
+
+  observer = SetSessionDescriptionObserver::Create(
+      new Nan::Persistent<Promise::Resolver>(resolver));
+
+  object->_peerConnection->SetLocalDescription(observer, _sessionDescription->_sessionDescription);
+
+}
+
+NAN_METHOD(RTCPeerConnection::CreateDataChannel) {
+  METHOD_HEADER("RTCPeerConnection", "setLocalDescription");
+  UNWRAP_OBJECT(RTCPeerConnection, object);
+
+  ASSERT_STRING_ARGUMENT(0, name);
+
+  const webrtc::DataChannelInit init;
+
+  object->_peerConnection->CreateDataChannel(*name, &init);
+
+}
+
 NAN_GETTER(RTCPeerConnection::GetConnectionState) {
   info.GetReturnValue().Set(LOCAL_STRING("new"));
 }

src/rtcpeerconnection.h

@@ -36,6 +36,8 @@ class RTCPeerConnection : public Nan::ObjectWrap {
 
   static NAN_METHOD(New);
   static NAN_METHOD(CreateOffer);
+  static NAN_METHOD(SetLocalDescription);
+  static NAN_METHOD(CreateDataChannel);
   static NAN_METHOD(GenerateCertificate);
 
   static NAN_GETTER(GetConnectionState);

src/rtcsessiondescription.h

@@ -42,6 +42,8 @@ class RTCSessionDescription : public Nan::ObjectWrap {
   static const char kPranswer[];
   static const char kRollback[];
 
+  webrtc::SessionDescriptionInterface *_sessionDescription;
+
  private:
   explicit RTCSessionDescription(
       webrtc::SessionDescriptionInterface *sessionDescription);
@@ -51,9 +53,6 @@ class RTCSessionDescription : public Nan::ObjectWrap {
 
   static NAN_GETTER(GetType);
   static NAN_GETTER(GetSdp);
-
- protected:
-  webrtc::SessionDescriptionInterface *_sessionDescription;
 };
 
 #endif  // RTCSESSIONDESCRIPTION_H_