[Chromoting] Enable jscompile for webapp unittests.

remoting/webapp/unittests/base_unittest.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function() {
 
 'use strict';
 
 module('base');
 
 test('mix(dest, src) should copy properties from |src| to |dest|',
   function() {
     var src = { a: 'a', b: 'b'};
     var dest = { c: 'c'};
 
     base.mix(dest, src);
     deepEqual(dest, {a: 'a', b: 'b', c: 'c'});
 });
 
 test('mix(dest, src) should assert if properties are overwritten',
   function() {
     var src = { a: 'a', b: 'b'};
     var dest = { a: 'a'};
 
-    sinon.spy(base.debug, 'assert');
+    sinon.$setupStub(base.debug, 'assert');
 
     try {
       base.mix(dest, src);
     } catch (e) {
     } finally {
       sinon.assert.called(base.debug.assert);
-      base.debug.assert.restore();
+      base.debug.assert.$testStub.restore();
     }
 });
 
 test('values(obj) should return an array containing the values of |obj|',
   function() {
     var output = base.values({ a: 'a', b: 'b'});
 
     notEqual(output.indexOf('a'), -1, '"a" should be in the output');
     notEqual(output.indexOf('b'), -1, '"b" should be in the output');
 });
@@ skipping 22 matching lines @@
 test('modify the original after deepCopy(obj) should not affect the copy',
   function() {
     var original = [1, 2, 3, 4];
     var copy = base.deepCopy(original);
     original[2] = 1000;
     QUnit.deepEqual(copy, [1, 2, 3, 4]);
 });
 
 test('dispose(obj) should invoke the dispose method on |obj|',
   function() {
-    var obj = {
-      dispose: sinon.spy()
-    };
+    /**
+     * @constructor
+     * @implements {base.Disposable}
+     */
+    base.MockDisposable = function() {};
+    base.MockDisposable.prototype.dispose = sinon.spy();
+
+    var obj = new base.MockDisposable();
     base.dispose(obj);
     sinon.assert.called(obj.dispose);
 });
 
 test('dispose(obj) should not crash if |obj| is null',
   function() {
     expect(0);
     base.dispose(null);
 });
 
@@ skipping 16 matching lines @@
         '&escapist=%3A%2F%3F%23%5B%5D%40%24%26%2B%2C%3B%3D');
 });
 
 test('escapeHTML(str) should escape special characters', function() {
   QUnit.equal(
     base.escapeHTML('<script>alert("hello")</script>'),
     '&lt;script&gt;alert("hello")&lt;/script&gt;');
 });
 
 QUnit.asyncTest('Promise.sleep(delay) should fulfill the promise after |delay|',
+  /**
+   * 'this' is not defined for jscompile, so it can't figure out the type of
+   * this.clock.
+   * @suppress {reportUnknownTypes|checkVars|checkTypes}
+   */
   function() {
     var isCalled = false;
-    var clock = this.clock;
+    var clock = /** @type {QUnit.Clock} */ (this.clock);
 
     base.Promise.sleep(100).then(function(){
       isCalled = true;
       ok(true, 'Promise.sleep() is fulfilled after delay.');
       QUnit.start();
     });
 
     // Tick the clock for 2 seconds and check if the promise is fulfilled.
     clock.tick(2);
 
     // Promise fulfillment always occur on a new stack.  Therefore, we will run
     // the verification in a requestAnimationFrame.
     window.requestAnimationFrame(function(){
       ok(!isCalled, 'Promise.sleep() should not be fulfilled prematurely.');
       clock.tick(101);
-    }.bind(this));
+    });
 });
 
 QUnit.asyncTest('Promise.negate should fulfill iff the promise does not.',
   function() {
 
     base.Promise.negate(Promise.reject()).then(
-        ok.bind(null, true),
-        ok.bind(null, false));
+        QUnit.ok.bind(null, true),
+        /** @type {Function} */ (QUnit.ok.bind(null, false)));
     base.Promise.negate(Promise.resolve()).then(
-        ok.bind(null, false),
-        ok.bind(null, true));
+        QUnit.ok.bind(null, false),
+        /** @type {Function} */ (QUnit.ok.bind(null, true)));
     window.requestAnimationFrame(function(){
       QUnit.start();
     });
 });
 
 module('base.Deferred');
 
 QUnit.asyncTest('resolve() should fulfill the underlying promise.', function() {
+  /** @returns {Promise} */
   function async() {
     var deferred = new base.Deferred();
     deferred.resolve('bar');
     return deferred.promise();
   }
 
-  async().then(function(value){
-    QUnit.equal(value, 'bar');
-    QUnit.start();
-  }, function() {
-    QUnit.ok(false, 'The reject handler should not be invoked.');
-  });
+  async().then(
+      /** @param {string} value */
+      function(value){
+          QUnit.equal(value, 'bar');
+          QUnit.start();
+      }, function() {
+          QUnit.ok(false, 'The reject handler should not be invoked.');
+      });
 });
 
 QUnit.asyncTest('reject() should fail the underlying promise.', function() {
+  /** @returns {Promise} */
   function async() {
     var deferred = new base.Deferred();
     deferred.reject('bar');
     return deferred.promise();
   }
 
   async().then(function(){
     QUnit.ok(false, 'The then handler should not be invoked.');
   }, function(value) {
     QUnit.equal(value, 'bar');
     QUnit.start();
   });
 });
 
 
+/** @type {base.EventSourceImpl} */
 var source = null;
 var listener = null;
 
 module('base.EventSource', {
   setup: function() {
     source = new base.EventSourceImpl();
     source.defineEvents(['foo', 'bar']);
     listener = sinon.spy();
     source.addEventListener('foo', listener);
   },
@@ skipping 30 matching lines @@
 });
 
 test('raiseEvent() should not invoke listeners of a different event',
   function() {
     source.raiseEvent('bar');
     sinon.assert.notCalled(listener);
 });
 
 test('raiseEvent() should assert when undeclared events are raised',
   function() {
-    sinon.spy(base.debug, 'assert');
+    sinon.$setupStub(base.debug, 'assert');
     try {
       source.raiseEvent('undefined');
     } catch (e) {
     } finally {
       sinon.assert.called(base.debug.assert);
-      base.debug.assert.restore();
+      base.debug.assert.$testStub.restore();
     }
 });
 
 test(
   'removeEventListener() should not invoke the listener in subsequent ' +
   'calls to |raiseEvent|',
   function() {
     source.raiseEvent('foo');
     sinon.assert.calledOnce(listener);
 
@@ skipping 12 matching lines @@
 
     source.addEventListener('foo', sink.listener);
     source.raiseEvent('foo');
     sinon.assert.calledOnce(sink.listener);
 
     source.raiseEvent('foo');
     sinon.assert.calledOnce(sink.listener);
 });
 
 test('encodeUtf8() can encode UTF8 strings', function() {
+  /** @type {function(ArrayBuffer):Array} */
   function toJsArray(arrayBuffer) {
     var result = [];
     var array = new Uint8Array(arrayBuffer);
     for (var i = 0; i < array.length; ++i) {
       result.push(array[i]);
     }
     return result;
   }
 
   // ASCII.
@@ skipping 21 matching lines @@
                           /* Ѓ */ 0xD0, 0x83,
                           /* ф */ 0xD1, 0x84]).buffer),
       "挂Ѓф");
 
   // Unicode surrogate pair for U+1F603.
   QUnit.equal(base.decodeUtf8(new Uint8Array([0xF0, 0x9F, 0x98, 0x83]).buffer),
               "😃");
 });
 
 })();