remoting/webapp/crd/js/mock_client_plugin.js

   1 // Copyright 2014 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  * Mock implementation of ClientPlugin for testing.
   8  */
   9
  10 /** @suppress {duplicate} */
  11 var remoting = remoting || {};
  12
  13 (function() {
  14
  15 'use strict';
  16
  17 /**
  18  * @constructor
  19  * @implements {remoting.ClientPlugin}
  20  */
  21 remoting.MockClientPlugin = function() {
  22   /** @private {Element} */
  23   this.container_ = null;
  24   /** @private */
  25   this.element_ = /** @type {HTMLElement} */ (document.createElement('div'));
  26   this.element_.style.backgroundImage = 'linear-gradient(45deg, blue, red)';
  27   /** @private */
  28   this.hostDesktop_ =
  29       new remoting.ClientPlugin.HostDesktopImpl(this, base.doNothing);
  30   /** @private */
  31   this.extensions_ = new remoting.ProtocolExtensionManager(base.doNothing);
  32
  33   /** @private {remoting.CredentialsProvider} */
  34   this.credentials_ = null;
  35
  36   /** @private {remoting.ClientPlugin.ConnectionEventHandler} */
  37   this.connectionEventHandler_ = null;
  38
  39   // Fake initialization result to return.
  40   this.mock$initializationResult = true;
  41
  42   // Fake capabilities to return.
  43   this.mock$capabilities = [
  44       remoting.ClientSession.Capability.SEND_INITIAL_RESOLUTION,
  45       remoting.ClientSession.Capability.RATE_LIMIT_RESIZE_REQUESTS
  46   ];
  47
  48   /** @private */
  49   this.onConnectDeferred_ = new base.Deferred();
  50 };
  51
  52 remoting.MockClientPlugin.prototype.dispose = function() {
  53   this.container_.removeChild(this.element_);
  54   this.element_ = null;
  55   this.connectionStatusUpdateHandler_ = null;
  56 };
  57
  58 remoting.MockClientPlugin.prototype.extensions = function() {
  59   return this.extensions_;
  60 };
  61
  62 remoting.MockClientPlugin.prototype.hostDesktop = function() {
  63   return this.hostDesktop_;
  64 };
  65
  66 remoting.MockClientPlugin.prototype.element = function() {
  67   return this.element_;
  68 };
  69
  70 remoting.MockClientPlugin.prototype.initialize = function(onDone) {
  71   var that = this;
  72   Promise.resolve().then(function() {
  73     onDone(that.mock$initializationResult);
  74   });
  75 };
  76
  77
  78 remoting.MockClientPlugin.prototype.connect =
  79     function(host, localJid, credentialsProvider) {
  80   this.credentials_ = credentialsProvider;
  81   this.onConnectDeferred_.resolve();
  82 };
  83
  84 remoting.MockClientPlugin.prototype.injectKeyCombination = function(keys) {};
  85
  86 remoting.MockClientPlugin.prototype.injectKeyEvent =
  87     function(key, down) {};
  88
  89 remoting.MockClientPlugin.prototype.setRemapKeys = function(remappings) {};
  90
  91 remoting.MockClientPlugin.prototype.remapKey = function(from, to) {};
  92
  93 remoting.MockClientPlugin.prototype.releaseAllKeys = function() {};
  94
  95 remoting.MockClientPlugin.prototype.onIncomingIq = function(iq) {};
  96
  97 remoting.MockClientPlugin.prototype.isSupportedVersion = function() {
  98   return true;
  99 };
 100
 101 remoting.MockClientPlugin.prototype.hasFeature = function(feature) {
 102   return false;
 103 };
 104
 105 remoting.MockClientPlugin.prototype.hasCapability = function(capability) {
 106   return this.mock$capabilities.indexOf(capability) !== -1;
 107 };
 108
 109 remoting.MockClientPlugin.prototype.sendClipboardItem =
 110     function(mimeType, item) {};
 111
 112 remoting.MockClientPlugin.prototype.enableTouchEvents =
 113     function(enable) {};
 114
 115 remoting.MockClientPlugin.prototype.requestPairing =
 116     function(clientName, onDone) {};
 117
 118 remoting.MockClientPlugin.prototype.allowMouseLock = function() {};
 119
 120 remoting.MockClientPlugin.prototype.pauseAudio = function(pause) {};
 121
 122 remoting.MockClientPlugin.prototype.pauseVideo = function(pause) {};
 123
 124 remoting.MockClientPlugin.prototype.getPerfStats = function() {
 125   var result = new remoting.ClientSession.PerfStats;
 126   result.videoBandwidth = 999;
 127   result.videoFrameRate = 60;
 128   result.captureLatency = 10;
 129   result.encodeLatency = 10;
 130   result.decodeLatency = 10;
 131   result.renderLatency = 10;
 132   result.roundtripLatency = 10;
 133   return result;
 134 };
 135
 136 remoting.MockClientPlugin.prototype.setConnectionEventHandler =
 137     function(handler) {
 138   this.connectionEventHandler_ = handler;
 139 };
 140
 141 remoting.MockClientPlugin.prototype.setMouseCursorHandler =
 142     function(handler) {};
 143
 144 remoting.MockClientPlugin.prototype.setClipboardHandler = function(handler) {};
 145
 146 remoting.MockClientPlugin.prototype.setDebugDirtyRegionHandler =
 147     function(handler) {};
 148
 149 /** @param {Element} container */
 150 remoting.MockClientPlugin.prototype.mock$setContainer = function(container) {
 151   this.container_ = container;
 152   this.container_.appendChild(this.element_);
 153 };
 154
 155 /** @return {Promise} */
 156 remoting.MockClientPlugin.prototype.mock$onConnect = function() {
 157   this.onConnectDeferred_ = new base.Deferred();
 158   return this.onConnectDeferred_.promise();
 159 };
 160
 161 /**
 162  * @param {remoting.ClientSession.State} status
 163  * @param {remoting.ClientSession.ConnectionError=} opt_error
 164  */
 165 remoting.MockClientPlugin.prototype.mock$setConnectionStatus = function(
 166     status, opt_error) {
 167   console.assert(this.connectionEventHandler_ !== null,
 168                  '|connectionEventHandler_| is null.');
 169   var PluginError = remoting.ClientSession.ConnectionError;
 170   var error = opt_error ? opt_error : PluginError.NONE;
 171   this.connectionEventHandler_.onConnectionStatusUpdate(status, error);
 172 };
 173
 174 /**
 175  * @param {remoting.MockClientPlugin.AuthMethod} authMethod
 176  * @return {Promise}
 177  */
 178 remoting.MockClientPlugin.prototype.mock$authenticate = function(authMethod) {
 179   var AuthMethod = remoting.MockClientPlugin.AuthMethod;
 180   var deferred = new base.Deferred();
 181
 182   var that = this;
 183   switch(authMethod) {
 184     case AuthMethod.PIN:
 185     case AuthMethod.ACCESS_CODE:
 186       this.credentials_.getPIN(true).then(function() {
 187         deferred.resolve();
 188       });
 189       break;
 190     case AuthMethod.THIRD_PARTY:
 191       this.credentials_.getThirdPartyToken(
 192           'fake_token_url', 'fake_host_publicKey', 'fake_scope'
 193       ).then(function() {
 194         deferred.resolve();
 195       });
 196       break;
 197     case AuthMethod.PAIRING:
 198       deferred.resolve();
 199   }
 200   return deferred.promise();
 201 };
 202
 203 /**
 204  * @param {remoting.MockClientPlugin.AuthMethod} authMethod
 205  */
 206 remoting.MockClientPlugin.prototype.mock$useDefaultBehavior =
 207     function(authMethod) {
 208   var that = this;
 209   var State = remoting.ClientSession.State;
 210   this.mock$onConnect().then(function() {
 211     that.mock$setConnectionStatus(State.CONNECTING);
 212     return that.mock$authenticate(authMethod);
 213   }).then(function() {
 214     that.mock$setConnectionStatus(State.CONNECTED);
 215   });
 216 };
 217
 218 /**
 219  * @constructor
 220  * @implements {remoting.ClientPluginFactory}
 221  */
 222 remoting.MockClientPluginFactory = function() {
 223   /** @private */
 224   this.plugin_ = new remoting.MockClientPlugin();
 225 };
 226
 227 remoting.MockClientPluginFactory.prototype.createPlugin =
 228     function(container, capabilities) {
 229   this.plugin_.mock$setContainer(container);
 230   this.plugin_.mock$capabilities = capabilities;
 231   return this.plugin_;
 232 };
 233
 234 /** @return {remoting.MockClientPlugin} */
 235 remoting.MockClientPluginFactory.prototype.plugin = function() {
 236   return this.plugin_;
 237 };
 238
 239 remoting.MockClientPluginFactory.prototype.preloadPlugin = function() {};
 240
 241 /**
 242  * A class that sets up all the dependencies required for mocking a connection.
 243  *
 244  * @constructor
 245  */
 246 remoting.MockConnection = function() {
 247   /** @private */
 248   this.originalPluginFactory_ = remoting.ClientPlugin.factory;
 249
 250   /** @private */
 251   this.pluginFactory_ = new remoting.MockClientPluginFactory();
 252   remoting.ClientPlugin.factory = this.pluginFactory_;
 253
 254   /** @private */
 255   this.mockSignalStrategy_ = new remoting.MockSignalStrategy(
 256       'fake_jid', remoting.SignalStrategy.Type.XMPP);
 257
 258   /** @private {sinon.TestStub} */
 259   this.createSignalStrategyStub_ =
 260       sinon.stub(remoting.SignalStrategy, 'create');
 261   this.createSignalStrategyStub_.returns(this.mockSignalStrategy_);
 262
 263   /** @private */
 264   this.originalIdentity_ = remoting.identity;
 265   remoting.identity = new remoting.Identity();
 266   var identityStub = sinon.stub(remoting.identity, 'getUserInfo');
 267   identityStub.returns(Promise.resolve({email: 'email', userName: 'userName'}));
 268
 269   /** @private */
 270   this.originalSettings_ = remoting.settings;
 271   remoting.settings = new remoting.Settings();
 272 };
 273
 274 /** @return {remoting.MockClientPlugin} */
 275 remoting.MockConnection.prototype.plugin = function() {
 276   return this.pluginFactory_.plugin();
 277 };
 278
 279 /** @return {remoting.MockSignalStrategy} */
 280 remoting.MockConnection.prototype.signalStrategy = function() {
 281   return this.mockSignalStrategy_;
 282 };
 283
 284 remoting.MockConnection.prototype.restore = function() {
 285   remoting.settings = this.originalSettings_;
 286   remoting.identity = this.originalIdentity_;
 287   remoting.ClientPlugin.factory = this.originalPluginFactory_;
 288   this.createSignalStrategyStub_.restore();
 289 };
 290
 291 })();
 292
 293 /** @enum {string} */
 294 remoting.MockClientPlugin.AuthMethod = {
 295   ACCESS_CODE: 'accessCode',
 296   PIN: 'pin',
 297   THIRD_PARTY: 'thirdParty',
 298   PAIRING: 'pairing'
 299 };