[Chromoting] Enable jscompile for browser tests.

remoting/webapp/browser_test/bump_scroll_browser_test.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.
 
 /**
  * @fileoverview
  * @suppress {checkTypes}
  * Browser test for the scenario below:
  * 1. Enter full-screen mode
  * 2. Move the mouse to each edge; verify that the desktop bump-scrolls.
  */
 
 'use strict';
 
-/** @constructor */
+/**
+ * @constructor
+ * @extends {base.EventSourceImpl}
+ */
 browserTest.FakeDesktopConnectedView = function() {
   this.pluginPosition = {
     top: 0,
     left: 0
   };
   this.defineEvents(Object.keys(remoting.DesktopConnectedView.Events));
 };
 
 base.extend(browserTest.FakeDesktopConnectedView, base.EventSourceImpl);
 
+/**
+ * @return {{top: number, left:number}} The top-left corner of the plugin.
+ */
 browserTest.FakeDesktopConnectedView.prototype.getPluginPositionForTesting =
     function() {
   return this.pluginPosition;
 };
 
 
 /** @constructor */
 browserTest.Bump_Scroll = function() {
-  // To aviod dependencies on the actual host desktop size, we simulate a
+  // To avoid dependencies on the actual host desktop size, we simulate a
   // desktop larger or smaller than the client window. The exact value is
   // arbitrary, but must be positive.
+  /** @type {number} */
   this.kHostDesktopSizeDelta = 10;
 };
 
+/**
+ * @param {{pin: string}} data

[kelvinp, 2015/02/18 18:41:29]

Nit: No space before string

[garykac, 2015/02/19 01:48:45]

Done.

+ */
 browserTest.Bump_Scroll.prototype.run = function(data) {
   browserTest.expect(typeof data.pin == 'string');
 
   if (!base.isAppsV2()) {
     browserTest.fail(
         'Bump-scroll requires full-screen, which can only be activated ' +
         'programmatically in apps v2.')
   }
 
   this.testVerifyScroll().then(function() {
@@ skipping 21 matching lines @@
       browserTest.disconnect();
       return browserTest.pass(value);
     },
     function(error) {
       browserTest.disconnect();
       return browserTest.fail(error);
     }
   );
 };
 
+/**
+ * @return {Promise}
+ */
 browserTest.Bump_Scroll.prototype.noScrollWindowed = function() {
-  remoting.desktopConnectedView.pluginWidthForBumpScrollTesting =
-      window.innerWidth + this.kHostDesktopSizeDelta;
-  remoting.desktopConnectedView.pluginHeightForBumpScrollTesting =
-      window.innerHeight + this.kHostDesktopSizeDelta;
+  remoting.desktopConnectedView.setPluginSizeForBumpScrollTesting(
+      window.innerWidth + this.kHostDesktopSizeDelta,
+      window.innerHeight + this.kHostDesktopSizeDelta);
   this.moveMouseTo(0, 0);
   return this.verifyScroll(undefined, undefined);
 };
 
+/**
+ * @return {Promise}
+ */
 browserTest.Bump_Scroll.prototype.noScrollSmaller = function() {
-  remoting.desktopConnectedView.pluginWidthForBumpScrollTesting =
-      window.innerWidth - this.kHostDesktopSizeDelta;
-  remoting.desktopConnectedView.pluginHeightForBumpScrollTesting =
-      window.innerHeight - this.kHostDesktopSizeDelta;
+  remoting.desktopConnectedView.setPluginSizeForBumpScrollTesting(
+      window.innerWidth - this.kHostDesktopSizeDelta,
+      window.innerHeight - this.kHostDesktopSizeDelta);
   this.moveMouseTo(0, 0);
   return this.verifyScroll(undefined, undefined);
 };
 
+/**
+ * @param {number} widthFraction
+ * @param {number} heightFraction
+ * @return {Promise}
+ */
 browserTest.Bump_Scroll.prototype.scrollDirection =
     function(widthFraction, heightFraction) {
-  remoting.desktopConnectedView.pluginWidthForBumpScrollTesting =
-      screen.width + this.kHostDesktopSizeDelta;
-  remoting.desktopConnectedView.pluginHeightForBumpScrollTesting =
-      screen.height + this.kHostDesktopSizeDelta;
+  remoting.desktopConnectedView.setPluginSizeForBumpScrollTesting(
+      screen.width + this.kHostDesktopSizeDelta,
+      screen.height + this.kHostDesktopSizeDelta);
+  /** @type {number} */
   var expectedTop = heightFraction == 0.0 ? 0 :
                     heightFraction == 1.0 ? -this.kHostDesktopSizeDelta :
                     undefined;
+  /** @type {number} */
   var expectedLeft = widthFraction == 0.0 ? 0 :
                      widthFraction == 1.0 ? -this.kHostDesktopSizeDelta :
                      undefined;
   var result = this.verifyScroll(expectedTop, expectedLeft);
   this.moveMouseTo(widthFraction * screen.width,
                    heightFraction * screen.height);
   return result;
 };
 
