[Chromoting] Change Application.Delegate to proper subclass of Application.

remoting/webapp/app_remoting/js/app_remoting.js

 // Copyright 2014 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
  * This class implements the functionality that is specific to application
  * remoting ("AppRemoting" or AR).
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
- * @param {remoting.Application} app The main app that owns this delegate.
+ * @param {Array<string>} appCapabilities Array of application capabilities.
  * @constructor
- * @implements {remoting.Application.Delegate}
+ * @implements {remoting.ApplicationInterface}
  * @implements {remoting.ProtocolExtension}
+ * @extends {remoting.Application}
  */
-remoting.AppRemoting = function(app) {
-  app.setDelegate(this);
+remoting.AppRemoting = function(appCapabilities) {
+  base.inherits(this, remoting.Application, appCapabilities);
 
   /** @private {remoting.ApplicationContextMenu} */
   this.contextMenu_ = null;
 
   /** @private {remoting.KeyboardLayoutsMenu} */
   this.keyboardLayoutsMenu_ = null;
 
   /** @private {remoting.WindowActivationMenu} */
   this.windowActivationMenu_ = null;
 
@@ skipping 18 matching lines @@
   this.sharedSecret = '';
 
   this.host = {
     /** @type {string} */
     applicationId: '',
 
     /** @type {string} */
     hostId: ''};
 };
 
+/** @return {string} */
+remoting.AppRemoting.prototype.runApplicationUrl = function() {

[Jamie, 2015/03/25 20:00:39]

This shouldn't be a public member, I don't think. Public methods on this class
should all be accessed through remoting.app, and runApplicationUrl is not a
generic property of all applications. It doesn't need to be this CL, but
consider either making this private or moving it to a more suitable home.

[garykac, 2015/03/26 01:41:57]

Done.

+  return remoting.settings.APP_REMOTING_API_BASE_URL + '/applications/' +
+      remoting.settings.getAppRemotingApplicationId() + '/run';
+};
+
 /**
- * Initialize the application. This is called before an OAuth token is requested
- * and should be used for tasks such as initializing the DOM, registering event
- * handlers, etc.
+ * Required for remoting.ApplicationInterface interface.
+ *
+ * @return {string} Application product name to be used in UI.
+ * @override
  */
-remoting.AppRemoting.prototype.init = function() {
+remoting.AppRemoting.prototype.getApplicationName = function() {
+  var manifest = chrome.runtime.getManifest();
+  return manifest.name;
+};
+
+/**
+ * Required for remoting.ApplicationInterface interface.
+ *
+ * @param {!remoting.Error} error The failure reason.
+ * @override
+ */
+remoting.AppRemoting.prototype.signInFailed = function(error) {
+  this.onError(error);
+};
+
+/**
+ * Required for remoting.ApplicationInterface interface.
+ *
+ * @override
+ */
+remoting.AppRemoting.prototype.initApplication = function() {
   // TODO(jamiewalch): Remove ClientSession's dependency on remoting.fullscreen
   // so that this is no longer required.
   remoting.fullscreen = new remoting.FullscreenAppsV2();
 
   var restoreHostWindows = function() {
     if (remoting.clientSession) {
       remoting.clientSession.sendClientMessage('restoreAllWindows', '');
     }
   };
   chrome.app.window.current().onRestored.addListener(restoreHostWindows);
 
   remoting.windowShape.updateClientWindowShape();
 
   // Initialize the context menus.
   if (remoting.platformIsChromeOS()) {
     var adapter = new remoting.ContextMenuChrome();
   } else {
     var adapter = new remoting.ContextMenuDom(
         document.getElementById('context-menu'));
   }
   this.contextMenu_ = new remoting.ApplicationContextMenu(adapter);
   this.keyboardLayoutsMenu_ = new remoting.KeyboardLayoutsMenu(adapter);
   this.windowActivationMenu_ = new remoting.WindowActivationMenu(adapter);
 
   remoting.LoadingWindow.show();
 };
 
 /**
- * Start the application. Once start() is called, the delegate can assume that
- * the user has consented to all permissions specified in the manifest.
+ * Required for remoting.ApplicationInterface interface.
  *
- * @param {remoting.SessionConnector} connector
- * @param {string} token An OAuth access token. The delegate should not cache
- *     this token, but can assume that it will remain valid during application
- *     start-up.
+ * @param {string} token An OAuth access token.
+ * @override
  */
-remoting.AppRemoting.prototype.start = function(connector, token) {
+remoting.AppRemoting.prototype.startApplication = function(token) {
   /** @type {remoting.AppRemoting} */
   var that = this;
 
   /** @param {!remoting.Xhr.Response} xhrResponse */
   var parseAppHostResponse = function(xhrResponse) {
     if (xhrResponse.status == 200) {
       var response = /** @type {remoting.AppRemoting.AppHostResponse} */
           (base.jsonParseSafe(xhrResponse.getText()));
       if (response &&
           response.status &&
@@ skipping 25 matching lines @@
          * @param {function(string, string):void} onThirdPartyTokenFetched
          *     Callback.
          */
         var fetchThirdPartyToken = function(
             tokenUrl, hostPublicKey, scope, onThirdPartyTokenFetched) {
           // Use the authentication tokens returned by the app-remoting server.
           onThirdPartyTokenFetched(host['authorizationCode'],
                                    host['sharedSecret']);
         };
 
-        connector.connectMe2App(host, fetchThirdPartyToken);
+        that.sessionConnector_.connectMe2App(host, fetchThirdPartyToken);
       } else if (response && response.status == 'pending') {
-        that.handleError(new remoting.Error(
+        that.onError(new remoting.Error(
             remoting.Error.Tag.SERVICE_UNAVAILABLE));
       }
     } else {
       console.error('Invalid "runApplication" response from server.');
       // TODO(garykac) Start using remoting.Error.fromHttpStatus once it has
       // been updated to properly report 'unknown' errors (rather than
       // reporting them as AUTHENTICATION_FAILED).
       if (xhrResponse.status == 0) {
-        that.handleError(new remoting.Error(
+        that.onError(new remoting.Error(
             remoting.Error.Tag.NETWORK_FAILURE));
       } else if (xhrResponse.status == 401) {
-        that.handleError(new remoting.Error(
+        that.onError(new remoting.Error(
             remoting.Error.Tag.AUTHENTICATION_FAILED));
       } else if (xhrResponse.status == 403) {
-        that.handleError(new remoting.Error(
+        that.onError(new remoting.Error(
             remoting.Error.Tag.APP_NOT_AUTHORIZED));
       } else if (xhrResponse.status == 502 || xhrResponse.status == 503) {
-        that.handleError(new remoting.Error(
+        that.onError(new remoting.Error(
             remoting.Error.Tag.SERVICE_UNAVAILABLE));
       } else {
-        that.handleError(remoting.Error.unexpected());
+        that.onError(remoting.Error.unexpected());
       }
     }
   };
 
   new remoting.Xhr({
     method: 'POST',
     url: that.runApplicationUrl(),
     oauthToken: token
   }).start().then(parseAppHostResponse);
 };
 
 /**
- * Report an authentication error to the user. This is called in lieu of start()
- * if the user cannot be authenticated or if they decline the app permissions.
- *
- * @param {!remoting.Error} error The failure reason.
+ * Close the loading window before exiting.
  */
-remoting.AppRemoting.prototype.signInFailed = function(error) {
-  this.handleError(error);
+remoting.AppRemoting.prototype.exit = function() {
+  remoting.LoadingWindow.close();
+
+  // Call superclass exit() after we've closed all our windows.
+  remoting.Application.prototype.exit.call(this);
 };
 
 /**
- * @return {string} Application product name to be used in UI.
- */
-remoting.AppRemoting.prototype.getApplicationName = function() {
-  var manifest = chrome.runtime.getManifest();
-  return manifest.name;
-};
-
-/** @return {string} */
-remoting.AppRemoting.prototype.runApplicationUrl = function() {
-  return remoting.settings.APP_REMOTING_API_BASE_URL + '/applications/' +
-      remoting.settings.getAppRemotingApplicationId() + '/run';
-};
-
-/**
  * Called when a new session has been connected.
  *
  * @param {remoting.ConnectionInfo} connectionInfo
  * @return {void} Nothing.
  */
-remoting.AppRemoting.prototype.handleConnected = function(connectionInfo) {
+remoting.AppRemoting.prototype.onConnected = function(connectionInfo) {
+  remoting.Application.prototype.onConnected.call(this, connectionInfo);
+
   remoting.identity.getUserInfo().then(
       function(userInfo) {
         remoting.clientSession.sendClientMessage(
             'setUserDisplayInfo',
             JSON.stringify({fullName: userInfo.name}));
       });
 
-  remoting.app.getSessionConnector().registerProtocolExtension(this);
+  this.sessionConnector_.registerProtocolExtension(this);
 
   this.connectedView_ = new remoting.AppConnectedView(
       document.getElementById('client-container'), connectionInfo);
 
   // Map Cmd to Ctrl on Mac since hosts typically use Ctrl for keyboard
   // shortcuts, but we want them to act as natively as possible.
   if (remoting.platformIsMac()) {
     connectionInfo.plugin().setRemapKeys('0x0700e3>0x0700e0,0x0700e7>0x0700e4');
   }
 };
 
 /**
  * Called when the current session has been disconnected.
  *
  * @return {void} Nothing.
  */
-remoting.AppRemoting.prototype.handleDisconnected = function() {
+remoting.AppRemoting.prototype.onDisconnected = function() {
+  remoting.Application.prototype.onDisconnected.call(this);
+
   base.dispose(this.connectedView_);
   this.connectedView_ = null;
 
   chrome.app.window.current().close();
 };
 
 /**
  * Called when the current session's connection has failed.
  *
- * @param {remoting.SessionConnector} connector
  * @param {!remoting.Error} error
  * @return {void} Nothing.
  */
-remoting.AppRemoting.prototype.handleConnectionFailed = function(
-    connector, error) {
-  this.handleError(error);
+remoting.AppRemoting.prototype.onConnectionFailed = function(error) {
+  remoting.Application.prototype.onConnectionFailed.call(this, error);
+
+  this.onError(error);
 };
 
-/** @return {Array<string>} */
+/**
+ * Called when an error needs to be displayed to the user.
+ *
+ * @param {!remoting.Error} error The error to be localized and displayed.
+ * @return {void} Nothing.
+ */
+remoting.AppRemoting.prototype.onError = function(error) {
+  remoting.Application.prototype.onError.call(this, error);
+
+  console.error('Connection failed: ' + error.toString());
+  remoting.LoadingWindow.close();
+  remoting.MessageWindow.showErrorMessage(
+      chrome.i18n.getMessage(/*i18n-content*/'CONNECTION_FAILED'),
+      chrome.i18n.getMessage(error.getTag()));
+};
+
+
+/**
+ * Required for remoting.ProtocolExtension interface.
+ *
+ * @return {Array<string>}
+ */
 remoting.AppRemoting.prototype.getExtensionTypes = function() {
   return ['openURL', 'onWindowRemoved', 'onWindowAdded',
           'onAllWindowsMinimized', 'setKeyboardLayouts', 'pingResponse'];
 };
 
 /**
+ * Required for remoting.ProtocolExtension interface.
+ *
  * @param {function(string,string)} sendMessageToHost Callback to send a message
  *     to the host.
  */
 remoting.AppRemoting.prototype.startExtension = function(sendMessageToHost) {
 };
 
 /**
+ * Required for remoting.ProtocolExtension interface.
+ *
  * @param {string} type The message type.
  * @param {Object} message The parsed extension message data.
  */
 remoting.AppRemoting.prototype.onExtensionMessage = function(type, message) {
   switch (type) {
 
     case 'openURL':
       // URL requests from the hosted app are untrusted, so disallow anything
       // other than HTTP or HTTPS.
       var url = base.getStringAttr(message, 'url');
@@ skipping 29 matching lines @@
 
     case 'pingResponse':
       var then = base.getNumberAttr(message, 'timestamp');
       var now = new Date().getTime();
       this.contextMenu_.updateConnectionRTT(now - then);
       return true;
   }
 
   return false;
 };
-
-/**
- * Called when an error needs to be displayed to the user.
- *
- * @param {!remoting.Error} error The error to be localized and displayed.
- * @return {void} Nothing.
- */
-remoting.AppRemoting.prototype.handleError = function(error) {
-  console.error('Connection failed: ' + error.toString());
-  remoting.LoadingWindow.close();
-  remoting.MessageWindow.showErrorMessage(
-      chrome.i18n.getMessage(/*i18n-content*/'CONNECTION_FAILED'),
-      chrome.i18n.getMessage(error.getTag()));
-};
-
-/**
- * Close the loading window before exiting.
- */
-remoting.AppRemoting.prototype.handleExit = function() {
-  remoting.LoadingWindow.close();
-};