Separate host desktop related functionality into remoting.HostDesktop

remoting/webapp/crd/js/client_plugin_impl.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 that wraps low-level details of interacting with the client plugin.
  *
  * This abstracts a <embed> element and controls the plugin which does
  * the actual remoting work. It also handles differences between
@@ skipping 30 matching lines @@
   this.plugin_.id = 'session-client-plugin';
   container.appendChild(this.plugin_);
 
   this.onExtensionMessage_ = onExtensionMessage;
   /**
    * @type {Array<string>}
    * @private
    */
   this.requiredCapabilities_ = requiredCapabilities;
 
-  /** @private */
-  this.desktopWidth_ = 0;
-  /** @private */
-  this.desktopHeight_ = 0;
-  /** @private */
-  this.desktopXDpi_ = 96;
-  /** @private */
-  this.desktopYDpi_ = 96;
-
   /**
    * @param {string} iq The Iq stanza received from the host.
    * @private
    */
   this.onOutgoingIqHandler_ = function (iq) {};
   /**
    * @param {string} message Log message.
    * @private
    */
   this.onDebugMessageHandler_ = function (message) {};
@@ skipping 18 matching lines @@
   this.onConnectionReadyHandler_ = function(ready) {};
 
   /**
    * @param {string} tokenUrl Token-request URL, received from the host.
    * @param {string} hostPublicKey Public key for the host.
    * @param {string} scope OAuth scope to request the token for.
    * @private
    */
   this.fetchThirdPartyTokenHandler_ = function(
     tokenUrl, hostPublicKey, scope) {};
-  /** @private */
-  this.onDesktopSizeUpdateHandler_ = function () {};
-  /**
-   * @param {Array<Array<number>>} rects
-   * @private
-   */
-  this.onDesktopShapeUpdateHandler_ = function (rects) {};
   /**
    * @param {!Array<string>} capabilities The negotiated capabilities.
    * @private
    */
   this.onSetCapabilitiesHandler_ = function (capabilities) {};
   /** @private */
   this.fetchPinHandler_ = function (supportsPairing) {};
   /**
    * @param {string} data Remote gnubbyd data.
    * @private
@@ skipping 27 matching lines @@
    * @type {number}
    * @private
    */
   this.pluginApiMinVersion_ = -1;
   /**
    * @type {!Array<string>}
    * @private
    */
   this.capabilities_ = [];
   /**
+   * @type {!Array<string>}
+   * @private
+   */
+  this.hostCapabilities_ = [];
+  /**
    * @type {boolean}
    * @private
    */
   this.helloReceived_ = false;
   /**
    * @type {function(boolean)|null}
    * @private
    */
   this.onInitializedCallback_ = null;
   /**
@@ skipping 11 matching lines @@
   var that = this;
   /** @param {Event} event Message event from the plugin. */
   this.plugin_.addEventListener('message', function(event) {
       that.handleMessage_(
           /** @type {remoting.ClientPluginMessage} */ (event.data));
     }, false);
 
   if (remoting.settings.CLIENT_PLUGIN_TYPE == 'native') {
     window.setTimeout(this.showPluginForClickToPlay_.bind(this), 500);
   }
