[Chromoting] SessionLogger refactor.

remoting/webapp/base/js/session_logger.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.
 
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 (function() {
 
@@ skipping 34 matching lines @@
   /** @private {remoting.ChromotingEvent.Os}*/
   this.hostOs_ = remoting.ChromotingEvent.Os.OTHER;
   /** @private */
   this.hostOsVersion_ = '';
   /** @private {number} */
   this.hostStatusUpdateElapsedTime_;
   /** @private */
   this.mode_ = remoting.ChromotingEvent.Mode.ME2ME;
   /** @private {remoting.ChromotingEvent.AuthMethod} */
   this.authMethod_;
-  /** @private */
-  this.pluginError_ = '';
 
   this.setSessionId_();
 };
 
 /**
  * @param {remoting.ChromotingEvent.SessionEntryPoint} entryPoint
  */
 remoting.SessionLogger.prototype.setEntryPoint = function(entryPoint) {
   this.entryPoint_ = entryPoint;
 };
@@ skipping 57 matching lines @@
 };
 
 /**
  * @param {remoting.ChromotingEvent.AuthMethod} method
  */
 remoting.SessionLogger.prototype.setAuthMethod = function(method) {
   this.authMethod_ = method;
 };
 
 /**
- * @param {string} error  The error string of the plugin error.
- */
-remoting.SessionLogger.prototype.setPluginError = function(error) {
-  this.pluginError_ = error;
-};
-
-/**
  * @return {string} The current session id. This is random GUID, refreshed
  *     every 24hrs.
  */
 remoting.SessionLogger.prototype.getSessionId = function() {
   return this.sessionId_;
 };
 
 /**
  * @param {remoting.SignalStrategy.Type} strategyType
  * @param {remoting.FallbackSignalStrategy.Progress} progress
  */
 remoting.SessionLogger.prototype.logSignalStrategyProgress =
     function(strategyType, progress) {
   this.maybeExpireSessionId_();
   var entry = new remoting.ChromotingEvent(
       remoting.ChromotingEvent.Type.SIGNAL_STRATEGY_PROGRESS);
   entry.signal_strategy_type = toSignalStrategyType(strategyType);
   entry.signal_strategy_progress = toSignalStrategyProgress(progress);
 
   this.fillEvent_(entry);
   this.log_(entry);
 };
 
 /**
- * Logs a client session state change.
- *
- * @param {remoting.ClientSession.State} state
- * @param {!remoting.Error} stateError
- * @param {?remoting.ChromotingEvent.XmppError} xmppError The XMPP error
- *     as described in http://xmpp.org/rfcs/rfc6120.html#stanzas-error.
- *     Set if the connecton error originates from the an XMPP stanza error.
- */
-remoting.SessionLogger.prototype.logClientSessionStateChange = function(
-    state, stateError, xmppError) {
-  this.logSessionStateChange(
-      toSessionState(state),
-      stateError.toConnectionError(),
-      xmppError);
-};
-
-/**
  * @param {remoting.ChromotingEvent.SessionState} state
- * @param {remoting.ChromotingEvent.ConnectionError} error
- * @param {remoting.ChromotingEvent.XmppError=} opt_XmppError
+ * @param {remoting.Error=} opt_error
  */
