Log signal strategy progress to server.

remoting/webapp/crd/js/fallback_signal_strategy.js

 // Copyright 2015 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.
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * A signal strategy encapsulating a primary and a back-up strategy. If the
  * primary fails or times out, then the secondary is used. Information about
  * which strategy was used, and why, is returned via |onProgressCallback|.
  *
  * @param {remoting.SignalStrategy} primary
  * @param {remoting.SignalStrategy} secondary
- * @param {function(remoting.FallbackSignalStrategy.Progress)}
- *     onProgressCallback
  *
  * @implements {remoting.SignalStrategy}
  * @constructor
  */
 remoting.FallbackSignalStrategy = function(primary,
-                                           secondary,
-                                           onProgressCallback) {
+                                           secondary) {
   /**
    * @type {remoting.SignalStrategy}
    * @private
    */
   this.primary_ = primary;
   this.primary_.setStateChangedCallback(this.onPrimaryStateChanged_.bind(this));
 
   /**
    * @type {remoting.SignalStrategy}
    * @private
    */
   this.secondary_ = secondary;
   this.secondary_.setStateChangedCallback(
       this.onSecondaryStateChanged_.bind(this));
 
   /**
    * @type {?function(remoting.SignalStrategy.State)}
    * @private
    */
   this.onStateChangedCallback_ = null;
 
   /**
-   * @type {function(remoting.FallbackSignalStrategy.Progress)}
-   * @private
-   */
-  this.onProgressCallback_ = onProgressCallback;
-
-  /**
    * @type {?function(Element):void}
    * @private
    */
   this.onIncomingStanzaCallback_ = null;
 
   /**
    * @type {number}
    * @private
    * @const
    */
@@ skipping 41 matching lines @@
    * @type {string}
    * @private
    */
   this.authToken_ = '';
 
   /**
    * @type {number}
    * @private
    */
   this.primaryConnectTimerId_ = 0;
+
+  /**
+   * @type {remoting.LogToServer}
+   * @private
+   */
+  this.logToServer_ = null;
+
+  /**
+   * @type {Array.<{strategyType: remoting.SignalStrategy.Type,
+                    progress: remoting.FallbackSignalStrategy.Progress,
+   *                elapsed: number}>}
+   */
+  this.connectionSetupResults_ = [];
+
+  /**
+   * @type {number}
+   * @private
+   */
+  this.startTime_ = 0;
 };
 
 /**
  * @enum {string}
  */
 remoting.FallbackSignalStrategy.Progress = {
-  PRIMARY_SUCCEEDED: 'primary-succeeded',
-  PRIMARY_FAILED: 'primary-failed',
-  PRIMARY_TIMED_OUT: 'primary-timed-out',
-  PRIMARY_SUCCEEDED_LATE: 'primary-succeeded-late',
-  PRIMARY_FAILED_LATE: 'primary-failed-late',
-  SECONDARY_SUCCEEDED: 'secondary-succeeded',
-  SECONDARY_FAILED: 'secondary-failed'
+  SUCCEEDED: 'succeeded',
+  FAILED: 'failed',
+  TIMED_OUT: 'timed-out',
+  SUCCEEDED_LATE: 'succeeded-late',
+  FAILED_LATE: 'failed-late',
 };
 
 remoting.FallbackSignalStrategy.prototype.dispose = function() {
   this.primary_.dispose();
   this.secondary_.dispose();
 };
 
 /**
  * @param {function(remoting.SignalStrategy.State):void} onStateChangedCallback
  *   Callback to call on state change.
@@ skipping 25 matching lines @@
  * @param {string} authToken
  */
 remoting.FallbackSignalStrategy.prototype.connect =
     function(server, username, authToken) {
   base.debug.assert(this.state_ == this.State.NOT_CONNECTED);
   base.debug.assert(this.onStateChangedCallback_ != null);
   this.server_ = server;
   this.username_ = username;
   this.authToken_ = authToken;
   this.state_ = this.State.PRIMARY_PENDING;
+  this.startTime_ = new Date().getTime();
   this.primary_.setIncomingStanzaCallback(this.onIncomingStanzaCallback_);
   this.primary_.connect(server, username, authToken);
   this.primaryConnectTimerId_ =
       window.setTimeout(this.onPrimaryTimeout_.bind(this),
                         this.PRIMARY_CONNECT_TIMEOUT_MS_);
 };
 
 /**
  * Sends a message. Can be called only in CONNECTED state.
  * @param {string} message
  */
 remoting.FallbackSignalStrategy.prototype.sendMessage = function(message) {
   this.getConnectedSignalStrategy_().sendMessage(message);
 };
 
+/**
+ * Send any messages accumulated during connection set-up.
+ *
+ * @param {remoting.LogToServer} logToServer The LogToServer instance for the
+ *     connection.
+ */
+remoting.FallbackSignalStrategy.prototype.sendConnectionSetupResults =
+    function(logToServer) {
+  this.logToServer_ = logToServer;
+  this.sendConnectionSetupResultsInternal_();
+}
+
+remoting.FallbackSignalStrategy.prototype.sendConnectionSetupResultsInternal_ =
+    function() {
+  for (var i = 0; i < this.connectionSetupResults_.length; ++i) {
+    var result = this.connectionSetupResults_[i];
+    this.logToServer_.logSignalStrategyProgress(result.strategyType,
+                                                result.progress,
+                                                result.elapsed);
+  }
+  this.connectionSetupResults_ = [];
+};
+
 /** @return {remoting.SignalStrategy.State} Current state */
 remoting.FallbackSignalStrategy.prototype.getState = function() {
   return (this.externalState_ === null)
       ? remoting.SignalStrategy.State.NOT_CONNECTED
       : this.externalState_;
 };
 
 /** @return {remoting.Error} Error when in FAILED state. */
 remoting.FallbackSignalStrategy.prototype.getError = function() {
   base.debug.assert(this.state_ == this.State.SECONDARY_FAILED);
   base.debug.assert(
       this.secondary_.getState() == remoting.SignalStrategy.State.FAILED);
   return this.secondary_.getError();
 };
 
 /** @return {string} Current JID when in CONNECTED state. */
 remoting.FallbackSignalStrategy.prototype.getJid = function() {
   return this.getConnectedSignalStrategy_().getJid();
 };
 