+/**
+ * @return {Promise}
+ */
 browserTest.Bump_Scroll.prototype.activateFullscreen = function() {
   return new Promise(function(fulfill, reject) {
     remoting.fullscreen.activate(true, function() {
       // The onFullscreen callback is invoked before the window has
       // resized, so defer fulfilling the promise so that innerWidth
       // and innerHeight are correct.
       base.Promise.sleep(1000).then(fulfill);
     });
     base.Promise.sleep(5000).then(function(){
       reject('Timed out waiting for full-screen');
     });
   });
 };
 
+/**
+ * @param {number} x
+ * @param {number} y
+ */
 browserTest.Bump_Scroll.prototype.moveMouseTo = function(x, y) {
   var e = {
     bubbles: true,
     cancelable: false,
     view: window,
     detail: 0,
     screenX: x,
     screenY: y,
     clientX: x,
     clientY: y,
     ctrlKey: false,
     altKey: false,
     shiftKey: false,
     metaKey: false,
     button: 0,
     relatedTarget: undefined
   };
   var event = document.createEvent('MouseEvents');
   event.initMouseEvent('mousemove',
                        e.bubbles, e.cancelable, e.view, e.detail,
                        e.screenX, e.screenY, e.clientX, e.clientY,
                        e.ctrlKey, e.altKey, e.shiftKey, e.metaKey,
                        e.button, document.documentElement);
   document.documentElement.dispatchEvent(event);
 };
 
-// verifyScroll is complicated enough to warrant a test
+/**
+ * verifyScroll() is complicated enough to warrant a test.
+ * @return {Promise}
+ */
 browserTest.Bump_Scroll.prototype.testVerifyScroll = function() {
   var STARTED = remoting.DesktopConnectedView.Events.bumpScrollStarted;
   var STOPPED = remoting.DesktopConnectedView.Events.bumpScrollStopped;
   var fakeSession = new browserTest.FakeDesktopConnectedView;
   var that = this;
 
   // No events raised (e.g. windowed mode).
   var result = this.verifyScroll(undefined, undefined, fakeSession)
 
   .then(function() {
@@ skipping 42 matching lines @@
 
 /**
  * Verify that a bump scroll operation takes place and that the top-left corner
  * of the plugin is as expected when it completes.
  * @param {number|undefined} expectedTop The expected vertical position of the
  *    plugin, or undefined if it is not expected to change.
  * @param {number|undefined} expectedLeft The expected horizontal position of
  *    the plugin, or undefined if it is not expected to change.
  * @param {browserTest.FakeDesktopConnectedView=} opt_desktopConnectedView
  *     DesktopConnectedView fake, for testing.
+ * @return {Promise}
  */
 browserTest.Bump_Scroll.prototype.verifyScroll =
     function (expectedTop, expectedLeft, opt_desktopConnectedView) {
+  /** @type {browserTest.FakeDesktopConnectedView} */
   var desktopConnectedView = opt_desktopConnectedView ||
       remoting.desktopConnectedView;
   base.debug.assert(desktopConnectedView != null);
   var STARTED = remoting.DesktopConnectedView.Events.bumpScrollStarted;
   var STOPPED = remoting.DesktopConnectedView.Events.bumpScrollStopped;
 
   var initialPosition = desktopConnectedView.getPluginPositionForTesting();
   var initialTop = initialPosition.top;
   var initialLeft = initialPosition.left;
 
+  /** @return {Promise} */
   var verifyPluginPosition = function() {
     var position = desktopConnectedView.getPluginPositionForTesting();
     if (expectedLeft === undefined) {
       expectedLeft = initialLeft;
     }
     if (expectedTop === undefined) {
       expectedTop = initialTop;
     }
     if (position.top != expectedTop || position.left != expectedLeft) {
       return Promise.reject(
@@ skipping 15 matching lines @@
     // If no started event is raised, the test might still pass if it asserted
     // no scrolling.
     if (expectedTop == undefined && expectedLeft == undefined) {
       return Promise.resolve();
     } else {
       return Promise.reject(
           new Error('Scroll expected but no start event fired.'));
     }
   });
 };