+
+  this.hostDesktop_ = new remoting.ClientPlugin.HostDesktopImpl(
+      this, this.postMessage_.bind(this));
 };
 
 /**
  * Creates plugin element without adding it to a container.
  *
  * @return {HTMLEmbedElement} Plugin element
  */
 remoting.ClientPluginImpl.createPluginElement_ = function() {
   var plugin =
       /** @type {HTMLEmbedElement} */ (document.createElement('embed'));
@@ skipping 65 matching lines @@
 
 /**
  * @param {function(boolean):void} handler
  */
 remoting.ClientPluginImpl.prototype.setConnectionReadyHandler =
     function(handler) {
   this.onConnectionReadyHandler_ = handler;
 };
 
 /**
- * @param {function():void} handler
- */
-remoting.ClientPluginImpl.prototype.setDesktopSizeUpdateHandler =
-    function(handler) {
-  this.onDesktopSizeUpdateHandler_ = handler;
-};
-
-/**
- * @param {function(Array<Array<number>>):void} handler
- */
-remoting.ClientPluginImpl.prototype.setDesktopShapeUpdateHandler =
-    function(handler) {
-  this.onDesktopShapeUpdateHandler_ = handler;
-};
-
-/**
  * @param {function(!Array<string>):void} handler
  */
 remoting.ClientPluginImpl.prototype.setCapabilitiesHandler = function(handler) {
   this.onSetCapabilitiesHandler_ = handler;
 };
 
 /**
  * @param {function(string):void} handler
  */
 remoting.ClientPluginImpl.prototype.setGnubbyAuthHandler = function(handler) {
@@ skipping 73 matching lines @@
     // Resize in case we had to enlarge it to support click-to-play.
     this.hidePluginForClickToPlay_();
     this.pluginApiVersion_ = getNumberAttr(message.data, 'apiVersion');
     this.pluginApiMinVersion_ = getNumberAttr(message.data, 'apiMinVersion');
 
     if (this.pluginApiVersion_ >= 7) {
       this.pluginApiFeatures_ =
           tokenize(getStringAttr(message.data, 'apiFeatures'));
 
       // Negotiate capabilities.
-
-      /** @type {!Array<string>} */
-      var requestedCapabilities = [];
-      if ('requestedCapabilities' in message.data) {
-        requestedCapabilities =
-            tokenize(getStringAttr(message.data, 'requestedCapabilities'));
-      }
-
       /** @type {!Array<string>} */
       var supportedCapabilities = [];
       if ('supportedCapabilities' in message.data) {
         supportedCapabilities =
             tokenize(getStringAttr(message.data, 'supportedCapabilities'));
       }
       // At the moment the webapp does not recognize any of
       // 'requestedCapabilities' capabilities (so they all should be disabled)
       // and do not care about any of 'supportedCapabilities' capabilities (so
       // they all can be enabled).
@@ skipping 23 matching lines @@
     var error = remoting.ClientSession.ConnectionError.fromString(
         getStringAttr(message.data, 'error'));
     this.onConnectionStatusUpdateHandler_(state, error);
 
   } else if (message.method == 'onRouteChanged') {
     var channel = getStringAttr(message.data, 'channel');
     var connectionType = getStringAttr(message.data, 'connectionType');
     this.onRouteChangedHandler_(channel, connectionType);
 
   } else if (message.method == 'onDesktopSize') {
-    this.desktopWidth_ = getNumberAttr(message.data, 'width');
-    this.desktopHeight_ = getNumberAttr(message.data, 'height');
-    this.desktopXDpi_ = getNumberAttr(message.data, 'x_dpi', 96);
-    this.desktopYDpi_ = getNumberAttr(message.data, 'y_dpi', 96);
-    this.onDesktopSizeUpdateHandler_();
-
+    this.hostDesktop_.onSizeUpdated(message);
   } else if (message.method == 'onDesktopShape') {
-    var rects = getArrayAttr(message.data, 'rects');
-    for (var i = 0; i < rects.length; ++i) {
-      /** @type {Array<number>} */
-      var rect = rects[i];
-      if (typeof rect != 'object' || rect.length != 4) {
-        throw 'Received invalid onDesktopShape message';
-      }
-    }
-    this.onDesktopShapeUpdateHandler_(rects);
-
+    this.hostDesktop_.onShapeUpdated(message);
   } else if (message.method == 'onPerfStats') {
     // Return value is ignored. These calls will throw an error if the value
     // is not a number.
     getNumberAttr(message.data, 'videoBandwidth');
     getNumberAttr(message.data, 'videoFrameRate');
     getNumberAttr(message.data, 'captureLatency');
     getNumberAttr(message.data, 'encodeLatency');
     getNumberAttr(message.data, 'decodeLatency');
     getNumberAttr(message.data, 'renderLatency');
     getNumberAttr(message.data, 'roundtripLatency');
@@ skipping 20 matching lines @@
     // The pairingSupported value in the dictionary indicates whether both
     // client and host support pairing. If the client doesn't support pairing,
     // then the value won't be there at all, so give it a default of false.
     var pairingSupported = getBooleanAttr(message.data, 'pairingSupported',
                                           false)
     this.fetchPinHandler_(pairingSupported);
 
   } else if (message.method == 'setCapabilities') {
     /** @type {!Array<string>} */
     var capabilities = tokenize(getStringAttr(message.data, 'capabilities'));
+    this.hostDesktop_.onSetCapabilities(capabilities);
     this.onSetCapabilitiesHandler_(capabilities);
 
   } else if (message.method == 'fetchThirdPartyToken') {
     var tokenUrl = getStringAttr(message.data, 'tokenUrl');
     var hostPublicKey = getStringAttr(message.data, 'hostPublicKey');
     var scope = getStringAttr(message.data, 'scope');
     this.fetchThirdPartyTokenHandler_(tokenUrl, hostPublicKey, scope);
 
   } else if (message.method == 'pairingResponse') {
     var clientId = getStringAttr(message.data, 'clientId');
@@ skipping 99 matching lines @@
 remoting.ClientPluginImpl.prototype.hasFeature = function(feature) {
   if (!this.helloReceived_) {
     console.error(
         "hasFeature() is called before the plugin is initialized.");
     return false;
   }
   return this.pluginApiFeatures_.indexOf(feature) > -1;
 };
 
 /**
+ * @param {string} capability The capability to test for.
+ * @return {boolean} True if the host supports the named capability.
+ */
+remoting.ClientPluginImpl.prototype.hasCapability = function(capability) {
+  if (!this.hostCapabilities_) {
+    console.error(
+        "hasCapability() is called before the capabilities are received.");
+    return false;
+  }
+  return this.hostCapabilities_.indexOf(capability) > -1;
+};
+
+/**
  * @return {boolean} True if the plugin supports the injectKeyEvent API.
  */
 remoting.ClientPluginImpl.prototype.isInjectKeyEventSupported = function() {
   return this.pluginApiVersion_ >= 6;
 };
 
 /**
  * @param {string} iq Incoming IQ stanza.
  */
 remoting.ClientPluginImpl.prototype.onIncomingIq = function(iq) {
@@ skipping 137 matching lines @@
 
 /**
  * Notifies the host that the client has the specified size and pixel density.
  *
  * @param {number} width The available client width in DIPs.
  * @param {number} height The available client height in DIPs.
  * @param {number} device_scale The number of device pixels per DIP.
  */
 remoting.ClientPluginImpl.prototype.notifyClientResolution =
     function(width, height, device_scale) {
-  if (this.hasFeature(remoting.ClientPlugin.Feature.NOTIFY_CLIENT_RESOLUTION)) {
-    var dpi = Math.floor(device_scale * 96);
-    this.plugin_.postMessage(JSON.stringify(
-        { method: 'notifyClientResolution',
-          data: { width: Math.floor(width * device_scale),
-                  height: Math.floor(height * device_scale),
-                  x_dpi: dpi, y_dpi: dpi }}));
-  }
+  this.hostDesktop_.resize(width, height, device_scale);
 };
 
 /**
  * Requests that the host pause or resume sending video updates.
  *
  * @param {boolean} pause True to suspend video updates, false otherwise.
  */
 remoting.ClientPluginImpl.prototype.pauseVideo =
     function(pause) {
   if (this.hasFeature(remoting.ClientPlugin.Feature.VIDEO_CONTROL)) {
@@ skipping 121 matching lines @@
     function(type, message) {
   if (!this.hasFeature(remoting.ClientPlugin.Feature.EXTENSION_MESSAGE)) {
     return;
   }
   this.plugin_.postMessage(JSON.stringify(
       { method: 'extensionMessage',
         data: { type: type, data: message } }));
 
 };
 
-remoting.ClientPluginImpl.prototype.getDesktopWidth = function() {
-  return this.desktopWidth_;
-}
-
-remoting.ClientPluginImpl.prototype.getDesktopHeight = function() {
-  return this.desktopHeight_;
-}
-
-remoting.ClientPluginImpl.prototype.getDesktopXDpi = function() {
-  return this.desktopXDpi_;
-}
-
-remoting.ClientPluginImpl.prototype.getDesktopYDpi = function() {
-  return this.desktopYDpi_;
-}
+remoting.ClientPluginImpl.prototype.hostDesktop = function() {
+  return this.hostDesktop_;
+};
 
 /**
  * If we haven't yet received a "hello" message from the plugin, change its
  * size so that the user can confirm it if click-to-play is enabled, or can
  * see the "this plugin is disabled" message if it is actually disabled.
  * @private
  */
 remoting.ClientPluginImpl.prototype.showPluginForClickToPlay_ = function() {
   if (!this.helloReceived_) {
     var width = 200;
@@ skipping 14 matching lines @@
  * @private
  */
 remoting.ClientPluginImpl.prototype.hidePluginForClickToPlay_ = function() {
   this.plugin_.style.width = '';
   this.plugin_.style.height = '';
   this.plugin_.style.top = '';
   this.plugin_.style.left = '';
   this.plugin_.style.position = '';
 };
 
+/**
+ * Callback passed to submodules to post a message to the plugin.
+ *
+ * @param {Object} objectLiteral
+ * @private
+ */
+remoting.ClientPluginImpl.prototype.postMessage_ = function(objectLiteral) {
+  if (this.plugin_ && this.plugin_.postMessage) {
+    this.plugin_.postMessage(JSON.stringify(objectLiteral));
+  }
+};
 
 /**
  * @constructor
  * @implements {remoting.ClientPluginFactory}
  */
 remoting.DefaultClientPluginFactory = function() {};
 
 /**
  * @param {Element} container
  * @param {function(string, string):boolean} onExtensionMessage
  * @param {Array<string>} requiredCapabilities
  * @return {remoting.ClientPlugin}
  */
 remoting.DefaultClientPluginFactory.prototype.createPlugin =
     function(container, onExtensionMessage, requiredCapabilities) {
   return new remoting.ClientPluginImpl(container, onExtensionMessage,
                                        requiredCapabilities);
 };
 
 remoting.DefaultClientPluginFactory.prototype.preloadPlugin = function() {
   if (remoting.settings.CLIENT_PLUGIN_TYPE != 'pnacl') {
     return;
   }
 
   var plugin = remoting.ClientPluginImpl.createPluginElement_();
   plugin.addEventListener(
       'loadend', function() { document.body.removeChild(plugin); }, false);
   document.body.appendChild(plugin);
 };