remoting/webapp/crd/js/wcs_sandbox_container.js

   1 /* Copyright 2013 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 /**
   7  * @fileoverview
   8  * The application side of the application/sandbox WCS interface, used by the
   9  * application to exchange messages with the sandbox.
  10  */
  11
  12 'use strict';
  13
  14 /** @suppress {duplicate} */
  15 var remoting = remoting || {};
  16
  17 /**
  18  * @param {Window} sandbox The Javascript Window object representing the
  19  *     sandboxed WCS driver.
  20  * @constructor
  21  */
  22 remoting.WcsSandboxContainer = function(sandbox) {
  23   /** @private */
  24   this.sandbox_ = sandbox;
  25   /** @type {?function(string):void}
  26     * @private */
  27   this.onConnected_ = null;
  28   /** @type {function(remoting.Error):void}
  29     * @private */
  30   this.onError_ = function(error) {};
  31   /** @type {?function(string):void}
  32     * @private */
  33   this.onIq_ = null;
  34   /** @type {Object<number, XMLHttpRequest>}
  35     * @private */
  36   this.pendingXhrs_ = {};
  37   /** @private */
  38   this.localJid_ = '';
  39
  40   /** @private */
  41   this.accessTokenRefreshTimerStarted_ = false;
  42
  43   window.addEventListener('message', this.onMessage_.bind(this), false);
  44
  45   if (base.isAppsV2()) {
  46     var message = {
  47       'command': 'proxyXhrs'
  48     };
  49     this.sandbox_.postMessage(message, '*');
  50   }
  51 };
  52
  53 /**
  54  * @param {function(string):void} onConnected Callback to be called when WCS is
  55  *     connected. May be called synchronously if WCS is already connected.
  56  * @param {function(remoting.Error):void} onError called in case of an error.
  57  * @return {void} Nothing.
  58  */
  59 remoting.WcsSandboxContainer.prototype.connect = function(
  60     onConnected, onError) {
  61   this.onError_ = onError;
  62   this.ensureAccessTokenRefreshTimer_();
  63   if (this.localJid_) {
  64     onConnected(this.localJid_);
  65   } else {
  66     this.onConnected_ = onConnected;
  67   }
  68 };
  69
  70 /**
  71  * @param {?function(string):void} onIq Callback invoked when an IQ stanza is
  72  *     received.
  73  * @return {void} Nothing.
  74  */
  75 remoting.WcsSandboxContainer.prototype.setOnIq = function(onIq) {
  76   this.onIq_ = onIq;
  77 };
  78
  79 /**
  80  * Refreshes access token and starts a timer to update it periodically.
  81  *
  82  * @private
  83  */
  84 remoting.WcsSandboxContainer.prototype.ensureAccessTokenRefreshTimer_ =
  85     function() {
  86   if (this.accessTokenRefreshTimerStarted_) {
  87     return;
  88   }
  89
  90   this.refreshAccessToken_();
  91   setInterval(this.refreshAccessToken_.bind(this), 60 * 1000);
  92   this.accessTokenRefreshTimerStarted_ = true;
  93 }
  94
  95 /**
  96  * @private
  97  * @return {void} Nothing.
  98  */
  99 remoting.WcsSandboxContainer.prototype.refreshAccessToken_ = function() {
 100   remoting.identity.getToken().then(
 101       this.setAccessToken_.bind(this),
 102       remoting.Error.handler(this.onError_));
 103 };
 104
 105 /**
 106  * @private
 107  * @param {string} token The access token.
 108  * @return {void}
 109  */
 110 remoting.WcsSandboxContainer.prototype.setAccessToken_ = function(token) {
 111   var message = {
 112     'command': 'setAccessToken',
 113     'token': token
 114   };
 115   this.sandbox_.postMessage(message, '*');
 116 };
 117
 118 /**
 119  * @param {string} stanza The IQ stanza to send.
 120  * @return {void}
 121  */
 122 remoting.WcsSandboxContainer.prototype.sendIq = function(stanza) {
 123   var message = {
 124     'command': 'sendIq',
 125     'stanza': stanza
 126   };
 127   this.sandbox_.postMessage(message, '*');
 128 };
 129
 130 /**
 131  * Event handler to process messages from the sandbox.
 132  *
 133  * @param {Event} event
 134  */
 135 remoting.WcsSandboxContainer.prototype.onMessage_ = function(event) {
 136   switch (event.data['command']) {
 137
 138     case 'onLocalJid':
 139       /** @type {string} */
 140       var localJid = event.data['localJid'];
 141       if (localJid === undefined) {
 142         console.error('onReady: missing localJid');
 143         break;
 144       }
 145       this.localJid_ = localJid;
 146       if (this.onConnected_) {
 147         var callback = this.onConnected_;
 148         this.onConnected_ = null;
 149         callback(localJid);
 150       }
 151       break;
 152
 153     case 'onError':
 154       /** @type {remoting.Error} */
 155       var error = event.data['error'];
 156       if (error === undefined) {
 157         console.error('onError: missing error code');
 158         break;
 159       }
 160       this.onError_(error);
 161       break;
 162
 163     case 'onIq':
 164       /** @type {string} */
 165       var stanza = event.data['stanza'];
 166       if (stanza === undefined) {
 167         console.error('onIq: missing IQ stanza');
 168         break;
 169       }
 170       if (this.onIq_) {
 171         this.onIq_(stanza);
 172       }
 173       break;
 174
 175     case 'sendXhr':
 176       /** @type {number} */
 177       var id = event.data['id'];
 178       if (id === undefined) {
 179         console.error('sendXhr: missing id');
 180         break;
 181       }
 182       /** @type {Object} */
 183       var parameters = event.data['parameters'];
 184       if (parameters === undefined) {
 185         console.error('sendXhr: missing parameters');
 186         break;
 187       }
 188       /** @type {string} */
 189       var method = parameters['method'];
 190       if (method === undefined) {
 191         console.error('sendXhr: missing method');
 192         break;
 193       }
 194       /** @type {string} */
 195       var url = parameters['url'];
 196       if (url === undefined) {
 197         console.error('sendXhr: missing url');
 198         break;
 199       }
 200       /** @type {string} */
 201       var data = parameters['data'];
 202       if (data === undefined) {
 203         console.error('sendXhr: missing data');
 204         break;
 205       }
 206       /** @type {string|undefined}*/
 207       var user = parameters['user'];
 208       /** @type {string|undefined}*/
 209       var password = parameters['password'];
 210       var xhr = new XMLHttpRequest;
 211       this.pendingXhrs_[id] = xhr;
 212       xhr.open(method, url, true, user, password);
 213       /** @type {Object} */
 214       var headers = parameters['headers'];
 215       if (headers) {
 216         for (var header in headers) {
 217           xhr.setRequestHeader(header, headers[header]);
 218         }
 219       }
 220       xhr.onreadystatechange = this.onReadyStateChange_.bind(this, id);
 221       xhr.send(data);
 222       break;
 223
 224     case 'abortXhr':
 225       var id = event.data['id'];
 226       if (id === undefined) {
 227         console.error('abortXhr: missing id');
 228         break;
 229       }
 230       var xhr = this.pendingXhrs_[id]
 231       if (!xhr) {
 232         // It's possible for an abort and a reply to cross each other on the
 233         // IPC channel. In that case, we silently ignore the abort.
 234         break;
 235       }
 236       xhr.abort();
 237       break;
 238
 239     default:
 240       console.error('Unexpected message:', event.data['command'], event.data);
 241   }
 242 };
 243
 244 /**
 245  * Return a "copy" of an XHR object suitable for postMessage. Specifically,
 246  * remove all non-serializable members such as functions.
 247  *
 248  * @param {XMLHttpRequest} xhr The XHR to serialize.
 249  * @return {Object} A serializable version of the input.
 250  */
 251 function sanitizeXhr_(xhr) {
 252   /** @type {Object} */
 253   var result = {
 254     readyState: xhr.readyState,
 255     response: xhr.response,
 256     responseText: xhr.responseText,
 257     responseType: xhr.responseType,
 258     responseXML: xhr.responseXML,
 259     status: xhr.status,
 260     statusText: xhr.statusText,
 261     withCredentials: xhr.withCredentials
 262   };
 263   return result;
 264 }
 265
 266 /**
 267  * @param {number} id The unique ID of the XHR for which the state has changed.
 268  * @private
 269  */
 270 remoting.WcsSandboxContainer.prototype.onReadyStateChange_ = function(id) {
 271   var xhr = this.pendingXhrs_[id];
 272   if (!xhr) {
 273     // XHRs are only removed when they have completed, in which case no
 274     // further callbacks should be received.
 275     console.error('Unexpected callback for xhr', id);
 276     return;
 277   }
 278   var message = {
 279     'command': 'xhrStateChange',
 280     'id': id,
 281     'xhr': sanitizeXhr_(xhr)
 282   };
 283   this.sandbox_.postMessage(message, '*');
 284   if (xhr.readyState == 4) {
 285     delete this.pendingXhrs_[id];
 286   }
 287 }
 288
 289 /** @type {remoting.WcsSandboxContainer} */
 290 remoting.wcsSandbox = null;