+/** @return {remoting.SignalStrategy.Type} The signal strategy type. */
+remoting.FallbackSignalStrategy.prototype.getType = function() {
+  return this.getConnectedSignalStrategy_().getType();
+};
+
 /**
  * @return {remoting.SignalStrategy} The active signal strategy, if the
  *     connection has succeeded.
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.getConnectedSignalStrategy_ =
     function() {
   if (this.state_ == this.State.PRIMARY_SUCCEEDED) {
     base.debug.assert(
         this.primary_.getState() == remoting.SignalStrategy.State.CONNECTED);
@@ skipping 13 matching lines @@
 /**
  * @param {remoting.SignalStrategy.State} state
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.onPrimaryStateChanged_ =
     function(state) {
   switch (state) {
     case remoting.SignalStrategy.State.CONNECTED:
       if (this.state_ == this.State.PRIMARY_PENDING) {
         window.clearTimeout(this.primaryConnectTimerId_);
-        this.onProgressCallback_(
-            remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED);
+        this.updateProgress_(
+            this.primary_,
+            remoting.FallbackSignalStrategy.Progress.SUCCEEDED);
         this.state_ = this.State.PRIMARY_SUCCEEDED;
       } else {
-        this.onProgressCallback_(
-            remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED_LATE);
+        this.updateProgress_(
+            this.primary_,
+            remoting.FallbackSignalStrategy.Progress.SUCCEEDED_LATE);
       }
       break;
 
     case remoting.SignalStrategy.State.FAILED:
       if (this.state_ == this.State.PRIMARY_PENDING) {
         window.clearTimeout(this.primaryConnectTimerId_);
-        this.onProgressCallback_(
-            remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED);
+        this.updateProgress_(
+            this.primary_,
+            remoting.FallbackSignalStrategy.Progress.FAILED);
         this.connectSecondary_();
       } else {
-        this.onProgressCallback_(
-            remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED_LATE);
+        this.updateProgress_(
+            this.primary_,
+            remoting.FallbackSignalStrategy.Progress.FAILED_LATE);
       }
       return;  // Don't notify the external callback
 
     case remoting.SignalStrategy.State.CLOSED:
       this.state_ = this.State.CLOSED;
       break;
   }
 
   this.notifyExternalCallback_(state);
 };
 
 /**
  * @param {remoting.SignalStrategy.State} state
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.onSecondaryStateChanged_ =
     function(state) {
   switch (state) {
     case remoting.SignalStrategy.State.CONNECTED:
-      this.onProgressCallback_(
-          remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED);
+      this.updateProgress_(
+          this.secondary_,
+          remoting.FallbackSignalStrategy.Progress.SUCCEEDED);
       this.state_ = this.State.SECONDARY_SUCCEEDED;
       break;
 
     case remoting.SignalStrategy.State.FAILED:
-      this.onProgressCallback_(
-          remoting.FallbackSignalStrategy.Progress.SECONDARY_FAILED);
+      this.updateProgress_(
+          this.secondary_,
+          remoting.FallbackSignalStrategy.Progress.FAILED);
       this.state_ = this.State.SECONDARY_FAILED;
       break;
 
     case remoting.SignalStrategy.State.CLOSED:
       this.state_ = this.State.CLOSED;
       break;
   }
 
   this.notifyExternalCallback_(state);
 };
@@ skipping 28 matching lines @@
   this.state_ = this.State.SECONDARY_PENDING;
   this.primary_.setIncomingStanzaCallback(null);
   this.secondary_.setIncomingStanzaCallback(this.onIncomingStanzaCallback_);
   this.secondary_.connect(this.server_, this.username_, this.authToken_);
 };
 
 /**
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.onPrimaryTimeout_ = function() {
-  this.onProgressCallback_(
-      remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT);
+  this.updateProgress_(
+      this.primary_,
+      remoting.FallbackSignalStrategy.Progress.TIMED_OUT);
   this.connectSecondary_();
 };
+
+/**
+ * @param {remoting.SignalStrategy} strategy
+ * @param {remoting.FallbackSignalStrategy.Progress} progress
+ * @private
+ */
+remoting.FallbackSignalStrategy.prototype.updateProgress_ = function(
+    strategy, progress) {
+  console.log('FallbackSignalStrategy progress: ' + strategy.getType() + ' ' +
+      progress);
+  this.connectionSetupResults_.push({
+    'strategyType': strategy.getType(),
+    'progress': progress,
+    'elapsed': new Date().getTime() - this.startTime_
+  });
+  if (this.logToServer_) {
+    this.sendConnectionSetupResultsInternal_();
+  }
+};