src/remoting/webapp/client_session.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview
   7  * Class handling creation and teardown of a remoting client session.
   8  *
   9  * The ClientSession class controls lifetime of the client plugin
  10  * object and provides the plugin with the functionality it needs to
  11  * establish connection. Specifically it:
  12  *  - Delivers incoming/outgoing signaling messages,
  13  *  - Adjusts plugin size and position when destop resolution changes,
  14  *
  15  * This class should not access the plugin directly, instead it should
  16  * do it through ClientPlugin class which abstracts plugin version
  17  * differences.
  18  */
  19
  20 'use strict';
  21
  22 /** @suppress {duplicate} */
  23 var remoting = remoting || {};
  24
  25 /**
  26  * True if Cast capability is supported.
  27  *
  28  * @type {boolean}
  29  */
  30 remoting.enableCast = false;
  31
  32 /**
  33  * @param {remoting.SignalStrategy} signalStrategy Signal strategy.
  34  * @param {HTMLElement} container Container element for the client view.
  35  * @param {string} hostDisplayName A human-readable name for the host.
  36  * @param {string} accessCode The IT2Me access code. Blank for Me2Me.
  37  * @param {function(boolean, function(string): void): void} fetchPin
  38  *     Called by Me2Me connections when a PIN needs to be obtained
  39  *     interactively.
  40  * @param {function(string, string, string,
  41  *                  function(string, string): void): void}
  42  *     fetchThirdPartyToken Called by Me2Me connections when a third party
  43  *     authentication token must be obtained.
  44  * @param {string} authenticationMethods Comma-separated list of
  45  *     authentication methods the client should attempt to use.
  46  * @param {string} hostId The host identifier for Me2Me, or empty for IT2Me.
  47  *     Mixed into authentication hashes for some authentication methods.
  48  * @param {string} hostJid The jid of the host to connect to.
  49  * @param {string} hostPublicKey The base64 encoded version of the host's
  50  *     public key.
  51  * @param {remoting.ClientSession.Mode} mode The mode of this connection.
  52  * @param {string} clientPairingId For paired Me2Me connections, the
  53  *     pairing id for this client, as issued by the host.
  54  * @param {string} clientPairedSecret For paired Me2Me connections, the
  55  *     paired secret for this client, as issued by the host.
  56  * @constructor
  57  * @extends {base.EventSource}
  58  */
  59 remoting.ClientSession = function(signalStrategy, container, hostDisplayName,
  60                                   accessCode, fetchPin, fetchThirdPartyToken,
  61                                   authenticationMethods, hostId, hostJid,
  62                                   hostPublicKey, mode, clientPairingId,
  63                                   clientPairedSecret) {
  64   /** @private */
  65   this.state_ = remoting.ClientSession.State.CREATED;
  66
  67   /** @private */
  68   this.error_ = remoting.Error.NONE;
  69
  70   /** @type {HTMLElement}
  71     * @private */
  72   this.container_ = container;
  73
  74   /** @private */
  75   this.hostDisplayName_ = hostDisplayName;
  76   /** @private */
  77   this.hostJid_ = hostJid;
  78   /** @private */
  79   this.hostPublicKey_ = hostPublicKey;
  80   /** @private */
  81   this.accessCode_ = accessCode;
  82   /** @private */
  83   this.fetchPin_ = fetchPin;
  84   /** @private */
  85   this.fetchThirdPartyToken_ = fetchThirdPartyToken;
  86   /** @private */
  87   this.authenticationMethods_ = authenticationMethods;
  88   /** @private */
  89   this.hostId_ = hostId;
  90   /** @private */
  91   this.mode_ = mode;
  92   /** @private */
  93   this.clientPairingId_ = clientPairingId;
  94   /** @private */
  95   this.clientPairedSecret_ = clientPairedSecret;
  96   /** @private */
  97   this.sessionId_ = '';
  98   /** @type {remoting.ClientPlugin}
  99     * @private */
 100   this.plugin_ = null;
 101   /** @private */
 102   this.shrinkToFit_ = true;
 103   /** @private */
 104   this.resizeToClient_ = true;
 105   /** @private */
 106   this.remapKeys_ = '';
 107   /** @private */
 108   this.hasReceivedFrame_ = false;
 109   this.logToServer = new remoting.LogToServer();
 110
 111   /** @private */
 112   this.signalStrategy_ = signalStrategy;
 113   base.debug.assert(this.signalStrategy_.getState() ==
 114                     remoting.SignalStrategy.State.CONNECTED);
 115   this.signalStrategy_.setIncomingStanzaCallback(
 116       this.onIncomingMessage_.bind(this));
 117   remoting.formatIq.setJids(this.signalStrategy_.getJid(), hostJid);
 118
 119   /** @type {number?} @private */
 120   this.notifyClientResolutionTimer_ = null;
 121   /** @type {number?} @private */
 122   this.bumpScrollTimer_ = null;
 123
 124   // Bump-scroll test variables. Override to use a fake value for the width
 125   // and height of the client plugin so that bump-scrolling can be tested
 126   // without relying on the actual size of the host desktop.
 127   /** @type {number} @private */
 128   this.pluginWidthForBumpScrollTesting = 0;
 129   /** @type {number} @private */
 130   this.pluginHeightForBumpScrollTesting = 0;
 131
 132   /**
 133    * Allow host-offline error reporting to be suppressed in situations where it
 134    * would not be useful, for example, when using a cached host JID.
 135    *
 136    * @type {boolean} @private
 137    */
 138   this.logHostOfflineErrors_ = true;
 139
 140   /** @private */
 141   this.callPluginLostFocus_ = this.pluginLostFocus_.bind(this);
 142   /** @private */
 143   this.callPluginGotFocus_ = this.pluginGotFocus_.bind(this);
 144   /** @private */
 145   this.callOnFullScreenChanged_ = this.onFullScreenChanged_.bind(this)
 146
 147   /** @type {HTMLMediaElement} @private */
 148   this.video_ = null;
 149
 150   /** @type {Element} @private */
 151   this.mouseCursorOverlay_ =
 152       this.container_.querySelector('.mouse-cursor-overlay');
 153
 154   /** @type {Element} */
 155   var img = this.mouseCursorOverlay_;
 156   /** @param {Event} event @private */
 157   this.updateMouseCursorPosition_ = function(event) {
 158     img.style.top = event.y + 'px';
 159     img.style.left = event.x + 'px';
 160   };
 161
 162   /** @type {remoting.GnubbyAuthHandler} @private */
 163   this.gnubbyAuthHandler_ = null;
 164
 165   /** @type {remoting.CastExtensionHandler} @private */
 166   this.castExtensionHandler_ = null;
 167
 168   /** @type {remoting.VideoFrameRecorder} @private */
 169   this.videoFrameRecorder_ = null;
 170
 171   this.defineEvents(Object.keys(remoting.ClientSession.Events));
 172 };
 173
 174 base.extend(remoting.ClientSession, base.EventSource);
 175
 176 /** @enum {string} */
 177 remoting.ClientSession.Events = {
 178   stateChanged: 'stateChanged',
 179   videoChannelStateChanged: 'videoChannelStateChanged',
 180   bumpScrollStarted: 'bumpScrollStarted',
 181   bumpScrollStopped: 'bumpScrollStopped'
 182 };
 183
 184 /**
 185  * Get host display name.
 186  *
 187  * @return {string}
 188  */
 189 remoting.ClientSession.prototype.getHostDisplayName = function() {
 190   return this.hostDisplayName_;
 191 };
 192
 193 /**
 194  * Called when the window or desktop size or the scaling settings change,
 195  * to set the scroll-bar visibility.
 196  *
 197  * TODO(jamiewalch): crbug.com/252796: Remove this once crbug.com/240772 is
 198  * fixed.
 199  */
 200 remoting.ClientSession.prototype.updateScrollbarVisibility = function() {
 201   var needsVerticalScroll = false;
 202   var needsHorizontalScroll = false;
 203   if (!this.shrinkToFit_) {
 204     // Determine whether or not horizontal or vertical scrollbars are
 205     // required, taking into account their width.
 206     var clientArea = this.getClientArea_();
 207     needsVerticalScroll = clientArea.height < this.plugin_.getDesktopHeight();
 208     needsHorizontalScroll = clientArea.width < this.plugin_.getDesktopWidth();
 209     var kScrollBarWidth = 16;
 210     if (needsHorizontalScroll && !needsVerticalScroll) {
 211       needsVerticalScroll =
 212           clientArea.height - kScrollBarWidth < this.plugin_.getDesktopHeight();
 213     } else if (!needsHorizontalScroll && needsVerticalScroll) {
 214       needsHorizontalScroll =
 215           clientArea.width - kScrollBarWidth < this.plugin_.getDesktopWidth();
 216     }
 217   }
 218
 219   var scroller = document.getElementById('scroller');
 220   if (needsHorizontalScroll) {
 221     scroller.classList.remove('no-horizontal-scroll');
 222   } else {
 223     scroller.classList.add('no-horizontal-scroll');
 224   }
 225   if (needsVerticalScroll) {
 226     scroller.classList.remove('no-vertical-scroll');
 227   } else {
 228     scroller.classList.add('no-vertical-scroll');
 229   }
 230 };
 231
 232 /**
 233  * @return {boolean} True if shrink-to-fit is enabled; false otherwise.
 234  */
 235 remoting.ClientSession.prototype.getShrinkToFit = function() {
 236   return this.shrinkToFit_;
 237 };
 238
 239 /**
 240  * @return {boolean} True if resize-to-client is enabled; false otherwise.
 241  */
 242 remoting.ClientSession.prototype.getResizeToClient = function() {
 243   return this.resizeToClient_;
 244 };
 245
 246 // Note that the positive values in both of these enums are copied directly
 247 // from chromoting_scriptable_object.h and must be kept in sync. The negative
 248 // values represent state transitions that occur within the web-app that have
 249 // no corresponding plugin state transition.
 250 /** @enum {number} */
 251 remoting.ClientSession.State = {
 252   CONNECTION_CANCELED: -3,  // Connection closed (gracefully) before connecting.
 253   CONNECTION_DROPPED: -2,  // Succeeded, but subsequently closed with an error.
 254   CREATED: -1,
 255   UNKNOWN: 0,
 256   CONNECTING: 1,
 257   INITIALIZING: 2,
 258   CONNECTED: 3,
 259   CLOSED: 4,
 260   FAILED: 5
 261 };
 262
 263 /**
 264  * @param {string} state The state name.
 265  * @return {remoting.ClientSession.State} The session state enum value.
 266  */
 267 remoting.ClientSession.State.fromString = function(state) {
 268   if (!remoting.ClientSession.State.hasOwnProperty(state)) {
 269     throw "Invalid ClientSession.State: " + state;
 270   }
 271   return remoting.ClientSession.State[state];
 272 };
 273
 274 /**
 275   @constructor
 276   @param {remoting.ClientSession.State} current
 277   @param {remoting.ClientSession.State} previous
 278 */
 279 remoting.ClientSession.StateEvent = function(current, previous) {
 280   /** @type {remoting.ClientSession.State} */
 281   this.previous = previous
 282
 283   /** @type {remoting.ClientSession.State} */
 284   this.current = current;
 285 };
 286
 287 /** @enum {number} */
 288 remoting.ClientSession.ConnectionError = {
 289   UNKNOWN: -1,
 290   NONE: 0,
 291   HOST_IS_OFFLINE: 1,
 292   SESSION_REJECTED: 2,
 293   INCOMPATIBLE_PROTOCOL: 3,
 294   NETWORK_FAILURE: 4,
 295   HOST_OVERLOAD: 5
 296 };
 297
 298 /**
 299  * @param {string} error The connection error name.
 300  * @return {remoting.ClientSession.ConnectionError} The connection error enum.
 301  */
 302 remoting.ClientSession.ConnectionError.fromString = function(error) {
 303   if (!remoting.ClientSession.ConnectionError.hasOwnProperty(error)) {
 304     console.error('Unexpected ClientSession.ConnectionError string: ', error);
 305     return remoting.ClientSession.ConnectionError.UNKNOWN;
 306   }
 307   return remoting.ClientSession.ConnectionError[error];
 308 }
 309
 310 // The mode of this session.
 311 /** @enum {number} */
 312 remoting.ClientSession.Mode = {
 313   IT2ME: 0,
 314   ME2ME: 1
 315 };
 316
 317 /**
 318  * Type used for performance statistics collected by the plugin.
 319  * @constructor
 320  */
 321 remoting.ClientSession.PerfStats = function() {};
 322 /** @type {number} */
 323 remoting.ClientSession.PerfStats.prototype.videoBandwidth;
 324 /** @type {number} */
 325 remoting.ClientSession.PerfStats.prototype.videoFrameRate;
 326 /** @type {number} */
 327 remoting.ClientSession.PerfStats.prototype.captureLatency;
 328 /** @type {number} */
 329 remoting.ClientSession.PerfStats.prototype.encodeLatency;
 330 /** @type {number} */
 331 remoting.ClientSession.PerfStats.prototype.decodeLatency;
 332 /** @type {number} */
 333 remoting.ClientSession.PerfStats.prototype.renderLatency;
 334 /** @type {number} */
 335 remoting.ClientSession.PerfStats.prototype.roundtripLatency;
 336
 337 // Keys for connection statistics.
 338 remoting.ClientSession.STATS_KEY_VIDEO_BANDWIDTH = 'videoBandwidth';
 339 remoting.ClientSession.STATS_KEY_VIDEO_FRAME_RATE = 'videoFrameRate';
 340 remoting.ClientSession.STATS_KEY_CAPTURE_LATENCY = 'captureLatency';
 341 remoting.ClientSession.STATS_KEY_ENCODE_LATENCY = 'encodeLatency';
 342 remoting.ClientSession.STATS_KEY_DECODE_LATENCY = 'decodeLatency';
 343 remoting.ClientSession.STATS_KEY_RENDER_LATENCY = 'renderLatency';
 344 remoting.ClientSession.STATS_KEY_ROUNDTRIP_LATENCY = 'roundtripLatency';
 345
 346 // Keys for per-host settings.
 347 remoting.ClientSession.KEY_REMAP_KEYS = 'remapKeys';
 348 remoting.ClientSession.KEY_RESIZE_TO_CLIENT = 'resizeToClient';
 349 remoting.ClientSession.KEY_SHRINK_TO_FIT = 'shrinkToFit';
 350
 351 /**
 352  * Set of capabilities for which hasCapability_() can be used to test.
 353  *
 354  * @enum {string}
 355  */
 356 remoting.ClientSession.Capability = {
 357   // When enabled this capability causes the client to send its screen
 358   // resolution to the host once connection has been established. See
 359   // this.plugin_.notifyClientResolution().
 360   SEND_INITIAL_RESOLUTION: 'sendInitialResolution',
 361   RATE_LIMIT_RESIZE_REQUESTS: 'rateLimitResizeRequests',
 362   VIDEO_RECORDER: 'videoRecorder',
 363   CAST: 'casting'
 364 };
 365
 366 /**
 367  * The set of capabilities negotiated between the client and host.
 368  * @type {Array.<string>}
 369  * @private
 370  */
 371 remoting.ClientSession.prototype.capabilities_ = null;
 372
 373 /**
 374  * @param {remoting.ClientSession.Capability} capability The capability to test
 375  *     for.
 376  * @return {boolean} True if the capability has been negotiated between
 377  *     the client and host.
 378  * @private
 379  */
 380 remoting.ClientSession.prototype.hasCapability_ = function(capability) {
 381   if (this.capabilities_ == null)
 382     return false;
 383
 384   return this.capabilities_.indexOf(capability) > -1;
 385 };
 386
 387 /**
 388  * Callback function called when the plugin element gets focus.
 389  */
 390 remoting.ClientSession.prototype.pluginGotFocus_ = function() {
 391   remoting.clipboard.initiateToHost();
 392 };
 393
 394 /**
 395  * Callback function called when the plugin element loses focus.
 396  */
 397 remoting.ClientSession.prototype.pluginLostFocus_ = function() {
 398   if (this.plugin_) {
 399     // Release all keys to prevent them becoming 'stuck down' on the host.
 400     this.plugin_.releaseAllKeys();
 401     if (this.plugin_.element()) {
 402       // Focus should stay on the element, not (for example) the toolbar.
 403       // Due to crbug.com/246335, we can't restore the focus immediately,
 404       // otherwise the plugin gets confused about whether or not it has focus.
 405       window.setTimeout(
 406           this.plugin_.element().focus.bind(this.plugin_.element()), 0);
 407     }
 408   }
 409 };
 410
 411 /**
 412  * Adds <embed> element to |container| and readies the sesion object.
 413  *
 414  * @param {function(string, string):boolean} onExtensionMessage The handler for
 415  *     protocol extension messages. Returns true if a message is recognized;
 416  *     false otherwise.
 417  */
 418 remoting.ClientSession.prototype.createPluginAndConnect =
 419     function(onExtensionMessage) {
 420   this.plugin_ = remoting.ClientPlugin.factory.createPlugin(
 421       this.container_.querySelector('.client-plugin-container'),
 422       onExtensionMessage);
 423   remoting.HostSettings.load(this.hostId_,
 424                              this.onHostSettingsLoaded_.bind(this));
 425 };
 426
 427 /**
 428  * @param {Object.<string>} options The current options for the host, or {}
 429  *     if this client has no saved settings for the host.
 430  * @private
 431  */
 432 remoting.ClientSession.prototype.onHostSettingsLoaded_ = function(options) {
 433   if (remoting.ClientSession.KEY_REMAP_KEYS in options &&
 434       typeof(options[remoting.ClientSession.KEY_REMAP_KEYS]) ==
 435           'string') {
 436     this.remapKeys_ = /** @type {string} */
 437         options[remoting.ClientSession.KEY_REMAP_KEYS];
 438   }
 439   if (remoting.ClientSession.KEY_RESIZE_TO_CLIENT in options &&
 440       typeof(options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT]) ==
 441           'boolean') {
 442     this.resizeToClient_ = /** @type {boolean} */
 443         options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT];
 444   }
 445   if (remoting.ClientSession.KEY_SHRINK_TO_FIT in options &&
 446       typeof(options[remoting.ClientSession.KEY_SHRINK_TO_FIT]) ==
 447           'boolean') {
 448     this.shrinkToFit_ = /** @type {boolean} */
 449         options[remoting.ClientSession.KEY_SHRINK_TO_FIT];
 450   }
 451
 452   /** @param {boolean} result */
 453   this.plugin_.initialize(this.onPluginInitialized_.bind(this));
 454 };
 455
 456 /**
 457  * Constrains the focus to the plugin element.
 458  * @private
 459  */
 460 remoting.ClientSession.prototype.setFocusHandlers_ = function() {
 461   this.plugin_.element().addEventListener(
 462       'focus', this.callPluginGotFocus_, false);
 463   this.plugin_.element().addEventListener(
 464       'blur', this.callPluginLostFocus_, false);
 465   this.plugin_.element().focus();
 466 };
 467
 468 /**
 469  * @param {remoting.Error} error
 470  */
 471 remoting.ClientSession.prototype.resetWithError_ = function(error) {
 472   this.signalStrategy_.setIncomingStanzaCallback(null);
 473   this.plugin_.dispose();
 474   this.plugin_ = null;
 475   this.error_ = error;
 476   this.setState_(remoting.ClientSession.State.FAILED);
 477 }
 478
 479 /**
 480  * @param {boolean} initialized
 481  */
 482 remoting.ClientSession.prototype.onPluginInitialized_ = function(initialized) {
 483   if (!initialized) {
 484     console.error('ERROR: remoting plugin not loaded');
 485     this.resetWithError_(remoting.Error.MISSING_PLUGIN);
 486     return;
 487   }
 488
 489   if (!this.plugin_.isSupportedVersion()) {
 490     this.resetWithError_(remoting.Error.BAD_PLUGIN_VERSION);
 491     return;
 492   }
 493
 494   // Show the Send Keys menu only if the plugin has the injectKeyEvent feature,
 495   // and the Ctrl-Alt-Del button only in Me2Me mode.
 496   if (!this.plugin_.hasFeature(
 497           remoting.ClientPlugin.Feature.INJECT_KEY_EVENT)) {
 498     var sendKeysElement = document.getElementById('send-keys-menu');
 499     sendKeysElement.hidden = true;
 500   } else if (this.mode_ != remoting.ClientSession.Mode.ME2ME) {
 501     var sendCadElement = document.getElementById('send-ctrl-alt-del');
 502     sendCadElement.hidden = true;
 503   }
 504
 505   // Apply customized key remappings if the plugin supports remapKeys.
 506   if (this.plugin_.hasFeature(remoting.ClientPlugin.Feature.REMAP_KEY)) {
 507     this.applyRemapKeys_(true);
 508   }
 509
 510   // Enable MediaSource-based rendering on Chrome 37 and above.
 511   var chromeVersionMajor =
 512       parseInt((remoting.getChromeVersion() || '0').split('.')[0], 10);
 513   if (chromeVersionMajor >= 37 &&
 514       this.plugin_.hasFeature(
 515           remoting.ClientPlugin.Feature.MEDIA_SOURCE_RENDERING)) {
 516     this.video_ = /** @type {HTMLMediaElement} */(
 517         this.container_.querySelector('video'));
 518     // Make sure that the <video> element is hidden until we get the first
 519     // frame.
 520     this.video_.style.width = '0px';
 521     this.video_.style.height = '0px';
 522
 523     var renderer = new remoting.MediaSourceRenderer(this.video_);
 524     this.plugin_.enableMediaSourceRendering(renderer);
 525     this.container_.classList.add('mediasource-rendering');
 526   } else {
 527     this.container_.classList.remove('mediasource-rendering');
 528   }
 529
 530   this.plugin_.setOnOutgoingIqHandler(this.sendIq_.bind(this));
 531   this.plugin_.setOnDebugMessageHandler(
 532       /** @param {string} msg */
 533       function(msg) {
 534         console.log('plugin: ' + msg.trimRight());
 535       });
 536
 537   this.plugin_.setConnectionStatusUpdateHandler(
 538       this.onConnectionStatusUpdate_.bind(this));
 539   this.plugin_.setConnectionReadyHandler(this.onConnectionReady_.bind(this));
 540   this.plugin_.setDesktopSizeUpdateHandler(
 541       this.onDesktopSizeChanged_.bind(this));
 542   this.plugin_.setCapabilitiesHandler(this.onSetCapabilities_.bind(this));
 543   this.plugin_.setGnubbyAuthHandler(
 544       this.processGnubbyAuthMessage_.bind(this));
 545   this.plugin_.setMouseCursorHandler(this.updateMouseCursorImage_.bind(this));
 546   this.plugin_.setCastExtensionHandler(
 547       this.processCastExtensionMessage_.bind(this));
 548   this.initiateConnection_();
 549 };
 550
 551 /**
 552  * Deletes the <embed> element from the container, without sending a
 553  * session_terminate request.  This is to be called when the session was
 554  * disconnected by the Host.
 555  *
 556  * @return {void} Nothing.
 557  */
 558 remoting.ClientSession.prototype.removePlugin = function() {
 559   if (this.plugin_) {
 560     this.plugin_.element().removeEventListener(
 561         'focus', this.callPluginGotFocus_, false);
 562     this.plugin_.element().removeEventListener(
 563         'blur', this.callPluginLostFocus_, false);
 564     this.plugin_.dispose();
 565     this.plugin_ = null;
 566   }
 567
 568   // Leave full-screen mode, and stop listening for related events.
 569   var listener = this.callOnFullScreenChanged_;
 570   remoting.fullscreen.activate(
 571       false,
 572       function() {
 573         remoting.fullscreen.removeListener(listener);
 574       });
 575   if (remoting.windowFrame) {
 576     remoting.windowFrame.setClientSession(null);
 577   } else {
 578     remoting.toolbar.setClientSession(null);
 579   }
 580   remoting.optionsMenu.setClientSession(null);
 581   document.body.classList.remove('connected');
 582
 583   // Remove mediasource-rendering class from the container - this will also
 584   // hide the <video> element.
 585   this.container_.classList.remove('mediasource-rendering');
 586
 587   this.container_.removeEventListener('mousemove',
 588                                       this.updateMouseCursorPosition_,
 589                                       true);
 590 };
 591
 592 /**
 593  * Disconnect the current session with a particular |error|.  The session will
 594  * raise a |stateChanged| event in response to it.  The caller should then call
 595  * |cleanup| to remove and destroy the <embed> element.
 596  *
 597  * @param {remoting.Error} error The reason for the disconnection.  Use
 598  *    remoting.Error.NONE if there is no error.
 599  * @return {void} Nothing.
 600  */
 601 remoting.ClientSession.prototype.disconnect = function(error) {
 602   var state = (error == remoting.Error.NONE) ?
 603                   remoting.ClientSession.State.CLOSED :
 604                   remoting.ClientSession.State.FAILED;
 605
 606   // The plugin won't send a state change notification, so we explicitly log
 607   // the fact that the connection has closed.
 608   this.logToServer.logClientSessionStateChange(state, error, this.mode_);
 609   this.error_ = error;
 610   this.setState_(state);
 611 };
 612
 613 /**
 614  * Deletes the <embed> element from the container and disconnects.
 615  *
 616  * @return {void} Nothing.
 617  */
 618 remoting.ClientSession.prototype.cleanup = function() {
 619   this.sendIq_(
 620       '<cli:iq ' +
 621           'to="' + this.hostJid_ + '" ' +
 622           'type="set" ' +
 623           'id="session-terminate" ' +
 624           'xmlns:cli="jabber:client">' +
 625         '<jingle ' +
 626             'xmlns="urn:xmpp:jingle:1" ' +
 627             'action="session-terminate" ' +
 628             'sid="' + this.sessionId_ + '">' +
 629           '<reason><success/></reason>' +
 630         '</jingle>' +
 631       '</cli:iq>');
 632   this.removePlugin();
 633 };
 634
 635 /**
 636  * @return {remoting.ClientSession.Mode} The current state.
 637  */
 638 remoting.ClientSession.prototype.getMode = function() {
 639   return this.mode_;
 640 };
 641
 642 /**
 643  * @return {remoting.ClientSession.State} The current state.
 644  */
 645 remoting.ClientSession.prototype.getState = function() {
 646   return this.state_;
 647 };
 648
 649 /**
 650  * @return {remoting.Error} The current error code.
 651  */
 652 remoting.ClientSession.prototype.getError = function() {
 653   return this.error_;
 654 };
 655
 656 /**
 657  * Sends a key combination to the remoting client, by sending down events for
 658  * the given keys, followed by up events in reverse order.
 659  *
 660  * @private
 661  * @param {[number]} keys Key codes to be sent.
 662  * @return {void} Nothing.
 663  */
 664 remoting.ClientSession.prototype.sendKeyCombination_ = function(keys) {
 665   for (var i = 0; i < keys.length; i++) {
 666     this.plugin_.injectKeyEvent(keys[i], true);
 667   }
 668   for (var i = 0; i < keys.length; i++) {
 669     this.plugin_.injectKeyEvent(keys[i], false);
 670   }
 671 }
 672
 673 /**
 674  * Sends a Ctrl-Alt-Del sequence to the remoting client.
 675  *
 676  * @return {void} Nothing.
 677  */
 678 remoting.ClientSession.prototype.sendCtrlAltDel = function() {
 679   console.log('Sending Ctrl-Alt-Del.');
 680   this.sendKeyCombination_([0x0700e0, 0x0700e2, 0x07004c]);
 681 }
 682
 683 /**
 684  * Sends a Print Screen keypress to the remoting client.
 685  *
 686  * @return {void} Nothing.
 687  */
 688 remoting.ClientSession.prototype.sendPrintScreen = function() {
 689   console.log('Sending Print Screen.');
 690   this.sendKeyCombination_([0x070046]);
 691 }
 692
 693 /**
 694  * Sets and stores the key remapping setting for the current host.
 695  *
 696  * @param {string} remappings Comma separated list of key remappings.
 697  */
 698 remoting.ClientSession.prototype.setRemapKeys = function(remappings) {
 699   // Cancel any existing remappings and apply the new ones.
 700   this.applyRemapKeys_(false);
 701   this.remapKeys_ = remappings;
 702   this.applyRemapKeys_(true);
 703
 704   // Save the new remapping setting.
 705   var options = {};
 706   options[remoting.ClientSession.KEY_REMAP_KEYS] = this.remapKeys_;
 707   remoting.HostSettings.save(this.hostId_, options);
 708 }
 709
 710 /**
 711  * Applies the configured key remappings to the session, or resets them.
 712  *
 713  * @param {boolean} apply True to apply remappings, false to cancel them.
 714  */
 715 remoting.ClientSession.prototype.applyRemapKeys_ = function(apply) {
 716   // By default, under ChromeOS, remap the right Control key to the right
 717   // Win / Cmd key.
 718   var remapKeys = this.remapKeys_;
 719   if (remapKeys == '' && remoting.runningOnChromeOS()) {
 720     remapKeys = '0x0700e4>0x0700e7';
 721   }
 722
 723   if (remapKeys == '') {
 724     return;
 725   }
 726
 727   var remappings = remapKeys.split(',');
 728   for (var i = 0; i < remappings.length; ++i) {
 729     var keyCodes = remappings[i].split('>');
 730     if (keyCodes.length != 2) {
 731       console.log('bad remapKey: ' + remappings[i]);
 732       continue;
 733     }
 734     var fromKey = parseInt(keyCodes[0], 0);
 735     var toKey = parseInt(keyCodes[1], 0);
 736     if (!fromKey || !toKey) {
 737       console.log('bad remapKey code: ' + remappings[i]);
 738       continue;
 739     }
 740     if (apply) {
 741       console.log('remapKey 0x' + fromKey.toString(16) +
 742                   '>0x' + toKey.toString(16));
 743       this.plugin_.remapKey(fromKey, toKey);
 744     } else {
 745       console.log('cancel remapKey 0x' + fromKey.toString(16));
 746       this.plugin_.remapKey(fromKey, fromKey);
 747     }
 748   }
 749 }
 750
 751 /**
 752  * Set the shrink-to-fit and resize-to-client flags and save them if this is
 753  * a Me2Me connection.
 754  *
 755  * @param {boolean} shrinkToFit True if the remote desktop should be scaled
 756  *     down if it is larger than the client window; false if scroll-bars
 757  *     should be added in this case.
 758  * @param {boolean} resizeToClient True if window resizes should cause the
 759  *     host to attempt to resize its desktop to match the client window size;
 760  *     false to disable this behaviour for subsequent window resizes--the
 761  *     current host desktop size is not restored in this case.
 762  * @return {void} Nothing.
 763  */
 764 remoting.ClientSession.prototype.setScreenMode =
 765     function(shrinkToFit, resizeToClient) {
 766   if (resizeToClient && !this.resizeToClient_) {
 767     var clientArea = this.getClientArea_();
 768     this.plugin_.notifyClientResolution(clientArea.width,
 769                                         clientArea.height,
 770                                         window.devicePixelRatio);
 771   }
 772
 773   // If enabling shrink, reset bump-scroll offsets.
 774   var needsScrollReset = shrinkToFit && !this.shrinkToFit_;
 775
 776   this.shrinkToFit_ = shrinkToFit;
 777   this.resizeToClient_ = resizeToClient;
 778   this.updateScrollbarVisibility();
 779
 780   if (this.hostId_ != '') {
 781     var options = {};
 782     options[remoting.ClientSession.KEY_SHRINK_TO_FIT] = this.shrinkToFit_;
 783     options[remoting.ClientSession.KEY_RESIZE_TO_CLIENT] = this.resizeToClient_;
 784     remoting.HostSettings.save(this.hostId_, options);
 785   }
 786
 787   this.updateDimensions();
 788   if (needsScrollReset) {
 789     this.resetScroll_();
 790   }
 791
 792 }
 793
 794 /**
 795  * Called when the client receives its first frame.
 796  *
 797  * @return {void} Nothing.
 798  */
 799 remoting.ClientSession.prototype.onFirstFrameReceived = function() {
 800   this.hasReceivedFrame_ = true;
 801 };
 802
 803 /**
 804  * @return {boolean} Whether the client has received a video buffer.
 805  */
 806 remoting.ClientSession.prototype.hasReceivedFrame = function() {
 807   return this.hasReceivedFrame_;
 808 };
 809
 810 /**
 811  * Sends a signaling message.
 812  *
 813  * @private
 814  * @param {string} message XML string of IQ stanza to send to server.
 815  * @return {void} Nothing.
 816  */
 817 remoting.ClientSession.prototype.sendIq_ = function(message) {
 818   // Extract the session id, so we can close the session later.
 819   var parser = new DOMParser();
 820   var iqNode = parser.parseFromString(message, 'text/xml').firstChild;
 821   var jingleNode = iqNode.firstChild;
 822   if (jingleNode) {
 823     var action = jingleNode.getAttribute('action');
 824     if (jingleNode.nodeName == 'jingle' && action == 'session-initiate') {
 825       this.sessionId_ = jingleNode.getAttribute('sid');
 826     }
 827   }
 828
 829   console.log(remoting.timestamp(), remoting.formatIq.prettifySendIq(message));
 830   if (this.signalStrategy_.getState() !=
 831       remoting.SignalStrategy.State.CONNECTED) {
 832     console.log("Message above is dropped because signaling is not connected.");
 833     return;
 834   }
 835
 836   this.signalStrategy_.sendMessage(message);
 837 };
 838
 839 /**
 840  * @private
 841  * @param {Element} message
 842  */
 843 remoting.ClientSession.prototype.onIncomingMessage_ = function(message) {
 844   if (!this.plugin_) {
 845     return;
 846   }
 847   var formatted = new XMLSerializer().serializeToString(message);
 848   console.log(remoting.timestamp(),
 849               remoting.formatIq.prettifyReceiveIq(formatted));
 850   this.plugin_.onIncomingIq(formatted);
 851 }
 852
 853 /**
 854  * @private
 855  */
 856 remoting.ClientSession.prototype.initiateConnection_ = function() {
 857   /** @type {remoting.ClientSession} */
 858   var that = this;
 859
 860   /** @param {string} sharedSecret Shared secret. */
 861   function onSharedSecretReceived(sharedSecret) {
 862     that.plugin_.connect(
 863         that.hostJid_, that.hostPublicKey_, that.signalStrategy_.getJid(),
 864         sharedSecret, that.authenticationMethods_, that.hostId_,
 865         that.clientPairingId_, that.clientPairedSecret_);
 866   };
 867
 868   this.getSharedSecret_(onSharedSecretReceived);
 869 }
 870
 871 /**
 872  * Gets shared secret to be used for connection.
 873  *
 874  * @param {function(string)} callback Callback called with the shared secret.
 875  * @return {void} Nothing.
 876  * @private
 877  */
 878 remoting.ClientSession.prototype.getSharedSecret_ = function(callback) {
 879   /** @type remoting.ClientSession */
 880   var that = this;
 881   if (this.plugin_.hasFeature(remoting.ClientPlugin.Feature.THIRD_PARTY_AUTH)) {
 882     /** @type{function(string, string, string): void} */
 883     var fetchThirdPartyToken = function(tokenUrl, hostPublicKey, scope) {
 884       that.fetchThirdPartyToken_(
 885           tokenUrl, hostPublicKey, scope,
 886           that.plugin_.onThirdPartyTokenFetched.bind(that.plugin_));
 887     };
 888     this.plugin_.setFetchThirdPartyTokenHandler(fetchThirdPartyToken);
 889   }
 890   if (this.accessCode_) {
 891     // Shared secret was already supplied before connecting (It2Me case).
 892     callback(this.accessCode_);
 893   } else if (this.plugin_.hasFeature(
 894       remoting.ClientPlugin.Feature.ASYNC_PIN)) {
 895     // Plugin supports asynchronously asking for the PIN.
 896     this.plugin_.useAsyncPinDialog();
 897     /** @param {boolean} pairingSupported */
 898     var fetchPin = function(pairingSupported) {
 899       that.fetchPin_(pairingSupported,
 900                      that.plugin_.onPinFetched.bind(that.plugin_));
 901     };
 902     this.plugin_.setFetchPinHandler(fetchPin);
 903     callback('');
 904   } else {
 905     // Clients that don't support asking for a PIN asynchronously also don't
 906     // support pairing, so request the PIN now without offering to remember it.
 907     this.fetchPin_(false, callback);
 908   }
 909 };
 910
 911 /**
 912  * Callback that the plugin invokes to indicate that the connection
 913  * status has changed.
 914  *
 915  * @private
 916  * @param {number} status The plugin's status.
 917  * @param {number} error The plugin's error state, if any.
 918  */
 919 remoting.ClientSession.prototype.onConnectionStatusUpdate_ =
 920     function(status, error) {
 921   if (status == remoting.ClientSession.State.CONNECTED) {
 922     this.setFocusHandlers_();
 923     this.onDesktopSizeChanged_();
 924     if (this.resizeToClient_) {
 925       var clientArea = this.getClientArea_();
 926       this.plugin_.notifyClientResolution(clientArea.width,
 927                                           clientArea.height,
 928                                           window.devicePixelRatio);
 929     }
 930     // Activate full-screen related UX.
 931     remoting.fullscreen.addListener(this.callOnFullScreenChanged_);
 932     if (remoting.windowFrame) {
 933       remoting.windowFrame.setClientSession(this);
 934     } else {
 935       remoting.toolbar.setClientSession(this);
 936     }
 937     remoting.optionsMenu.setClientSession(this);
 938     document.body.classList.add('connected');
 939
 940     this.container_.addEventListener('mousemove',
 941                                      this.updateMouseCursorPosition_,
 942                                      true);
 943
 944   } else if (status == remoting.ClientSession.State.FAILED) {
 945     switch (error) {
 946       case remoting.ClientSession.ConnectionError.HOST_IS_OFFLINE:
 947         this.error_ = remoting.Error.HOST_IS_OFFLINE;
 948         break;
 949       case remoting.ClientSession.ConnectionError.SESSION_REJECTED:
 950         this.error_ = remoting.Error.INVALID_ACCESS_CODE;
 951         break;
 952       case remoting.ClientSession.ConnectionError.INCOMPATIBLE_PROTOCOL:
 953         this.error_ = remoting.Error.INCOMPATIBLE_PROTOCOL;
 954         break;
 955       case remoting.ClientSession.ConnectionError.NETWORK_FAILURE:
 956         this.error_ = remoting.Error.P2P_FAILURE;
 957         break;
 958       case remoting.ClientSession.ConnectionError.HOST_OVERLOAD:
 959         this.error_ = remoting.Error.HOST_OVERLOAD;
 960         break;
 961       default:
 962         this.error_ = remoting.Error.UNEXPECTED;
 963     }
 964   }
 965   this.setState_(/** @type {remoting.ClientSession.State} */ (status));
 966 };
 967
 968 /**
 969  * Callback that the plugin invokes to indicate when the connection is
 970  * ready.
 971  *
 972  * @private
 973  * @param {boolean} ready True if the connection is ready.
 974  */
 975 remoting.ClientSession.prototype.onConnectionReady_ = function(ready) {
 976   if (!ready) {
 977     this.container_.classList.add('session-client-inactive');
 978   } else {
 979     this.container_.classList.remove('session-client-inactive');
 980   }
 981
 982   this.raiseEvent(remoting.ClientSession.Events.videoChannelStateChanged,
 983                   ready);
 984 };
 985
 986 /**
 987  * Called when the client-host capabilities negotiation is complete.
 988  *
 989  * @param {!Array.<string>} capabilities The set of capabilities negotiated
 990  *     between the client and host.
 991  * @return {void} Nothing.
 992  * @private
 993  */
 994 remoting.ClientSession.prototype.onSetCapabilities_ = function(capabilities) {
 995   if (this.capabilities_ != null) {
 996     console.error('onSetCapabilities_() is called more than once');
 997     return;
 998   }
 999
1000   this.capabilities_ = capabilities;
1001   if (this.hasCapability_(
1002       remoting.ClientSession.Capability.SEND_INITIAL_RESOLUTION)) {
1003     var clientArea = this.getClientArea_();
1004     this.plugin_.notifyClientResolution(clientArea.width,
1005                                         clientArea.height,
1006                                         window.devicePixelRatio);
1007   }
1008   if (this.hasCapability_(
1009       remoting.ClientSession.Capability.VIDEO_RECORDER)) {
1010     this.videoFrameRecorder_ = new remoting.VideoFrameRecorder(this.plugin_);
1011   }
1012 };
1013
1014 /**
1015  * @private
1016  * @param {remoting.ClientSession.State} newState The new state for the session.
1017  * @return {void} Nothing.
1018  */
1019 remoting.ClientSession.prototype.setState_ = function(newState) {
1020   var oldState = this.state_;
1021   this.state_ = newState;
1022   var state = this.state_;
1023   if (oldState == remoting.ClientSession.State.CONNECTING) {
1024     if (this.state_ == remoting.ClientSession.State.CLOSED) {
1025       state = remoting.ClientSession.State.CONNECTION_CANCELED;
1026     } else if (this.state_ == remoting.ClientSession.State.FAILED &&
1027         this.error_ == remoting.Error.HOST_IS_OFFLINE &&
1028         !this.logHostOfflineErrors_) {
1029       // The application requested host-offline errors to be suppressed, for
1030       // example, because this connection attempt is using a cached host JID.
1031       console.log('Suppressing host-offline error.');
1032       state = remoting.ClientSession.State.CONNECTION_CANCELED;
1033     }
1034   } else if (oldState == remoting.ClientSession.State.CONNECTED &&
1035              this.state_ == remoting.ClientSession.State.FAILED) {
1036     state = remoting.ClientSession.State.CONNECTION_DROPPED;
1037   }
1038   this.logToServer.logClientSessionStateChange(state, this.error_, this.mode_);
1039   if (this.state_ == remoting.ClientSession.State.CONNECTED) {
1040     this.createGnubbyAuthHandler_();
1041     this.createCastExtensionHandler_();
1042   }
1043
1044   this.raiseEvent(remoting.ClientSession.Events.stateChanged,
1045     new remoting.ClientSession.StateEvent(newState, oldState)
1046   );
1047 };
1048
1049 /**
1050  * This is a callback that gets called when the window is resized.
1051  *
1052  * @return {void} Nothing.
1053  */
1054 remoting.ClientSession.prototype.onResize = function() {
1055   this.updateDimensions();
1056
1057   if (this.notifyClientResolutionTimer_) {
1058     window.clearTimeout(this.notifyClientResolutionTimer_);
1059     this.notifyClientResolutionTimer_ = null;
1060   }
1061
1062   // Defer notifying the host of the change until the window stops resizing, to
1063   // avoid overloading the control channel with notifications.
1064   if (this.resizeToClient_) {
1065     var kResizeRateLimitMs = 1000;
1066     if (this.hasCapability_(
1067         remoting.ClientSession.Capability.RATE_LIMIT_RESIZE_REQUESTS)) {
1068       kResizeRateLimitMs = 250;
1069     }
1070     var clientArea = this.getClientArea_();
1071     this.notifyClientResolutionTimer_ = window.setTimeout(
1072         this.plugin_.notifyClientResolution.bind(this.plugin_,
1073                                                  clientArea.width,
1074                                                  clientArea.height,
1075                                                  window.devicePixelRatio),
1076         kResizeRateLimitMs);
1077   }
1078
1079   // If bump-scrolling is enabled, adjust the plugin margins to fully utilize
1080   // the new window area.
1081   this.resetScroll_();
1082
1083   this.updateScrollbarVisibility();
1084 };
1085
1086 /**
1087  * Requests that the host pause or resume video updates.
1088  *
1089  * @param {boolean} pause True to pause video, false to resume.
1090  * @return {void} Nothing.
1091  */
1092 remoting.ClientSession.prototype.pauseVideo = function(pause) {
1093   if (this.plugin_) {
1094     this.plugin_.pauseVideo(pause);
1095   }
1096 };
1097
1098 /**
1099  * Requests that the host pause or resume audio.
1100  *
1101  * @param {boolean} pause True to pause audio, false to resume.
1102  * @return {void} Nothing.
1103  */
1104 remoting.ClientSession.prototype.pauseAudio = function(pause) {
1105   if (this.plugin_) {
1106     this.plugin_.pauseAudio(pause)
1107   }
1108 }
1109
1110 /**
1111  * This is a callback that gets called when the plugin notifies us of a change
1112  * in the size of the remote desktop.
1113  *
1114  * @private
1115  * @return {void} Nothing.
1116  */
1117 remoting.ClientSession.prototype.onDesktopSizeChanged_ = function() {
1118   console.log('desktop size changed: ' +
1119               this.plugin_.getDesktopWidth() + 'x' +
1120               this.plugin_.getDesktopHeight() +' @ ' +
1121               this.plugin_.getDesktopXDpi() + 'x' +
1122               this.plugin_.getDesktopYDpi() + ' DPI');
1123   this.updateDimensions();
1124   this.updateScrollbarVisibility();
1125 };
1126
1127 /**
1128  * Refreshes the plugin's dimensions, taking into account the sizes of the
1129  * remote desktop and client window, and the current scale-to-fit setting.
1130  *
1131  * @return {void} Nothing.
1132  */
1133 remoting.ClientSession.prototype.updateDimensions = function() {
1134   if (this.plugin_.getDesktopWidth() == 0 ||
1135       this.plugin_.getDesktopHeight() == 0) {
1136     return;
1137   }
1138
1139   var clientArea = this.getClientArea_();
1140   var desktopWidth = this.plugin_.getDesktopWidth();
1141   var desktopHeight = this.plugin_.getDesktopHeight();
1142
1143   // When configured to display a host at its original size, we aim to display
1144   // it as close to its physical size as possible, without losing data:
1145   // - If client and host have matching DPI, render the host pixel-for-pixel.
1146   // - If the host has higher DPI then still render pixel-for-pixel.
1147   // - If the host has lower DPI then let Chrome up-scale it to natural size.
1148
1149   // We specify the plugin dimensions in Density-Independent Pixels, so to
1150   // render pixel-for-pixel we need to down-scale the host dimensions by the
1151   // devicePixelRatio of the client. To match the host pixel density, we choose
1152   // an initial scale factor based on the client devicePixelRatio and host DPI.
1153
1154   // Determine the effective device pixel ratio of the host, based on DPI.
1155   var hostPixelRatioX = Math.ceil(this.plugin_.getDesktopXDpi() / 96);
1156   var hostPixelRatioY = Math.ceil(this.plugin_.getDesktopYDpi() / 96);
1157   var hostPixelRatio = Math.min(hostPixelRatioX, hostPixelRatioY);
1158
1159   // Down-scale by the smaller of the client and host ratios.
1160   var scale = 1.0 / Math.min(window.devicePixelRatio, hostPixelRatio);
1161
1162   if (this.shrinkToFit_) {
1163     // Reduce the scale, if necessary, to fit the whole desktop in the window.
1164     var scaleFitWidth = Math.min(scale, 1.0 * clientArea.width / desktopWidth);
1165     var scaleFitHeight =
1166         Math.min(scale, 1.0 * clientArea.height / desktopHeight);
1167     scale = Math.min(scaleFitHeight, scaleFitWidth);
1168
1169     // If we're running full-screen then try to handle common side-by-side
1170     // multi-monitor combinations more intelligently.
1171     if (remoting.fullscreen.isActive()) {
1172       // If the host has two monitors each the same size as the client then
1173       // scale-to-fit will have the desktop occupy only 50% of the client area,
1174       // in which case it would be preferable to down-scale less and let the
1175       // user bump-scroll around ("scale-and-pan").
1176       // Triggering scale-and-pan if less than 65% of the client area would be
1177       // used adds enough fuzz to cope with e.g. 1280x800 client connecting to
1178       // a (2x1280)x1024 host nicely.
1179       // Note that we don't need to account for scrollbars while fullscreen.
1180       if (scale <= scaleFitHeight * 0.65) {
1181         scale = scaleFitHeight;
1182       }
1183       if (scale <= scaleFitWidth * 0.65) {
1184         scale = scaleFitWidth;
1185       }
1186     }
1187   }
1188
1189   var pluginWidth = Math.round(desktopWidth * scale);
1190   var pluginHeight = Math.round(desktopHeight * scale);
1191
1192   if (this.video_) {
1193     this.video_.style.width = pluginWidth + 'px';
1194     this.video_.style.height = pluginHeight + 'px';
1195   }
1196
1197   // Resize the plugin if necessary.
1198   // TODO(wez): Handle high-DPI to high-DPI properly (crbug.com/135089).
1199   this.plugin_.element().style.width = pluginWidth + 'px';
1200   this.plugin_.element().style.height = pluginHeight + 'px';
1201
1202   // Position the container.
1203   // Note that clientWidth/Height take into account scrollbars.
1204   var clientWidth = document.documentElement.clientWidth;
1205   var clientHeight = document.documentElement.clientHeight;
1206   var parentNode = this.plugin_.element().parentNode;
1207
1208   console.log('plugin dimensions: ' +
1209               parentNode.style.left + ',' +
1210               parentNode.style.top + '-' +
1211               pluginWidth + 'x' + pluginHeight + '.');
1212 };
1213
1214 /**
1215  * Returns an associative array with a set of stats for this connection.
1216  *
1217  * @return {remoting.ClientSession.PerfStats} The connection statistics.
1218  */
1219 remoting.ClientSession.prototype.getPerfStats = function() {
1220   return this.plugin_.getPerfStats();
1221 };
1222
1223 /**
1224  * Logs statistics.
1225  *
1226  * @param {remoting.ClientSession.PerfStats} stats
1227  */
1228 remoting.ClientSession.prototype.logStatistics = function(stats) {
1229   this.logToServer.logStatistics(stats, this.mode_);
1230 };
1231
1232 /**
1233  * Enable or disable logging of connection errors due to a host being offline.
1234  * For example, if attempting a connection using a cached JID, host-offline
1235  * errors should not be logged because the JID will be refreshed and the
1236  * connection retried.
1237  *
1238  * @param {boolean} enable True to log host-offline errors; false to suppress.
1239  */
1240 remoting.ClientSession.prototype.logHostOfflineErrors = function(enable) {
1241   this.logHostOfflineErrors_ = enable;
1242 };
1243
1244 /**
1245  * Request pairing with the host for PIN-less authentication.
1246  *
1247  * @param {string} clientName The human-readable name of the client.
1248  * @param {function(string, string):void} onDone Callback to receive the
1249  *     client id and shared secret when they are available.
1250  */
1251 remoting.ClientSession.prototype.requestPairing = function(clientName, onDone) {
1252   if (this.plugin_) {
1253     this.plugin_.requestPairing(clientName, onDone);
1254   }
1255 };
1256
1257 /**
1258  * Called when the full-screen status has changed, either via the
1259  * remoting.Fullscreen class, or via a system event such as the Escape key
1260  *
1261  * @param {boolean} fullscreen True if the app is entering full-screen mode;
1262  *     false if it is leaving it.
1263  * @private
1264  */
1265 remoting.ClientSession.prototype.onFullScreenChanged_ = function (fullscreen) {
1266   var htmlNode = /** @type {HTMLElement} */ (document.documentElement);
1267   this.enableBumpScroll_(fullscreen);
1268   if (fullscreen) {
1269     htmlNode.classList.add('full-screen');
1270   } else {
1271     htmlNode.classList.remove('full-screen');
1272   }
1273 };
1274
1275 /**
1276  * Scroll the client plugin by the specified amount, keeping it visible.
1277  * Note that this is only used in content full-screen mode (not windowed or
1278  * browser full-screen modes), where window.scrollBy and the scrollTop and
1279  * scrollLeft properties don't work.
1280  * @param {number} dx The amount by which to scroll horizontally. Positive to
1281  *     scroll right; negative to scroll left.
1282  * @param {number} dy The amount by which to scroll vertically. Positive to
1283  *     scroll down; negative to scroll up.
1284  * @return {boolean} True if the requested scroll had no effect because both
1285  *     vertical and horizontal edges of the screen have been reached.
1286  * @private
1287  */
1288 remoting.ClientSession.prototype.scroll_ = function(dx, dy) {
1289   /**
1290    * Helper function for x- and y-scrolling
1291    * @param {number|string} curr The current margin, eg. "10px".
1292    * @param {number} delta The requested scroll amount.
1293    * @param {number} windowBound The size of the window, in pixels.
1294    * @param {number} pluginBound The size of the plugin, in pixels.
1295    * @param {{stop: boolean}} stop Reference parameter used to indicate when
1296    *     the scroll has reached one of the edges and can be stopped in that
1297    *     direction.
1298    * @return {string} The new margin value.
1299    */
1300   var adjustMargin = function(curr, delta, windowBound, pluginBound, stop) {
1301     var minMargin = Math.min(0, windowBound - pluginBound);
1302     var result = (curr ? parseFloat(curr) : 0) - delta;
1303     result = Math.min(0, Math.max(minMargin, result));
1304     stop.stop = (result == 0 || result == minMargin);
1305     return result + 'px';
1306   };
1307
1308   var plugin = this.plugin_.element();
1309   var style = this.container_.style;
1310
1311   var stopX = { stop: false };
1312   var clientArea = this.getClientArea_();
1313   style.marginLeft = adjustMargin(style.marginLeft, dx, clientArea.width,
1314       this.pluginWidthForBumpScrollTesting || plugin.clientWidth, stopX);
1315
1316   var stopY = { stop: false };
1317   style.marginTop = adjustMargin(
1318       style.marginTop, dy, clientArea.height,
1319       this.pluginHeightForBumpScrollTesting || plugin.clientHeight, stopY);
1320   return stopX.stop && stopY.stop;
1321 };
1322
1323 remoting.ClientSession.prototype.resetScroll_ = function() {
1324   this.container_.style.marginTop = '0px';
1325   this.container_.style.marginLeft = '0px';
1326 };
1327
1328 /**
1329  * Enable or disable bump-scrolling. When disabling bump scrolling, also reset
1330  * the scroll offsets to (0, 0).
1331  * @private
1332  * @param {boolean} enable True to enable bump-scrolling, false to disable it.
1333  */
1334 remoting.ClientSession.prototype.enableBumpScroll_ = function(enable) {
1335   var element = /*@type{HTMLElement} */ document.documentElement;
1336   if (enable) {
1337     /** @type {null|function(Event):void} */
1338     this.onMouseMoveRef_ = this.onMouseMove_.bind(this);
1339     element.addEventListener('mousemove', this.onMouseMoveRef_, false);
1340   } else {
1341     element.removeEventListener('mousemove', this.onMouseMoveRef_, false);
1342     this.onMouseMoveRef_ = null;
1343     this.resetScroll_();
1344   }
1345 };
1346
1347 /**
1348  * @param {Event} event The mouse event.
1349  * @private
1350  */
1351 remoting.ClientSession.prototype.onMouseMove_ = function(event) {
1352   if (this.bumpScrollTimer_) {
1353     window.clearTimeout(this.bumpScrollTimer_);
1354     this.bumpScrollTimer_ = null;
1355   }
1356
1357   /**
1358    * Compute the scroll speed based on how close the mouse is to the edge.
1359    * @param {number} mousePos The mouse x- or y-coordinate
1360    * @param {number} size The width or height of the content area.
1361    * @return {number} The scroll delta, in pixels.
1362    */
1363   var computeDelta = function(mousePos, size) {
1364     var threshold = 10;
1365     if (mousePos >= size - threshold) {
1366       return 1 + 5 * (mousePos - (size - threshold)) / threshold;
1367     } else if (mousePos <= threshold) {
1368       return -1 - 5 * (threshold - mousePos) / threshold;
1369     }
1370     return 0;
1371   };
1372
1373   var clientArea = this.getClientArea_();
1374   var dx = computeDelta(event.x, clientArea.width);
1375   var dy = computeDelta(event.y, clientArea.height);
1376
1377   if (dx != 0 || dy != 0) {
1378     this.raiseEvent(remoting.ClientSession.Events.bumpScrollStarted);
1379     /** @type {remoting.ClientSession} */
1380     var that = this;
1381     /**
1382      * Scroll the view, and schedule a timer to do so again unless we've hit
1383      * the edges of the screen. This timer is cancelled when the mouse moves.
1384      * @param {number} expected The time at which we expect to be called.
1385      */
1386     var repeatScroll = function(expected) {
1387       /** @type {number} */
1388       var now = new Date().getTime();
1389       /** @type {number} */
1390       var timeout = 10;
1391       var lateAdjustment = 1 + (now - expected) / timeout;
1392       if (that.scroll_(lateAdjustment * dx, lateAdjustment * dy)) {
1393         that.raiseEvent(remoting.ClientSession.Events.bumpScrollStopped);
1394       } else {
1395         that.bumpScrollTimer_ = window.setTimeout(
1396             function() { repeatScroll(now + timeout); },
1397             timeout);
1398       }
1399     };
1400     repeatScroll(new Date().getTime());
1401   }
1402 };
1403
1404 /**
1405  * Sends a clipboard item to the host.
1406  *
1407  * @param {string} mimeType The MIME type of the clipboard item.
1408  * @param {string} item The clipboard item.
1409  */
1410 remoting.ClientSession.prototype.sendClipboardItem = function(mimeType, item) {
1411   if (!this.plugin_)
1412     return;
1413   this.plugin_.sendClipboardItem(mimeType, item);
1414 };
1415
1416 /**
1417  * Send a gnubby-auth extension message to the host.
1418  * @param {Object} data The gnubby-auth message data.
1419  */
1420 remoting.ClientSession.prototype.sendGnubbyAuthMessage = function(data) {
1421   if (!this.plugin_)
1422     return;
1423   this.plugin_.sendClientMessage('gnubby-auth', JSON.stringify(data));
1424 };
1425
1426 /**
1427  * Process a remote gnubby auth request.
1428  * @param {string} data Remote gnubby request data.
1429  * @private
1430  */
1431 remoting.ClientSession.prototype.processGnubbyAuthMessage_ = function(data) {
1432   if (this.gnubbyAuthHandler_) {
1433     try {
1434       this.gnubbyAuthHandler_.onMessage(data);
1435     } catch (err) {
1436       console.error('Failed to process gnubby message: ',
1437           /** @type {*} */ (err));
1438     }
1439   } else {
1440     console.error('Received unexpected gnubby message');
1441   }
1442 };
1443
1444 /**
1445  * Create a gnubby auth handler and inform the host that gnubby auth is
1446  * supported.
1447  * @private
1448  */
1449 remoting.ClientSession.prototype.createGnubbyAuthHandler_ = function() {
1450   if (this.mode_ == remoting.ClientSession.Mode.ME2ME) {
1451     this.gnubbyAuthHandler_ = new remoting.GnubbyAuthHandler(this);
1452     // TODO(psj): Move to more generic capabilities mechanism.
1453     this.sendGnubbyAuthMessage({'type': 'control', 'option': 'auth-v1'});
1454   }
1455 };
1456
1457 /**
1458  * @return {{width: number, height: number}} The height of the window's client
1459  *     area. This differs between apps v1 and apps v2 due to the custom window
1460  *     borders used by the latter.
1461  * @private
1462  */
1463 remoting.ClientSession.prototype.getClientArea_ = function() {
1464   return remoting.windowFrame ?
1465       remoting.windowFrame.getClientArea() :
1466       { 'width': window.innerWidth, 'height': window.innerHeight };
1467 };
1468
1469 /**
1470  * @param {string} url
1471  * @param {number} hotspotX
1472  * @param {number} hotspotY
1473  */
1474 remoting.ClientSession.prototype.updateMouseCursorImage_ =
1475     function(url, hotspotX, hotspotY) {
1476   this.mouseCursorOverlay_.hidden = !url;
1477   if (url) {
1478     this.mouseCursorOverlay_.style.marginLeft = '-' + hotspotX + 'px';
1479     this.mouseCursorOverlay_.style.marginTop = '-' + hotspotY + 'px';
1480     this.mouseCursorOverlay_.src = url;
1481   }
1482 };
1483
1484 /**
1485  * @return {{top: number, left:number}} The top-left corner of the plugin.
1486  */
1487 remoting.ClientSession.prototype.getPluginPositionForTesting = function() {
1488   var style = this.container_.style;
1489   return {
1490     top: parseFloat(style.marginTop),
1491     left: parseFloat(style.marginLeft)
1492   };
1493 };
1494
1495 /**
1496  * Send a Cast extension message to the host.
1497  * @param {Object} data The cast message data.
1498  */
1499 remoting.ClientSession.prototype.sendCastExtensionMessage = function(data) {
1500   if (!this.plugin_)
1501     return;
1502   this.plugin_.sendClientMessage('cast_message', JSON.stringify(data));
1503 };
1504
1505 /**
1506  * Process a remote Cast extension message from the host.
1507  * @param {string} data Remote cast extension data message.
1508  * @private
1509  */
1510 remoting.ClientSession.prototype.processCastExtensionMessage_ = function(data) {
1511   if (this.castExtensionHandler_) {
1512     try {
1513       this.castExtensionHandler_.onMessage(data);
1514     } catch (err) {
1515       console.error('Failed to process cast message: ',
1516           /** @type {*} */ (err));
1517     }
1518   } else {
1519     console.error('Received unexpected cast message');
1520   }
1521 };
1522
1523 /**
1524  * Create a CastExtensionHandler and inform the host that cast extension
1525  * is supported.
1526  * @private
1527  */
1528 remoting.ClientSession.prototype.createCastExtensionHandler_ = function() {
1529   if (remoting.enableCast && this.mode_ == remoting.ClientSession.Mode.ME2ME) {
1530     this.castExtensionHandler_ = new remoting.CastExtensionHandler(this);
1531   }
1532 };
1533
1534 /**
1535  * Returns true if the ClientSession can record video frames to a file.
1536  * @return {boolean}
1537  */
1538 remoting.ClientSession.prototype.canRecordVideo = function() {
1539   return !!this.videoFrameRecorder_;
1540 }
1541
1542 /**
1543  * Returns true if the ClientSession is currently recording video frames.
1544  * @return {boolean}
1545  */
1546 remoting.ClientSession.prototype.isRecordingVideo = function() {
1547   if (!this.videoFrameRecorder_) {
1548     return false;
1549   }
1550   return this.videoFrameRecorder_.isRecording();
1551 }
1552
1553 /**
1554  * Starts or stops recording of video frames.
1555  */
1556 remoting.ClientSession.prototype.startStopRecording = function() {
1557   if (this.videoFrameRecorder_) {
1558     this.videoFrameRecorder_.startStopRecording();
1559   }
1560 }
1561
1562 /**
1563  * Handles protocol extension messages.
1564  * @param {string} type Type of extension message.
1565  * @param {string} data Contents of the extension message.
1566  * @return {boolean} True if the message was recognized, false otherwise.
1567  */
1568 remoting.ClientSession.prototype.handleExtensionMessage =
1569     function(type, data) {
1570   if (this.videoFrameRecorder_) {
1571     return this.videoFrameRecorder_.handleMessage(type, data);
1572   }
1573   return false;
1574 }