Update Chromoting to use /third_party/closure_compiler.

remoting/webapp/crd/js/client_session.js

 // Copyright (c) 2012 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
  * Class handling creation and teardown of a remoting client session.
  *
  * The ClientSession class controls lifetime of the client plugin
  * object and provides the plugin with the functionality it needs to
@@ skipping 151 matching lines @@
    * would not be useful, for example, when using a cached host JID.
    *
    * @type {boolean} @private
    */
   this.logHostOfflineErrors_ = true;
 
   /** @private */
   this.callPluginLostFocus_ = this.pluginLostFocus_.bind(this);
   /** @private */
   this.callPluginGotFocus_ = this.pluginGotFocus_.bind(this);
-  /** @private */
+  /**
+   * @type {function(boolean=):void}
+   * @private
+   */
   this.callOnFullScreenChanged_ = this.onFullScreenChanged_.bind(this)
 
   /** @type {Element} @private */
   this.mouseCursorOverlay_ =
       this.container_.querySelector('.mouse-cursor-overlay');
 
   /** @type {Element} */
   var img = this.mouseCursorOverlay_;
   /** @param {Event} event @private */
   this.updateMouseCursorPosition_ = function(event) {
@@ skipping 285 matching lines @@
 remoting.ClientSession.prototype.createPluginAndConnect =
     function(onExtensionMessage, requiredCapabilities) {
   this.plugin_ = remoting.ClientPlugin.factory.createPlugin(
       this.container_.querySelector('.client-plugin-container'),
       onExtensionMessage, requiredCapabilities);
   remoting.HostSettings.load(this.hostId_,
                              this.onHostSettingsLoaded_.bind(this));
 };
 
 /**
- * @param {Object.<string>} options The current options for the host, or {}
- *     if this client has no saved settings for the host.
+ * @param {Object.<string|boolean|number>} options The current options for the
+ *     host, or {} if this client has no saved settings for the host.
  * @private
  */
 remoting.ClientSession.prototype.onHostSettingsLoaded_ = function(options) {
   if (remoting.ClientSession.KEY_REMAP_KEYS in options &&
       typeof(options[remoting.ClientSession.KEY_REMAP_KEYS]) ==
           'string') {
     this.remapKeys_ = /** @type {string} */
-        options[remoting.ClientSession.KEY_REMAP_KEYS];
+        (options[remoting.ClientSession.KEY_REMAP_KEYS]);
   }
   if (remoting.ClientSession.KEY_RESIZE_TO_CLIENT in options &&
       typeof(options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT]) ==
           'boolean') {
     this.resizeToClient_ = /** @type {boolean} */
-        options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT];
+        (options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT]);
   }
   if (remoting.ClientSession.KEY_SHRINK_TO_FIT in options &&
       typeof(options[remoting.ClientSession.KEY_SHRINK_TO_FIT]) ==
           'boolean') {
     this.shrinkToFit_ = /** @type {boolean} */
-        options[remoting.ClientSession.KEY_SHRINK_TO_FIT];
+        (options[remoting.ClientSession.KEY_SHRINK_TO_FIT]);
   }
   if (remoting.ClientSession.KEY_DESKTOP_SCALE in options &&
       typeof(options[remoting.ClientSession.KEY_DESKTOP_SCALE]) ==
           'number') {
     this.desktopScale_ = /** @type {number} */
-        options[remoting.ClientSession.KEY_DESKTOP_SCALE];
+        (options[remoting.ClientSession.KEY_DESKTOP_SCALE]);
   }
 
   /** @param {boolean} result */
   this.plugin_.initialize(this.onPluginInitialized_.bind(this));
 };
 
 /**
  * Constrains the focus to the plugin element.
  * @private
  */
