Merge remote-tracking branch 'origin/dev' into iislucas-separate-signal

Conflicts:
	Gruntfile.coffee
	package.json

Author: iislucas

Gruntfile.coffee

@@ -53,7 +53,9 @@ taskManager.add 'browserifySpecs', [
   'browserify:buildToolsTaskmanagerSpec'
   'browserify:loggingSpec'
   'browserify:loggingProviderSpec'
-  'browserify:webrtcSpec'
+  'browserify:peerconnectionSpec'
+  'browserify:datachannelSpec'
+  'browserify:queueSpec'
 ]
 
 # Create unit test code
@@ -64,7 +66,9 @@ taskManager.add 'browserifyCovSpecs', [
   'browserify:buildToolsTaskmanagerCovSpec'
   'browserify:loggingCovSpec'
   'browserify:loggingProviderCovSpec'
-  'browserify:webrtcCovSpec'
+  'browserify:peerconnectionCovSpec'
+  'browserify:datachannelCovSpec'
+  'browserify:queueCovSpec'
 ]
 
 # Run unit tests
@@ -76,6 +80,7 @@ taskManager.add 'unit_test', [
   'jasmine:logging'
   'jasmine:loggingProvider'
   'jasmine:webrtc'
+  'jasmine:queue'
 ]
 
 # Run unit tests to produce coverage; these are separate from unit_tests because
@@ -88,6 +93,7 @@ taskManager.add 'coverage', [
   'jasmine:loggingCov'
   'jasmine:loggingProviderCov'
   'jasmine:webrtcCov'
+  'jasmine:queueCov'
 ]
 
 # Run unit tests
@@ -211,6 +217,8 @@ module.exports = (grunt) ->
       loggingProviderCov: Rule.addCoverageToSpec(Rule.jasmineSpec 'loggingprovider')
       webrtc: Rule.jasmineSpec 'webrtc'
       webrtcCov: Rule.addCoverageToSpec(Rule.jasmineSpec 'webrtc')
+      queue: Rule.jasmineSpec 'queue'
+      queueCov: Rule.addCoverageToSpec(Rule.jasmineSpec 'queue')
 
     browserify:
       # Browserify freedom-modules in the library
@@ -226,8 +234,12 @@ module.exports = (grunt) ->
       loggingProviderCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'loggingprovider/loggingprovider')
       loggingSpec: Rule.browserifySpec 'logging/logging'
       loggingCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'logging/logging')
-      webrtcSpec: Rule.browserifySpec 'webrtc/peerconnection'
-      webrtcCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'webrtc/peerconnection')
+      peerconnectionSpec: Rule.browserifySpec 'webrtc/peerconnection'
+      peerconnectionCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'webrtc/peerconnection')
+      datachannelSpec: Rule.browserifySpec 'webrtc/datachannel'
+      datachannelCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'webrtc/datachannel')
+      queueSpec: Rule.browserifySpec 'queue/queue'
+      queueCovSpec: Rule.addCoverageToBrowserify(Rule.browserifySpec 'queue/queue')
       # Browserify sample apps main freedom module and core environments
       copypasteFreedomChatFreedomModule: Rule.browserify 'samples/copypaste-freedom-chat/freedom-module'
       copypasteFreedomChatMain: Rule.browserify 'samples/copypaste-freedom-chat/main.core-env'

package.json