-remoting.SessionLogger.prototype.logSessionStateChange = function(
-    state, error, opt_XmppError) {
+remoting.SessionLogger.prototype.logSessionStateChange =
+    function(state, opt_error) {
   this.maybeExpireSessionId_();
 
-  var entry = this.makeSessionStateChange_(
-      state, error,
-      /** @type {?remoting.ChromotingEvent.XmppError} */ (opt_XmppError));
+  var entry = this.makeSessionStateChange_(state, opt_error);
   entry.previous_session_state = this.previousSessionState_;
   this.previousSessionState_ = state;
 
   this.log_(entry);
 
   // Don't accumulate connection statistics across state changes.
   this.logAccumulatedStatistics_();
   this.statsAccumulator_.empty();
 };
 
 /**
  * Logs connection statistics.
  *
  * @param {Object<number>} stats The connection statistics
  */
 remoting.SessionLogger.prototype.logStatistics = function(stats) {
   this.maybeExpireSessionId_();
   // Store the statistics.
   this.statsAccumulator_.add(stats);
   // Send statistics to the server if they've been accumulating for at least
   // 60 seconds.
   if (this.statsAccumulator_.getTimeSinceFirstValue() >=
       remoting.SessionLogger.CONNECTION_STATS_ACCUMULATE_TIME) {
     this.logAccumulatedStatistics_();
   }
 };
 
 /**
  * @param {remoting.ChromotingEvent.SessionState} state
- * @param {remoting.ChromotingEvent.ConnectionError} error
- * @param {?remoting.ChromotingEvent.XmppError} xmppError
+ * @param {remoting.Error=} opt_error
  * @return {remoting.ChromotingEvent}
  * @private
  */
 remoting.SessionLogger.prototype.makeSessionStateChange_ =
-    function(state, error, xmppError) {
+    function(state, opt_error) {
   var entry = new remoting.ChromotingEvent(
       remoting.ChromotingEvent.Type.SESSION_STATE);
-  entry.connection_error = error;
+
+  var ConnectionError = remoting.ChromotingEvent.ConnectionError;
+
+  if (!opt_error) {
+    entry.connection_error = ConnectionError.NONE;
+  } else if (opt_error instanceof remoting.Error) {
+    entry.setError(opt_error);
+  } else {
+    entry.connection_error = ConnectionError.UNKNOWN_ERROR;
+  }
+
   entry.session_state = state;
 
-  if (Boolean(xmppError)) {
-    entry.xmpp_error = xmppError;
-  }
-
   this.fillEvent_(entry);
   return entry;
 };
 
 /**
  * @return {remoting.ChromotingEvent}
  * @private
  */
 remoting.SessionLogger.prototype.makeSessionIdNew_ = function() {
   var entry = new remoting.ChromotingEvent(
@@ skipping 65 matching lines @@
   entry.session_duration = sessionDurationInSeconds;
   if (Boolean(this.connectionType_)) {
     entry.connection_type = this.connectionType_;
   }
   if (this.hostStatusUpdateElapsedTime_ != undefined) {
     entry.host_status_update_elapsed_time = this.hostStatusUpdateElapsedTime_;
   }
   if (this.authMethod_ != undefined) {
     entry.auth_method = this.authMethod_;
   }
-  if (Boolean(this.pluginError_)) {
-    entry.raw_plugin_error = this.pluginError_;
-  }
   entry.host_version = this.hostVersion_;
   entry.host_os = this.hostOs_;
   entry.host_os_version = this.hostOsVersion_;
 };
 
 /**
  * Sends a log entry to the server.
  *
  * @param {remoting.ChromotingEvent} entry
  * @private
@@ skipping 47 matching lines @@
   }
 };
 
 /** @return {remoting.SessionLogger} */
 remoting.SessionLogger.createForClient = function() {
   return new remoting.SessionLogger(remoting.ChromotingEvent.Role.CLIENT,
                                     remoting.TelemetryEventWriter.Client.write);
 };
 
 /**
- * TODO(kelvinp): Consolidate the two enums (crbug.com/504200)
- * @param {remoting.ClientSession.State} state
- * @return {remoting.ChromotingEvent.SessionState}
- */
-function toSessionState(state) {
-  var SessionState = remoting.ChromotingEvent.SessionState;
-  switch(state) {
-    case remoting.ClientSession.State.UNKNOWN:
-      return SessionState.UNKNOWN;
-    case remoting.ClientSession.State.INITIALIZING:
-      return SessionState.INITIALIZING;
-    case remoting.ClientSession.State.CONNECTING:
-      return SessionState.CONNECTING;
-    case remoting.ClientSession.State.AUTHENTICATED:
-      return SessionState.AUTHENTICATED;
-    case remoting.ClientSession.State.CONNECTED:
-      return SessionState.CONNECTED;
-    case remoting.ClientSession.State.CLOSED:
-      return SessionState.CLOSED;
-    case remoting.ClientSession.State.FAILED:
-      return SessionState.CONNECTION_FAILED;
-    case remoting.ClientSession.State.CONNECTION_DROPPED:
-      return SessionState.CONNECTION_DROPPED;
-    case remoting.ClientSession.State.CONNECTION_CANCELED:
-      return SessionState.CONNECTION_CANCELED;
-    default:
-      throw new Error('Unknown session state : ' + state);
-  }
-}
-
-/**
  * @param {remoting.SignalStrategy.Type} type
  * @return {remoting.ChromotingEvent.SignalStrategyType}
  */
 function toSignalStrategyType(type) {
   switch (type) {
     case remoting.SignalStrategy.Type.XMPP:
       return remoting.ChromotingEvent.SignalStrategyType.XMPP;
     case remoting.SignalStrategy.Type.WCS:
       return remoting.ChromotingEvent.SignalStrategyType.WCS;
     default:
@@ skipping 41 matching lines @@
 }
 
 // The maximum age of a session ID, in milliseconds.
 remoting.SessionLogger.MAX_SESSION_ID_AGE = 24 * 60 * 60 * 1000;
 
 // The time over which to accumulate connection statistics before logging them
 // to the server, in milliseconds.
 remoting.SessionLogger.CONNECTION_STATS_ACCUMULATE_TIME = 60 * 1000;
 
 })();