Log signal strategy progress to server.

remoting/webapp/crd/js/server_log_entry.js

 // Copyright (c) 2012 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
  * A class of server log entries.
  *
  * Any changes to the values here need to be coordinated with the host and
  * server/log proto code.
@@ skipping 11 matching lines @@
  */
 remoting.ServerLogEntry = function() {
   /** @type Object.<string, string> */ this.dict = {};
 };
 
 /** @private */
 remoting.ServerLogEntry.KEY_EVENT_NAME_ = 'event-name';
 /** @private */
 remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_STATE_ = 'session-state';
 /** @private */
+remoting.ServerLogEntry.VALUE_EVENT_NAME_SIGNAL_STRATEGY_PROGRESS_ =
+    'signal-strategy-progress';
+/** @private */
 remoting.ServerLogEntry.KEY_SESSION_ID_ = 'session-id';
 /** @private */
 remoting.ServerLogEntry.KEY_ROLE_ = 'role';
 /** @private */
 remoting.ServerLogEntry.VALUE_ROLE_CLIENT_ = 'client';
 /** @private */
 remoting.ServerLogEntry.KEY_SESSION_STATE_ = 'session-state';
 /** @private */
 remoting.ServerLogEntry.KEY_CONNECTION_TYPE_ = 'connection-type';
+/** @private */
+remoting.ServerLogEntry.KEY_SIGNAL_STRATEGY_TYPE_ = 'signal-strategy-type';
+/** @private */
+remoting.ServerLogEntry.KEY_SIGNAL_STRATEGY_PROGRESS_ =
+    'signal-strategy-progress';
+/** @private */
+remoting.ServerLogEntry.KEY_SIGNAL_STRATEGY_ELAPSED_TIME_ =
+    'signal-strategy-elapsed-time';
 
 /**
  * @private
  * @param {remoting.ClientSession.State} state
  * @return {string}
  */