@@ -1,7 +1,7 @@
 {
   "name": "uproxy-lib",
   "description": "Shared libraries for uProxy projects.",
-  "version": "21.0.0",
+  "version": "22.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/uProxy/uproxy-lib"

src/handler/queue.ts

@@ -23,6 +23,8 @@
 // CONSIDER: This is kind of similar to functional parsing. May be good to
 // formalize the relationship in comments here.
 
+import baseQueue = require('../queue/queue');
+
 // The |QueueFeeder| is the abstraction for events to be handled.
 export interface QueueFeeder<Feed,Result> {
   // Number of things in the queue to be handled.
@@ -160,7 +162,7 @@ class PendingPromiseHandler<T,T2> {
 export class Queue<Feed,Result>
     implements QueueFeeder<Feed,Result>, QueueHandler<Feed,Result> {
   // The queue of things to handle.
-  private queue_ :PendingPromiseHandler<Feed, Result>[] = [];
+  private queue_ = new baseQueue.Queue<PendingPromiseHandler<Feed, Result>>();
 
   // Handler function for things on the queue. When null, things queue up.
   // When non-null, gets called on the thing to handle. When set, called on

src/queue/queue.spec.ts

@@ -0,0 +1,46 @@
+/// <reference path='../../../third_party/typings/jasmine/jasmine.d.ts' />
+
+import queue = require('./queue');
+import Queue = queue.Queue;
+
+describe('Base Queue', function() {
+  var queue :Queue<string>;
+
+  beforeEach(() => {
+    queue = new Queue<string>();
+  });
+
+  it('New queue has length = 0', function() {
+    expect(queue.length).toBe(0);
+  });
+
+  it('3 items makes length = 3', function() {
+    queue.push('A');
+    queue.push('BB');
+    queue.push('CCC');
+    expect(queue.length).toBe(3);
+  });
+
+  it('3 items and then clearing makes length = 0', function() {
+    queue.push('A');
+    queue.push('BB');
+    queue.push('CCC');
+    while (queue.length > 0) {
+      queue.shift();
+    }
+    expect(queue.length).toBe(0);
+  });
+
+  it('3 items come out in order', function() {
+    queue.push('A');
+    queue.push('BBB');
+    queue.push('CCCCC');
+    expect(queue.length).toBe(3);
+    expect(queue.shift()).toEqual('A');
+    expect(queue.length).toBe(2);
+    expect(queue.shift()).toEqual('BBB');
+    expect(queue.length).toBe(1);
+    expect(queue.shift()).toEqual('CCCCC');
+    expect(queue.length).toBe(0);
+  });
+});  // describe('Base Queue', ... )

src/queue/queue.ts

@@ -0,0 +1,43 @@
+// This file defines a basic queue data structure, providing
+// the standard Array push(), shift(), and length attributes,
+// but with O(1) operation.
+
+// Private helper class.
+class Cell<T> {
+  public next :Cell<T> = null;
+  constructor(public item:T) {}
+}
+
+export class Queue<T> {
+  private back_ :Cell<T> = null;
+  private front_ :Cell<T> = null;
+  public length :number = 0;
+
+  constructor() {}
+
+  // Add an item to the back of the queue.
+  public push = (item:T) : void => {
+    var cell = new Cell<T>(item);
+    if (this.length > 0) {
+      this.back_.next = cell;
+    } else {
+      // The queue was empty, so set both pointers.
+      this.front_ = cell;
+    }
+    this.back_ = cell;
+    this.length++;
+  }
+
+  // Remove and return the front element.
+  public shift = () : T => {
+    var dequeued = this.front_;
+    // If this.front_ is this.back_, then getNext() returns null.
+    this.front_ = dequeued.next;
+    dequeued.next = null;  // Just to help the garbage collector.
+    this.length--;
+    if (this.length === 0) {
+      this.back_ = null;
+    }
+    return dequeued.item;
+  }
+}  // class Queue

src/webrtc/datachannel.spec.ts

@@ -0,0 +1,63 @@
+/// <reference path='../../../third_party/typings/es6-promise/es6-promise.d.ts' />
+/// <reference path='../../../third_party/typings/jasmine/jasmine.d.ts' />
+/// <reference path="../../../third_party/freedom-typings/rtcpeerconnection.d.ts" />
+
+import MockFreedomRtcDataChannel = require('../freedom/mocks/mock-rtcdatachannel');
+
+import freedomMocker = require('../freedom/mocks/mock-freedom-in-module-env');
+freedom = freedomMocker.makeMockFreedomInModuleEnv({
+  'rtcdatachannel': () => { return new MockFreedomRtcDataChannel(); }
+});
+
+import datachannel = require('./datachannel');
+
+describe('DataChannel', function() {
+  var mockRtcDataChannel :MockFreedomRtcDataChannel;
+
+  beforeEach(function() {
+    mockRtcDataChannel = new MockFreedomRtcDataChannel();
+  });
+
+  // Ensure that close() waits for all outgoing unsent messages to be sent:
+  //   https://github.com/uProxy/uproxy/issues/1218
+  it('close waits for all data to be sent', (done) => {
+    // The core.rtcdatachannel is initially open.
+    spyOn(mockRtcDataChannel, 'getReadyState').and.returnValue(
+        Promise.resolve('open'));
+
+    // Have core.rtcdatachannel emit an onclose event when its
+    // close() method is invoked.
+    var closeSpy = spyOn(mockRtcDataChannel, 'close').and.callFake(() => {
+      mockRtcDataChannel.handleEvent('onclose');
+    });
+
+    // Pretend the core.rtcdatachannel is buffering a lot of data.
+    // This will cause DataChannel to buffer sends.
+    var getBufferedAmountSpy = spyOn(mockRtcDataChannel, 'getBufferedAmount');
+    getBufferedAmountSpy.and.callFake(() => {
+      return Promise.resolve(datachannel.PC_QUEUE_LIMIT);
+    });
+
+    var sendBufferSpy = spyOn(mockRtcDataChannel, 'sendBuffer');
+
+    datachannel.createFromRtcDataChannel(mockRtcDataChannel).then(
+        (channel:datachannel.DataChannel) => {
+      channel.send({
+        buffer: new Uint8Array([0, 1, 2]).buffer
+      });
+
+      channel.close();
+
+      // At this point, our message should not yet have been sent.
+      // Now that we've requested the channel be closed, "unblock" the
+      // core.rtcdatachannel to drain the message queue.
+      expect(sendBufferSpy).not.toHaveBeenCalled();
+      getBufferedAmountSpy.and.returnValue(Promise.resolve(0));
+
+      channel.onceClosed.then(() => {
+        expect(sendBufferSpy).toHaveBeenCalled();
+        done();
+      });
+    });
+  });
+});