@@ skipping 191 matching lines @@
  * @return {remoting.Error} The current error code.
  */
 remoting.ClientSession.prototype.getError = function() {
   return this.error_;
 };
 
 /**
  * Sends a key combination to the remoting client, by sending down events for
  * the given keys, followed by up events in reverse order.
  *
+ * @param {Array.<number>} keys Key codes to be sent.
+ * @return {void} Nothing.
  * @private
- * @param {[number]} keys Key codes to be sent.
- * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.sendKeyCombination_ = function(keys) {
   for (var i = 0; i < keys.length; i++) {
     this.plugin_.injectKeyEvent(keys[i], true);
   }
   for (var i = 0; i < keys.length; i++) {
     this.plugin_.injectKeyEvent(keys[i], false);
   }
 }
 
@@ skipping 144 matching lines @@
 /**
  * @return {boolean} Whether the client has received a video buffer.
  */
 remoting.ClientSession.prototype.hasReceivedFrame = function() {
   return this.hasReceivedFrame_;
 };
 
 /**
  * Sends a signaling message.
  *
- * @private
  * @param {string} message XML string of IQ stanza to send to server.
  * @return {void} Nothing.
+ * @private
  */
 remoting.ClientSession.prototype.sendIq_ = function(message) {
   // Extract the session id, so we can close the session later.
   var parser = new DOMParser();
   var iqNode = parser.parseFromString(message, 'text/xml').firstChild;
   var jingleNode = iqNode.firstChild;
   if (jingleNode) {
     var action = jingleNode.getAttribute('action');
     if (jingleNode.nodeName == 'jingle' && action == 'session-initiate') {
       this.sessionId_ = jingleNode.getAttribute('sid');
     }
   }
 
   console.log(remoting.timestamp(), remoting.formatIq.prettifySendIq(message));
   if (this.signalStrategy_.getState() !=
       remoting.SignalStrategy.State.CONNECTED) {
     console.log("Message above is dropped because signaling is not connected.");
     return;
   }
 
   this.signalStrategy_.sendMessage(message);
 };
 
 /**
+ * @param {string} msg
  * @private
- * @param {string} msg
  */
 remoting.ClientSession.prototype.onDebugMessage_ = function(msg) {
   console.log('plugin: ' + msg.trimRight());
 };
 
 /**
+ * @param {Element} message
  * @private
- * @param {Element} message
  */
 remoting.ClientSession.prototype.onIncomingMessage_ = function(message) {
   if (!this.plugin_) {
     return;
   }
   var formatted = new XMLSerializer().serializeToString(message);
   console.log(remoting.timestamp(),
               remoting.formatIq.prettifyReceiveIq(formatted));
   this.plugin_.onIncomingIq(formatted);
 }