-remoting.ServerLogEntry.getValueForSessionState = function(state) {
+remoting.ServerLogEntry.getValueForSessionState_ = function(state) {
   switch(state) {
     case remoting.ClientSession.State.UNKNOWN:
       return 'unknown';
     case remoting.ClientSession.State.CREATED:
       return 'created';
     case remoting.ClientSession.State.CONNECTING:
       return 'connecting';
     case remoting.ClientSession.State.INITIALIZING:
       return 'initializing';
     case remoting.ClientSession.State.CONNECTED:
@@ skipping 12 matching lines @@
 };
 
 /** @private */
 remoting.ServerLogEntry.KEY_CONNECTION_ERROR_ = 'connection-error';
 
 /**
  * @private
  * @param {remoting.Error} connectionError
  * @return {string}
  */
-remoting.ServerLogEntry.getValueForError =
-    function(connectionError) {
+remoting.ServerLogEntry.getValueForError_ = function(connectionError) {
   // Directory service should be updated if a new string is added here as
   // otherwise the error code will be ignored (i.e. recorded as 0 instead).
   switch(connectionError) {
     case remoting.Error.NONE:
       return 'none';
     case remoting.Error.INVALID_ACCESS_CODE:
       return 'invalid-access-code';
     case remoting.Error.MISSING_PLUGIN:
       return 'missing_plugin';
     case remoting.Error.AUTHENTICATION_FAILED:
@@ skipping 76 matching lines @@
 /** @private */
 remoting.ServerLogEntry.VALUE_MODE_UNKNOWN_ = 'unknown';
 
 /**
  * Sets one field in this log entry.
  *
  * @private
  * @param {string} key
  * @param {string} value
  */
-remoting.ServerLogEntry.prototype.set = function(key, value) {
+remoting.ServerLogEntry.prototype.set_ = function(key, value) {
   this.dict[key] = value;
 };
 
 /**
  * Converts this object into an XML stanza.
  *
  * @return {string}
  */
 remoting.ServerLogEntry.prototype.toStanza = function() {
   var stanza = '<gr:entry ';
@@ skipping 21 matching lines @@
  * Makes a log entry for a change of client session state.
  *
  * @param {remoting.ClientSession.State} state
  * @param {remoting.Error} connectionError
  * @param {remoting.ClientSession.Mode} mode
  * @return {remoting.ServerLogEntry}
  */
 remoting.ServerLogEntry.makeClientSessionStateChange = function(state,
     connectionError, mode) {
   var entry = new remoting.ServerLogEntry();
-  entry.set(remoting.ServerLogEntry.KEY_ROLE_,
-            remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
-  entry.set(remoting.ServerLogEntry.KEY_EVENT_NAME_,
-            remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_STATE_);
-  entry.set(remoting.ServerLogEntry.KEY_SESSION_STATE_,
-            remoting.ServerLogEntry.getValueForSessionState(state));
+  entry.set_(remoting.ServerLogEntry.KEY_ROLE_,
+             remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
+  entry.set_(remoting.ServerLogEntry.KEY_EVENT_NAME_,
+             remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_STATE_);
+  entry.set_(remoting.ServerLogEntry.KEY_SESSION_STATE_,
+             remoting.ServerLogEntry.getValueForSessionState_(state));
   if (connectionError != remoting.Error.NONE) {
-    entry.set(remoting.ServerLogEntry.KEY_CONNECTION_ERROR_,
-              remoting.ServerLogEntry.getValueForError(connectionError));
+    entry.set_(remoting.ServerLogEntry.KEY_CONNECTION_ERROR_,
+               remoting.ServerLogEntry.getValueForError_(connectionError));
   }
   entry.addModeField(mode);
   return entry;
 };
 
 /**
  * Adds a session duration to a log entry.
  *
  * @param {number} sessionDuration
  */
 remoting.ServerLogEntry.prototype.addSessionDurationField = function(
     sessionDuration) {
-  this.set(remoting.ServerLogEntry.KEY_SESSION_DURATION_,
-      sessionDuration.toString());
+  this.set_(remoting.ServerLogEntry.KEY_SESSION_DURATION_,
+            sessionDuration.toString());
 };
 
 /**
  * Makes a log entry for a set of connection statistics.
  * Returns null if all the statistics were zero.
  *
  * @param {remoting.StatsAccumulator} statsAccumulator
  * @param {string} connectionType
  * @param {remoting.ClientSession.Mode} mode
  * @return {?remoting.ServerLogEntry}
  */
 remoting.ServerLogEntry.makeStats = function(statsAccumulator,
                                              connectionType,
                                              mode) {
   var entry = new remoting.ServerLogEntry();
-  entry.set(remoting.ServerLogEntry.KEY_ROLE_,
-            remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
-  entry.set(remoting.ServerLogEntry.KEY_EVENT_NAME_,
-            remoting.ServerLogEntry.VALUE_EVENT_NAME_CONNECTION_STATISTICS_);
+  entry.set_(remoting.ServerLogEntry.KEY_ROLE_,
+             remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
+  entry.set_(remoting.ServerLogEntry.KEY_EVENT_NAME_,
+             remoting.ServerLogEntry.VALUE_EVENT_NAME_CONNECTION_STATISTICS_);
   if (connectionType) {
-    entry.set(remoting.ServerLogEntry.KEY_CONNECTION_TYPE_,
-              connectionType);
+    entry.set_(remoting.ServerLogEntry.KEY_CONNECTION_TYPE_,
+               connectionType);
   }
   entry.addModeField(mode);
   var nonZero = false;
-  nonZero |= entry.addStatsField(
+  nonZero |= entry.addStatsField_(
       remoting.ServerLogEntry.KEY_VIDEO_BANDWIDTH_,
       remoting.ClientSession.STATS_KEY_VIDEO_BANDWIDTH, statsAccumulator);
-  nonZero |= entry.addStatsField(
+  nonZero |= entry.addStatsField_(
       remoting.ServerLogEntry.KEY_CAPTURE_LATENCY_,
       remoting.ClientSession.STATS_KEY_CAPTURE_LATENCY, statsAccumulator);
-  nonZero |= entry.addStatsField(
+  nonZero |= entry.addStatsField_(
       remoting.ServerLogEntry.KEY_ENCODE_LATENCY_,
       remoting.ClientSession.STATS_KEY_ENCODE_LATENCY, statsAccumulator);
-  nonZero |= entry.addStatsField(
+  nonZero |= entry.addStatsField_(
       remoting.ServerLogEntry.KEY_DECODE_LATENCY_,
       remoting.ClientSession.STATS_KEY_DECODE_LATENCY, statsAccumulator);
-  nonZero |= entry.addStatsField(
+  nonZero |= entry.addStatsField_(
       remoting.ServerLogEntry.KEY_RENDER_LATENCY_,
       remoting.ClientSession.STATS_KEY_RENDER_LATENCY, statsAccumulator);
-  nonZero |= entry.addStatsField(
+  nonZero |= entry.addStatsField_(
       remoting.ServerLogEntry.KEY_ROUNDTRIP_LATENCY_,
       remoting.ClientSession.STATS_KEY_ROUNDTRIP_LATENCY, statsAccumulator);
   if (nonZero) {
     return entry;
   }
   return null;
 };
 
 /**
  * Adds one connection statistic to a log entry.
  *
  * @private
  * @param {string} entryKey
  * @param {string} statsKey
  * @param {remoting.StatsAccumulator} statsAccumulator
  * @return {boolean} whether the statistic is non-zero
  */
-remoting.ServerLogEntry.prototype.addStatsField = function(
+remoting.ServerLogEntry.prototype.addStatsField_ = function(
     entryKey, statsKey, statsAccumulator) {
   var val = statsAccumulator.calcMean(statsKey);
-  this.set(entryKey, val.toFixed(2));
+  this.set_(entryKey, val.toFixed(2));
   return (val != 0);
 };
 
 /**
  * Makes a log entry for a "this session ID is old" event.
  *
  * @param {string} sessionId
  * @param {remoting.ClientSession.Mode} mode
  * @return {remoting.ServerLogEntry}
  */
 remoting.ServerLogEntry.makeSessionIdOld = function(sessionId, mode) {
   var entry = new remoting.ServerLogEntry();
-  entry.set(remoting.ServerLogEntry.KEY_ROLE_,
-            remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
-  entry.set(remoting.ServerLogEntry.KEY_EVENT_NAME_,
-            remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_ID_OLD_);
+  entry.set_(remoting.ServerLogEntry.KEY_ROLE_,
+             remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
+  entry.set_(remoting.ServerLogEntry.KEY_EVENT_NAME_,
+             remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_ID_OLD_);
   entry.addSessionIdField(sessionId);
   entry.addModeField(mode);
   return entry;
 };
 
 /**
  * Makes a log entry for a "this session ID is new" event.
  *
  * @param {string} sessionId
  * @param {remoting.ClientSession.Mode} mode
  * @return {remoting.ServerLogEntry}
  */
 remoting.ServerLogEntry.makeSessionIdNew = function(sessionId, mode) {
   var entry = new remoting.ServerLogEntry();
-  entry.set(remoting.ServerLogEntry.KEY_ROLE_,
-            remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
-  entry.set(remoting.ServerLogEntry.KEY_EVENT_NAME_,
-            remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_ID_NEW_);
+  entry.set_(remoting.ServerLogEntry.KEY_ROLE_,
+             remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
+  entry.set_(remoting.ServerLogEntry.KEY_EVENT_NAME_,
+             remoting.ServerLogEntry.VALUE_EVENT_NAME_SESSION_ID_NEW_);
   entry.addSessionIdField(sessionId);
   entry.addModeField(mode);
   return entry;
 };
 
 /**
+ * Makes a log entry for a "signal strategy fallback" event.
+ *
+ * @param {string} sessionId
+ * @param {remoting.SignalStrategy.Type} strategyType
+ * @param {remoting.FallbackSignalStrategy.Progress} progress
+ * @param {number} elapsedTimeInMs
+ * @return {remoting.ServerLogEntry}
+ */
+remoting.ServerLogEntry.makeSignalStrategyProgress =
+    function(sessionId, strategyType, progress, elapsedTimeInMs) {
+  var entry = new remoting.ServerLogEntry();
+  entry.set_(remoting.ServerLogEntry.KEY_ROLE_,
+             remoting.ServerLogEntry.VALUE_ROLE_CLIENT_);
+  entry.set_(
+      remoting.ServerLogEntry.KEY_EVENT_NAME_,
+      remoting.ServerLogEntry.VALUE_EVENT_NAME_SIGNAL_STRATEGY_PROGRESS_);
+  entry.addSessionIdField(sessionId);
+  entry.set_(remoting.ServerLogEntry.KEY_SIGNAL_STRATEGY_TYPE_, strategyType);
+  entry.set_(remoting.ServerLogEntry.KEY_SIGNAL_STRATEGY_PROGRESS_, progress);
+  entry.set_(remoting.ServerLogEntry.KEY_SIGNAL_STRATEGY_ELAPSED_TIME_,
+             String(elapsedTimeInMs));
+
+  return entry;
+};
+
+/**
  * Adds a session ID field to this log entry.
  *
  * @param {string} sessionId
  */
 remoting.ServerLogEntry.prototype.addSessionIdField = function(sessionId) {
-  this.set(remoting.ServerLogEntry.KEY_SESSION_ID_, sessionId);
+  this.set_(remoting.ServerLogEntry.KEY_SESSION_ID_, sessionId);
 }
 
 /**
  * Adds fields describing the host to this log entry.
  */
 remoting.ServerLogEntry.prototype.addHostFields = function() {
-  var host = remoting.ServerLogEntry.getHostData();
+  var host = remoting.ServerLogEntry.getHostData_();
   if (host) {
     if (host.os_name.length > 0) {
-      this.set(remoting.ServerLogEntry.KEY_OS_NAME_, host.os_name);
+      this.set_(remoting.ServerLogEntry.KEY_OS_NAME_, host.os_name);
     }
     if (host.os_version.length > 0) {
-      this.set(remoting.ServerLogEntry.KEY_OS_VERSION_, host.os_version);
+      this.set_(remoting.ServerLogEntry.KEY_OS_VERSION_, host.os_version);
     }
     if (host.cpu.length > 0) {
-      this.set(remoting.ServerLogEntry.KEY_CPU_, host.cpu);
+      this.set_(remoting.ServerLogEntry.KEY_CPU_, host.cpu);
     }
   }
 };
 
 /**
  * Extracts host data from the userAgent string.
  *
  * @private
  * @return {{os_name:string, os_version:string, cpu:string} | null}
  */
-remoting.ServerLogEntry.getHostData = function() {
-  return remoting.ServerLogEntry.extractHostDataFrom(navigator.userAgent);
+remoting.ServerLogEntry.getHostData_ = function() {
+  return remoting.ServerLogEntry.extractHostDataFrom_(navigator.userAgent);
 };
 
 /**
  * Extracts host data from the given userAgent string.
  *
  * @private
  * @param {string} s
  * @return {{os_name:string, os_version:string, cpu:string} | null}
  */
-remoting.ServerLogEntry.extractHostDataFrom = function(s) {
+remoting.ServerLogEntry.extractHostDataFrom_ = function(s) {
   // Sample userAgent strings:
   // 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.2 ' +
   //   '(KHTML, like Gecko) Chrome/15.0.874.106 Safari/535.2'
   // 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.8 ' +
   //   '(KHTML, like Gecko) Chrome/17.0.933.0 Safari/535.8'
   // 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/535.1 ' +
   //   '(KHTML, like Gecko) Chrome/14.0.835.202 Safari/535.1'
   // 'Mozilla/5.0 (X11; CrOS i686 14.811.154) AppleWebKit/535.1 ' +
   //   '(KHTML, like Gecko) Chrome/14.0.835.204 Safari/535.1'
   var match = new RegExp('Windows NT ([0-9\\.]*)').exec(s);
@@ skipping 30 matching lines @@
   }
   return null;
 };
 
 /**
  * Adds a field specifying the browser version to this log entry.
  */
 remoting.ServerLogEntry.prototype.addChromeVersionField = function() {
   var version = remoting.getChromeVersion();
   if (version != null) {
-    this.set(remoting.ServerLogEntry.KEY_BROWSER_VERSION_, version);
+    this.set_(remoting.ServerLogEntry.KEY_BROWSER_VERSION_, version);
   }
 };
 
 /**
  * Adds a field specifying the webapp version to this log entry.
  */
 remoting.ServerLogEntry.prototype.addWebappVersionField = function() {
   var manifest = chrome.runtime.getManifest();
   if (manifest && manifest.version) {
-    this.set(remoting.ServerLogEntry.KEY_WEBAPP_VERSION_, manifest.version);
+    this.set_(remoting.ServerLogEntry.KEY_WEBAPP_VERSION_, manifest.version);
   }
 };
 
 /**
  * Adds a field specifying the mode to this log entry.
  *
  * @param {remoting.ClientSession.Mode} mode
  */
 remoting.ServerLogEntry.prototype.addModeField = function(mode) {
-  this.set(remoting.ServerLogEntry.KEY_MODE_,
-      remoting.ServerLogEntry.getModeField(mode));
+  this.set_(remoting.ServerLogEntry.KEY_MODE_,
+            remoting.ServerLogEntry.getModeField_(mode));
 };
 
 /**
  * Gets the value of the mode field to be put in a log entry.
  *
  * @private
  * @param {remoting.ClientSession.Mode} mode
  * @return {string}
  */
-remoting.ServerLogEntry.getModeField = function(mode) {
+remoting.ServerLogEntry.getModeField_ = function(mode) {
   switch(mode) {
     case remoting.ClientSession.Mode.IT2ME:
       return remoting.ServerLogEntry.VALUE_MODE_IT2ME_;
     case remoting.ClientSession.Mode.ME2ME:
       return remoting.ServerLogEntry.VALUE_MODE_ME2ME_;
     case remoting.ClientSession.Mode.APP_REMOTING:
       return remoting.ServerLogEntry.VALUE_MODE_APP_REMOTING_;
     default:
       return remoting.ServerLogEntry.VALUE_MODE_UNKNOWN_;
   }
 };