Refactor tool-bar event handlers.

remoting/webapp/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
  * establish connection. Specifically it:
  *  - Delivers incoming/outgoing signaling messages,
  *  - Adjusts plugin size and position when destop resolution changes,
  *
  * This class should not access the plugin directly, instead it should
  * do it through ClientPlugin class which abstracts plugin version
  * differences.
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
+ * @param {string} hostDisplayName A human-readable name for the host.
  * @param {string} accessCode The IT2Me access code. Blank for Me2Me.
  * @param {function(boolean, function(string): void): void} fetchPin
  *     Called by Me2Me connections when a PIN needs to be obtained
  *     interactively.
  * @param {function(string, string, string,
  *                  function(string, string): void): void}
  *     fetchThirdPartyToken Called by Me2Me connections when a third party
  *     authentication token must be obtained.
  * @param {string} authenticationMethods Comma-separated list of
  *     authentication methods the client should attempt to use.
  * @param {string} hostId The host identifier for Me2Me, or empty for IT2Me.
  *     Mixed into authentication hashes for some authentication methods.
  * @param {string} hostJid The jid of the host to connect to.
  * @param {string} hostPublicKey The base64 encoded version of the host's
  *     public key.
  * @param {remoting.ClientSession.Mode} mode The mode of this connection.
  * @param {string} clientPairingId For paired Me2Me connections, the
  *     pairing id for this client, as issued by the host.
  * @param {string} clientPairedSecret For paired Me2Me connections, the
  *     paired secret for this client, as issued by the host.
  * @constructor
  * @extends {base.EventSource}
  */
