[Webapp Refactor] Reparent the ConnectedView into the delegate.

remoting/webapp/crd/js/session_connector_impl.js

 // Copyright 2013 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
  * Connect set-up state machine for Me2Me and IT2Me
  */
 
 'use strict';
@@ skipping 13 matching lines @@
  *     once the connector has invoked its onOk callback.
  * TODO(garykac): Have this owned by someone instead of being global.
  */
 remoting.desktopConnectedView = null;
 
 /**
  * @param {HTMLElement} clientContainer Container element for the client view.
  * @param {function(remoting.ConnectionInfo):void} onConnected Callback on
  *     success.
  * @param {function(!remoting.Error):void} onError Callback on error.
- * @param {function(string, string):boolean} appProtocolExtensionHandler The
- *     handler for the application's protocol extension messages. Returns true
- *     if a message is recognized; false otherwise.
  * @param {function(!remoting.Error):void} onConnectionFailed Callback for when
  *     the connection fails.
  * @param {Array<string>} requiredCapabilities Connector capabilities
  *     required by this application.
  * @param {string} defaultRemapKeys The default set of key mappings for the
  *     client session to use.
  * @constructor
  * @implements {remoting.SessionConnector}
  */
 remoting.SessionConnectorImpl = function(clientContainer, onConnected, onError,
-                                         appProtocolExtensionHandler,
                                          onConnectionFailed,
                                          requiredCapabilities,
                                          defaultRemapKeys) {
   /** @private {HTMLElement} */
   this.clientContainer_ = clientContainer;
 
   /** @private {function(remoting.ConnectionInfo):void} */
   this.onConnected_ = onConnected;
 
   /** @private {function(!remoting.Error):void} */
   this.onError_ = onError;
 
-  /** @private {function(string, string):boolean} */
-  this.appProtocolExtensionHandler_ = appProtocolExtensionHandler;
-
   /** @private {function(!remoting.Error):void} */
   this.onConnectionFailed_ = onConnectionFailed;
 
   /** @private {Array<string>} */
   this.requiredCapabilities_ = requiredCapabilities;
 
   /** @private {string} */
   this.defaultRemapKeys_ = defaultRemapKeys;
 
   /** @private {remoting.DesktopConnectedView.Mode} */
@@ skipping 38 matching lines @@
   this.connectedView_ = null;
 
   /** @private {XMLHttpRequest} */
   this.pendingXhr_ = null;
 
   /** @private {remoting.CredentialsProvider} */
   this.credentialsProvider_ = null;
 
   /** @private {Object<string,remoting.ProtocolExtension>} */
   this.protocolExtensions_ = {};
+
+  /**
+   * True once a session has been created and we've started the extensions.
+   * This is used to immediately start any extensions that are registered
+   * after the CONNECTED state change.
+   * @private {boolean}
+   */
+  this.protocolExtensionsStarted_ = false;
 };
 
 /**
  * Initiate a Me2Me connection.
  *
  * This doesn't report host-offline errors because the connection will
  * be retried and retryConnectMe2Me is responsible for reporting these errors.
  *
  * @param {remoting.Host} host The Me2Me host to which to connect.
  * @param {function(boolean, function(string):void):void} fetchPin Function to
@@ skipping 267 matching lines @@
 
   base.dispose(this.plugin_);
   this.plugin_ = null;
 };
 
 /**
  * @param {remoting.ProtocolExtension} extension
  */
 remoting.SessionConnectorImpl.prototype.registerProtocolExtension =
     function(extension) {
-  var type = extension.getType();
-  if (type in this.protocolExtensions_) {
-    console.error(
-        'Attempt to register multiple extensions with the same type: ', type);
-    return;
+  var types = extension.getExtensionTypes();
+
+  // Make sure we don't have an extension of that type already registered.
+  for (var i=0, len=types.length; i < len; i++) {
+    if (types[i] in this.protocolExtensions_) {
+      console.error(
+          'Attempt to register multiple extensions of the same type: ', type);
+      return;
+    }
   }
-  this.protocolExtensions_[type] = extension;
+
+  for (var i=0, len=types.length; i < len; i++) {
+    var type = types[i];
+    this.protocolExtensions_[type] = extension;
+    if (this.protocolExtensionsStarted_) {
+      this.startProtocolExtension_(type);
+    }
+  }
 };
 
 /** @private */
 remoting.SessionConnectorImpl.prototype.initProtocolExtensions_ = function() {
+  base.debug.assert(!this.protocolExtensionsStarted_);
   for (var type in this.protocolExtensions_) {
-    /** @type {remoting.ProtocolExtension} */
-    var extension = this.protocolExtensions_[type];
-    extension.start(this.plugin_.sendClientMessage.bind(this.plugin_));
+    this.startProtocolExtension_(type);
   }
+  this.protocolExtensionsStarted_ = true;
 };
 
 /**
+ * @param {string} type
+ * @private
+ */
+remoting.SessionConnectorImpl.prototype.startProtocolExtension_ =
+    function(type) {
+  var extension = this.protocolExtensions_[type];
+  extension.startExtension(this.plugin_.sendClientMessage.bind(this.plugin_));
+};
+
+/**
  * Called when an extension message needs to be handled.
  *
  * @param {string} type The type of the extension message.
  * @param {string} data The payload of the extension message.
  * @return {boolean} Return true if the extension message was recognized.
  * @private
  */
 remoting.SessionConnectorImpl.prototype.onProtocolExtensionMessage_ =
     function(type, data) {
   if (type == 'test-echo-reply') {
     console.log('Got echo reply: ' + data);
     return true;
   }
-  for (var type in this.protocolExtensions_) {
+
+  var message = base.jsonParseSafe(data);
+  if (typeof message != 'object') {
+    console.error('Error parsing extension json data: ' + data);
+    return false;
+  }
+
+  if (type in this.protocolExtensions_) {
     /** @type {remoting.ProtocolExtension} */
     var extension = this.protocolExtensions_[type];
-    if (type == extension.getType()) {
-      try {
-        extension.onMessage(data);
-      } catch (/** @type {*} */ err) {
-        console.error('Failed to process protocol extension ', type,
-                      ' message: ', err);
-      }
+    var handled = false;
+    try {
+      handled = extension.onExtensionMessage(type, message);
+    } catch (/** @type {*} */ err) {
+      console.error('Failed to process protocol extension ' + type +
+                    ' message: ' + err);
+    }
+    if (handled) {
       return true;
     }
   }
-  return this.appProtocolExtensionHandler_(type, data);
+
+  if (remoting.desktopConnectedView) {
+    return remoting.desktopConnectedView.handleExtensionMessage(type, message);
+  }
+
+  return false;
 };
 
 /**
  * Handle a change in the state of the client session prior to successful
  * connection (after connection, this class no longer handles state change
  * events). Errors that occur while connecting either trigger a reconnect
  * or notify the onError handler.
  *
  * @param {remoting.ClientSession.StateEvent=} event
  * @return {void} Nothing.
@@ skipping 71 matching lines @@
  * @constructor
  * @implements {remoting.SessionConnectorFactory}
  */
 remoting.DefaultSessionConnectorFactory = function() {};
 
 /**
  * @param {HTMLElement} clientContainer Container element for the client view.
  * @param {function(remoting.ConnectionInfo):void} onConnected Callback on
  *     success.
  * @param {function(!remoting.Error):void} onError Callback on error.
- * @param {function(string, string):boolean} appProtocolExtensionHandler The
- *     handler for the application's protocol extension messages. Returns true
- *     if a message is recognized; false otherwise.
  * @param {function(!remoting.Error):void} onConnectionFailed Callback for when
  *     the connection fails.
  * @param {Array<string>} requiredCapabilities Connector capabilities
  *     required by this application.
  * @param {string} defaultRemapKeys The default set of key mappings to use
  *     in the client session.
  * @return {remoting.SessionConnector}
  */
 remoting.DefaultSessionConnectorFactory.prototype.createConnector =
     function(clientContainer, onConnected, onError,
-             appProtocolExtensionHandler,
              onConnectionFailed, requiredCapabilities, defaultRemapKeys) {
   return new remoting.SessionConnectorImpl(clientContainer, onConnected,
                                            onError,
-                                           appProtocolExtensionHandler,
                                            onConnectionFailed,
                                            requiredCapabilities,
                                            defaultRemapKeys);
 };