@@ skipping 53 matching lines @@
     // Clients that don't support asking for a PIN asynchronously also don't
     // support pairing, so request the PIN now without offering to remember it.
     this.fetchPin_(false, callback);
   }
 };
 
 /**
  * Callback that the plugin invokes to indicate that the connection
  * status has changed.
  *
- * @private
  * @param {number} status The plugin's status.
  * @param {number} error The plugin's error state, if any.
+ * @private
  */
 remoting.ClientSession.prototype.onConnectionStatusUpdate_ =
     function(status, error) {
   if (status == remoting.ClientSession.State.CONNECTED) {
     this.setFocusHandlers_();
     this.onDesktopSizeChanged_();
     if (this.resizeToClient_) {
       this.notifyClientResolution_();
     }
     // Activate full-screen related UX.
@@ skipping 24 matching lines @@
         this.error_ = remoting.Error.UNEXPECTED;
     }
   }
   this.setState_(/** @type {remoting.ClientSession.State} */ (status));
 };
 
 /**
  * Callback that the plugin invokes to indicate that the connection type for
  * a channel has changed.
  *
- * @private
  * @param {string} channel The channel name.
  * @param {string} connectionType The new connection type.
+ * @private
  */
 remoting.ClientSession.prototype.onRouteChanged_ =
     function(channel, connectionType) {
   console.log('plugin: Channel ' + channel + ' using ' +
               connectionType + ' connection.');
   this.logToServer.setConnectionType(connectionType);
 };
 
 /**
  * Callback that the plugin invokes to indicate when the connection is
  * ready.
  *
+ * @param {boolean} ready True if the connection is ready.
  * @private
- * @param {boolean} ready True if the connection is ready.
  */
 remoting.ClientSession.prototype.onConnectionReady_ = function(ready) {
   // TODO(jamiewalch): Currently, the logic for determining whether or not the
   // connection is available is based solely on whether or not any video frames
   // have been received recently. which leads to poor UX on slow connections.
   // Re-enable this once crbug.com/435315 has been fixed.
   var ignoreVideoChannelState = true;
   if (ignoreVideoChannelState) {
     console.log('Video channel ' + (ready ? '' : 'not ') + 'ready.');
     return;
@@ skipping 31 matching lines @@
   if (this.hasCapability_(remoting.ClientSession.Capability.GOOGLE_DRIVE)) {
     this.sendGoogleDriveAccessToken_();
   }
   if (this.hasCapability_(
       remoting.ClientSession.Capability.VIDEO_RECORDER)) {
     this.videoFrameRecorder_ = new remoting.VideoFrameRecorder(this.plugin_);
   }
 };
 
 /**
- * @private
  * @param {remoting.ClientSession.State} newState The new state for the session.
  * @return {void} Nothing.
+ * @private
  */
 remoting.ClientSession.prototype.setState_ = function(newState) {
   var oldState = this.state_;
   this.state_ = newState;
   var state = this.state_;
   if (oldState == remoting.ClientSession.State.CONNECTING) {
     if (this.state_ == remoting.ClientSession.State.CLOSED) {
       state = remoting.ClientSession.State.CONNECTION_CANCELED;
     } else if (this.state_ == remoting.ClientSession.State.FAILED &&
         this.error_ == remoting.Error.HOST_IS_OFFLINE &&
@@ skipping 73 matching lines @@
 remoting.ClientSession.prototype.pauseAudio = function(pause) {
   if (this.plugin_) {
     this.plugin_.pauseAudio(pause)
   }
 }
 
 /**
  * This is a callback that gets called when the plugin notifies us of a change
  * in the size of the remote desktop.
  *
+ * @return {void} Nothing.
  * @private
- * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.onDesktopSizeChanged_ = function() {
   console.log('desktop size changed: ' +
               this.plugin_.getDesktopWidth() + 'x' +
               this.plugin_.getDesktopHeight() +' @ ' +
               this.plugin_.getDesktopXDpi() + 'x' +
               this.plugin_.getDesktopYDpi() + ' DPI');
   this.updateDimensions();
   this.updateScrollbarVisibility();
 };
 
 /**
  * Sets the non-click-through area of the client in response to notifications
  * from the plugin of desktop shape changes.
  *
- * @private
  * @param {Array.<Array.<number>>} rects List of rectangles comprising the
  *     desktop shape.
  * @return {void} Nothing.
+ * @private
  */
 remoting.ClientSession.prototype.onDesktopShapeChanged_ = function(rects) {
   // Build the list of rects for the input region.
   var inputRegion = [];
   for (var i = 0; i < rects.length; ++i) {
     var rect = {};
     rect.left = rects[i][0];
     rect.top = rects[i][1];
     rect.width = rects[i][2];
     rect.height = rects[i][3];
@@ skipping 133 matching lines @@
 remoting.ClientSession.prototype.requestPairing = function(clientName, onDone) {
   if (this.plugin_) {
     this.plugin_.requestPairing(clientName, onDone);
   }
 };
 
 /**
  * Called when the full-screen status has changed, either via the
  * remoting.Fullscreen class, or via a system event such as the Escape key
  *
- * @param {boolean} fullscreen True if the app is entering full-screen mode;
+ * @param {boolean=} fullscreen True if the app is entering full-screen mode;
  *     false if it is leaving it.
  * @private
  */
 remoting.ClientSession.prototype.onFullScreenChanged_ = function (fullscreen) {
   this.enableBumpScroll_(fullscreen);
 };
 
 /**
  * Scroll the client plugin by the specified amount, keeping it visible.
  * Note that this is only used in content full-screen mode (not windowed or
@@ skipping 43 matching lines @@
 };
 
 remoting.ClientSession.prototype.resetScroll_ = function() {
   this.container_.style.marginTop = '0px';
   this.container_.style.marginLeft = '0px';
 };
 
 /**
  * Enable or disable bump-scrolling. When disabling bump scrolling, also reset
  * the scroll offsets to (0, 0).
+ * @param {boolean=} enable True to enable bump-scrolling, false to disable it.
  * @private
- * @param {boolean} enable True to enable bump-scrolling, false to disable it.
  */
 remoting.ClientSession.prototype.enableBumpScroll_ = function(enable) {
-  var element = /*@type{HTMLElement} */ document.documentElement;
+  var element = /** @type{HTMLElement} */ (document.documentElement);
   if (enable) {
     /** @type {null|function(Event):void} */
     this.onMouseMoveRef_ = this.onMouseMove_.bind(this);
     element.addEventListener('mousemove', this.onMouseMoveRef_, false);
   } else {
     element.removeEventListener('mousemove', this.onMouseMoveRef_, false);
     this.onMouseMoveRef_ = null;
     this.resetScroll_();
   }
 };
@@ skipping 91 matching lines @@
 
 /**
  * Process a remote gnubby auth request.
  * @param {string} data Remote gnubby request data.
  * @private
  */
 remoting.ClientSession.prototype.processGnubbyAuthMessage_ = function(data) {
   if (this.gnubbyAuthHandler_) {
     try {
       this.gnubbyAuthHandler_.onMessage(data);
-    } catch (err) {
-      console.error('Failed to process gnubby message: ',
-          /** @type {*} */ (err));
+    } catch (/** @type {*} */ err) {
+      console.error('Failed to process gnubby message: ', err);
     }
   } else {
     console.error('Received unexpected gnubby message');
   }
 };
 
 /**
  * Create a gnubby auth handler and inform the host that gnubby auth is
  * supported.
  * @private
@@ skipping 93 matching lines @@
 
 /**
  * Process a remote Cast extension message from the host.
  * @param {string} data Remote cast extension data message.
  * @private
  */
 remoting.ClientSession.prototype.processCastExtensionMessage_ = function(data) {
   if (this.castExtensionHandler_) {
     try {
       this.castExtensionHandler_.onMessage(data);
-    } catch (err) {
-      console.error('Failed to process cast message: ',
-          /** @type {*} */ (err));
+    } catch (/** @type {*} */ err) {
+      console.error('Failed to process cast message: ', err);
     }
   } else {
     console.error('Received unexpected cast message');
   }
 };
 
 /**
  * Create a CastExtensionHandler and inform the host that cast extension
  * is supported.
  * @private
@@ skipping 38 matching lines @@
  * @param {Object} message The parsed extension message data.
  * @return {boolean} True if the message was recognized, false otherwise.
  */
 remoting.ClientSession.prototype.handleExtensionMessage =
     function(type, message) {
   if (this.videoFrameRecorder_) {
     return this.videoFrameRecorder_.handleMessage(type, message);
   }
   return false;
 }