-remoting.ClientSession = function(accessCode, fetchPin, fetchThirdPartyToken,
-                                  authenticationMethods,
+remoting.ClientSession = function(hostDisplayName, accessCode, fetchPin,
+                                  fetchThirdPartyToken, authenticationMethods,
                                   hostId, hostJid, hostPublicKey, mode,
                                   clientPairingId, clientPairedSecret) {
   /** @private */
   this.state_ = remoting.ClientSession.State.CREATED;
 
   /** @private */
   this.error_ = remoting.Error.NONE;
 
   /** @private */
+  this.hostDisplayName_ = hostDisplayName;
+  /** @private */
   this.hostJid_ = hostJid;
   /** @private */
   this.hostPublicKey_ = hostPublicKey;
   /** @private */
   this.accessCode_ = accessCode;
   /** @private */
   this.fetchPin_ = fetchPin;
   /** @private */
   this.fetchThirdPartyToken_ = fetchThirdPartyToken;
   /** @private */
@@ skipping 32 matching lines @@
    *
    * @type {boolean} @private
    */
   this.logHostOfflineErrors_ = true;
 
   /** @private */
   this.callPluginLostFocus_ = this.pluginLostFocus_.bind(this);
   /** @private */
   this.callPluginGotFocus_ = this.pluginGotFocus_.bind(this);
   /** @private */
-  this.callSetScreenMode_ = this.onSetScreenMode_.bind(this);
-  /** @private */
   this.callToggleFullScreen_ = remoting.fullscreen.toggle.bind(
       remoting.fullscreen);
   /** @private */
   this.callOnFullScreenChanged_ = this.onFullScreenChanged_.bind(this)
 
   /** @private */
   this.screenOptionsMenu_ = new remoting.MenuButton(
       document.getElementById('screen-options-menu'),
       this.onShowOptionsMenu_.bind(this));
   /** @private */
@@ skipping 13 matching lines @@
   this.fullScreenButton_ = document.getElementById('toggle-full-screen');
 
   /** @type {remoting.GnubbyAuthHandler} @private */
   this.gnubbyAuthHandler_ = null;
 
   if (this.mode_ == remoting.ClientSession.Mode.IT2ME) {
     // Resize-to-client is not supported for IT2Me hosts.
     this.resizeToClientButton_.hidden = true;
   } else {
     this.resizeToClientButton_.hidden = false;
-    this.resizeToClientButton_.addEventListener(
-        'click', this.callSetScreenMode_, false);
   }
 
-  this.shrinkToFitButton_.addEventListener(
-      'click', this.callSetScreenMode_, false);
   this.fullScreenButton_.addEventListener(
       'click', this.callToggleFullScreen_, false);
   this.defineEvents(Object.keys(remoting.ClientSession.Events));
 };
 
 base.extend(remoting.ClientSession, base.EventSource);
 
 /** @enum {string} */
 remoting.ClientSession.Events = {
   stateChanged: 'stateChanged',
   videoChannelStateChanged: 'videoChannelStateChanged'
 };
 
 /**
+ * Get host display name.
+ *
+ * @return {string}
+ */
+remoting.ClientSession.prototype.getHostDisplayName = function() {
+  return this.hostDisplayName_;
+};
+
+/**
  * Called when the window or desktop size or the scaling settings change,
  * to set the scroll-bar visibility.
  *
  * TODO(jamiewalch): crbug.com/252796: Remove this once crbug.com/240772 is
  * fixed.
  */
 remoting.ClientSession.prototype.updateScrollbarVisibility = function() {
   var needsVerticalScroll = false;
   var needsHorizontalScroll = false;
   if (!this.shrinkToFit_) {
@@ skipping 18 matching lines @@
   } else {
     scroller.classList.add('no-horizontal-scroll');
   }
   if (needsVerticalScroll) {
     scroller.classList.remove('no-vertical-scroll');
   } else {
     scroller.classList.add('no-vertical-scroll');
   }
 };
 
+/**
+ * @return {boolean} True if shrink-to-fit is enabled; false otherwise.
+ */
+remoting.ClientSession.prototype.getShrinkToFit = function() {
+  return this.shrinkToFit_;
+};
+
+/**
+ * @return {boolean} True if resize-to-client is enabled; false otherwise.
+ */
+remoting.ClientSession.prototype.getResizeToClient = function() {
+  return this.resizeToClient_;
+};
+
 // Note that the positive values in both of these enums are copied directly
 // from chromoting_scriptable_object.h and must be kept in sync. The negative
 // values represent state transitions that occur within the web-app that have
 // no corresponding plugin state transition.
 /** @enum {number} */
 remoting.ClientSession.State = {
   CONNECTION_CANCELED: -3,  // Connection closed (gracefully) before connecting.
   CONNECTION_DROPPED: -2,  // Succeeded, but subsequently closed with an error.
   CREATED: -1,
   UNKNOWN: 0,
@@ skipping 341 matching lines @@
   if (this.plugin_) {
     this.plugin_.element().removeEventListener(
         'focus', this.callPluginGotFocus_, false);
     this.plugin_.element().removeEventListener(
         'blur', this.callPluginLostFocus_, false);
     this.plugin_.cleanup();
     this.plugin_ = null;
   }
 
   // Delete event handlers that aren't relevent when not connected.
-  this.resizeToClientButton_.removeEventListener(
-      'click', this.callSetScreenMode_, false);
-  this.shrinkToFitButton_.removeEventListener(
-      'click', this.callSetScreenMode_, false);
   this.fullScreenButton_.removeEventListener(
       'click', this.callToggleFullScreen_, false);
 
   // Leave full-screen mode, and stop listening for related events.
   var listener = this.callOnFullScreenChanged_;
   remoting.fullscreen.syncWithMaximize(false);
   remoting.fullscreen.activate(
       false,
       function() {
         remoting.fullscreen.removeListener(listener);
       });
   if (remoting.windowFrame) {
     remoting.windowFrame.setConnected(false);
   }
+  remoting.toolbar.setClientSession(null);
 
   // Remove mediasource-rendering class from video-contained - this will also
   // hide the <video> element.
   /** @type {HTMLElement} */(document.getElementById('video-container'))
       .classList.remove('mediasource-rendering');
 };
 
 /**
  * Disconnect the current session with a particular |error|.  The session will
  * raise a |stateChanged| event in response to it.  The caller should then call
@@ skipping 75 matching lines @@
     this.plugin_.injectKeyEvent(keys[i], false);
   }
 }
 
 /**
  * Sends a Ctrl-Alt-Del sequence to the remoting client.
  *
  * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.sendCtrlAltDel = function() {
+  console.log('Sending Ctrl-Alt-Del.');
   this.sendKeyCombination_([0x0700e0, 0x0700e2, 0x07004c]);
 }
 
 /**
  * Sends a Print Screen keypress to the remoting client.
  *
  * @return {void} Nothing.
  */
 remoting.ClientSession.prototype.sendPrintScreen = function() {
+  console.log('Sending Print Screen.');
   this.sendKeyCombination_([0x070046]);
 }
 
 /**
  * Sets and stores the key remapping setting for the current host.
  *
  * @param {string} remappings Comma separated list of key remappings.
  */
 remoting.ClientSession.prototype.setRemapKeys = function(remappings) {
   // Cancel any existing remappings and apply the new ones.
@@ skipping 42 matching lines @@
                   '>0x' + toKey.toString(16));
       this.plugin_.remapKey(fromKey, toKey);
     } else {
       console.log('cancel remapKey 0x' + fromKey.toString(16));
       this.plugin_.remapKey(fromKey, fromKey);
     }
   }
 }
 
 /**
- * Callback for the two "screen mode" related menu items: Resize desktop to
- * fit and Shrink to fit.
- *
- * @param {Event} event The click event indicating which mode was selected.
- * @return {void} Nothing.
- * @private
- */
-remoting.ClientSession.prototype.onSetScreenMode_ = function(event) {
-  var shrinkToFit = this.shrinkToFit_;
-  var resizeToClient = this.resizeToClient_;
-  if (event.target == this.shrinkToFitButton_) {
-    shrinkToFit = !shrinkToFit;
-  }
-  if (event.target == this.resizeToClientButton_) {
-    resizeToClient = !resizeToClient;
-  }
-  this.setScreenMode_(shrinkToFit, resizeToClient);
-};
-
-/**
  * Set the shrink-to-fit and resize-to-client flags and save them if this is
  * a Me2Me connection.
  *
  * @param {boolean} shrinkToFit True if the remote desktop should be scaled
  *     down if it is larger than the client window; false if scroll-bars
  *     should be added in this case.
  * @param {boolean} resizeToClient True if window resizes should cause the
  *     host to attempt to resize its desktop to match the client window size;
  *     false to disable this behaviour for subsequent window resizes--the
  *     current host desktop size is not restored in this case.
  * @return {void} Nothing.
- * @private
  */
-remoting.ClientSession.prototype.setScreenMode_ =
+remoting.ClientSession.prototype.setScreenMode =
     function(shrinkToFit, resizeToClient) {
   if (resizeToClient && !this.resizeToClient_) {
     var clientArea = this.getClientArea_();
     this.plugin_.notifyClientResolution(clientArea.width,
                                         clientArea.height,
                                         window.devicePixelRatio);
   }
 
   // If enabling shrink, reset bump-scroll offsets.
   var needsScrollReset = shrinkToFit && !this.shrinkToFit_;
@@ skipping 181 matching lines @@
       this.plugin_.notifyClientResolution(clientArea.width,
                                           clientArea.height,
                                           window.devicePixelRatio);
     }
     // Activate full-screen related UX.
     remoting.fullscreen.addListener(this.callOnFullScreenChanged_);
     remoting.fullscreen.syncWithMaximize(true);
     if (remoting.windowFrame) {
       remoting.windowFrame.setConnected(true);
     }
+    remoting.toolbar.setClientSession(this);
 
   } else if (status == remoting.ClientSession.State.FAILED) {
     switch (error) {
       case remoting.ClientSession.ConnectionError.HOST_IS_OFFLINE:
         this.error_ = remoting.Error.HOST_IS_OFFLINE;
         break;
       case remoting.ClientSession.ConnectionError.SESSION_REJECTED:
         this.error_ = remoting.Error.INVALID_ACCESS_CODE;
         break;
       case remoting.ClientSession.ConnectionError.INCOMPATIBLE_PROTOCOL:
@@ skipping 512 matching lines @@
  * @return {{width: number, height: number}} The height of the window's client
  *     area. This differs between apps v1 and apps v2 due to the custom window
  *     borders used by the latter.
  * @private
  */
 remoting.ClientSession.prototype.getClientArea_ = function() {
   return remoting.windowFrame ?
       remoting.windowFrame.getClientArea() :
       { 'width': window.innerWidth, 'height': window.innerHeight };
 }