Stops accumulating performance statistics on the Chrome App.

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() {
 
 'use strict';
 
 /**
  * |remoting.SessionLogger| is responsible for reporting telemetry entries for
  * a Chromoting session.
  *
  * @param {remoting.ChromotingEvent.Role} role
  * @param {function(!Object)} writeLogEntry
  *
  * @constructor
  */
 remoting.SessionLogger = function(role, writeLogEntry) {
   /** @private */
   this.role_ = role;
   /** @private */
   this.writeLogEntry_ = writeLogEntry;
   /** @private */
-  this.statsAccumulator_ = new remoting.StatsAccumulator();
-  /** @private */
   this.sessionId_ = '';
   /** @private */
   this.sessionIdGenerationTime_ = 0;
   /** @private */
   this.sessionStartTime_ = Date.now();
   /** @private */
   this.sessionEndTime_ = 0;
   /** @private {remoting.ChromotingEvent.ConnectionType} */
   this.connectionType_;
   /** @private {remoting.ChromotingEvent.SessionEntryPoint} */
@@ skipping 188 matching lines @@
   this.log_(entry);
 
   this.lastSessionEntry_ =
       /** @type {remoting.ChromotingEvent} */ (base.deepCopy(entry));
 
   // Update the session summary.
   if (remoting.ChromotingEvent.isEndOfSession(entry)) {
     this.sessionEndTime_ = Date.now();
   }
 
-  // Don't accumulate connection statistics across state changes.
-  this.logAccumulatedStatistics_();
-  this.statsAccumulator_.empty();
-
-    if (state == remoting.ChromotingEvent.SessionState.CLOSED ||
+  if (state == remoting.ChromotingEvent.SessionState.CLOSED ||
       state == remoting.ChromotingEvent.SessionState.CONNECTION_DROPPED) {
     this.flushFeatureTracker();
   }
 };
 
 /**
  * Logs connection statistics.
  *
- * @param {Object<number>} stats The connection statistics
+ * @param {remoting.ClientSession.PerfStats} 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_();
+  if (stats && remoting.ClientSession.PerfStats.hasValidField(stats)) {
+    this.maybeExpireSessionId_();
+    var entry = this.makeStats_(stats);
+    this.log_(entry);
   }
 };
 
 /**
  * Logs host and client dimensions.
  *
  * @param {{width: number, height: number}} hostSize
+ * @param {number} hostDpi
  * @param {{width: number, height: number}} clientPluginSize
+ * @param {number} clientDpi
  * @param {{width: number, height: number}} clientWindowSize
  * @param {boolean} clientFullscreen
  */
 remoting.SessionLogger.prototype.logScreenResolutions =
     function(hostSize, hostDpi, clientPluginSize, clientWindowSize, clientDpi,
              clientFullscreen) {
   this.maybeExpireSessionId_();
   var entry = this.makeScreenResolutions_(hostSize, hostDpi, clientPluginSize,
                                           clientWindowSize, clientDpi,
                                           clientFullscreen);
@@ skipping 22 matching lines @@
   }
 
   entry.session_state = state;
 
   this.fillEvent_(entry);
   return entry;
 };
 
 /**
  * @param {{width: number, height: number}} hostSize
+ * @param {number} hostDpi
  * @param {{width: number, height: number}} clientPluginSize
  * @param {{width: number, height: number}} clientWindowSize
+ * @param {number} clientDpi
  * @param {boolean} clientFullscreen
  * @return {remoting.ChromotingEvent}
  * @private
  */
 remoting.SessionLogger.prototype.makeScreenResolutions_ =
     function(hostSize, hostDpi, clientPluginSize, clientWindowSize, clientDpi,
              clientFullscreen) {
   var entry = new remoting.ChromotingEvent(
       remoting.ChromotingEvent.Type.SCREEN_RESOLUTIONS);
   entry.client_video_size = new remoting.ChromotingEvent.ScreenResolution(
@@ skipping 23 matching lines @@
  * @private
  */
 remoting.SessionLogger.prototype.makeSessionIdOld_ = function() {
   var entry = new remoting.ChromotingEvent(
       remoting.ChromotingEvent.Type.SESSION_ID_OLD);
   this.fillEvent_(entry);
   return entry;
 };
 
 /**
- * @return {remoting.ChromotingEvent}
+ * @param {!remoting.ClientSession.PerfStats} perfStats
+ * @return {!remoting.ChromotingEvent}
  * @private
  */
-remoting.SessionLogger.prototype.makeStats_ = function() {
-  var perfStats = this.statsAccumulator_.getPerfStats();
-  if (Boolean(perfStats)) {
-    var entry = new remoting.ChromotingEvent(
-        remoting.ChromotingEvent.Type.CONNECTION_STATISTICS);
-    this.fillEvent_(entry);
-    entry.video_bandwidth = perfStats.videoBandwidth;
-    entry.capture_latency = perfStats.captureLatency;
-    entry.encode_latency = perfStats.encodeLatency;
-    entry.decode_latency = perfStats.decodeLatency;
-    entry.render_latency = perfStats.renderLatency;
-    entry.roundtrip_latency = perfStats.roundtripLatency;
-    entry.max_capture_latency = perfStats.maxCaptureLatency;
-    entry.max_encode_latency = perfStats.maxEncodeLatency;
-    entry.max_decode_latency = perfStats.maxDecodeLatency;
-    entry.max_render_latency = perfStats.maxRenderLatency;
-    entry.max_roundtrip_latency = perfStats.maxRoundtripLatency;
-    return entry;
-  }
-  return null;
+remoting.SessionLogger.prototype.makeStats_ = function(perfStats) {
+  var entry = new remoting.ChromotingEvent(
+      remoting.ChromotingEvent.Type.CONNECTION_STATISTICS);
+  this.fillEvent_(entry);
+  entry.video_bandwidth = perfStats.videoBandwidth;
+  entry.capture_latency = perfStats.captureLatency;
+  entry.encode_latency = perfStats.encodeLatency;
+  entry.decode_latency = perfStats.decodeLatency;
+  entry.render_latency = perfStats.renderLatency;
+  entry.roundtrip_latency = perfStats.roundtripLatency;
+  entry.max_capture_latency = perfStats.maxCaptureLatency;
+  entry.max_encode_latency = perfStats.maxEncodeLatency;
+  entry.max_decode_latency = perfStats.maxDecodeLatency;
+  entry.max_render_latency = perfStats.maxRenderLatency;
+  entry.max_roundtrip_latency = perfStats.maxRoundtripLatency;
+  return entry;
 };
 
-/**
- * Moves connection statistics from the accumulator to the log server.
- *
- * If all the statistics are zero, then the accumulator is still emptied,
- * but the statistics are not sent to the log server.
- *
- * @private
- */
-remoting.SessionLogger.prototype.logAccumulatedStatistics_ = function() {
-  var entry = this.makeStats_();
-  if (entry) {
-    this.log_(entry);
-  }
-  this.statsAccumulator_.empty();
-};
 
 /**
  * @param {remoting.ChromotingEvent} entry
  * @private
  */
 remoting.SessionLogger.prototype.fillEvent_ = function(entry) {
   entry.session_id = this.sessionId_;
   entry.mode = this.mode_;
   entry.role = this.role_;
   entry.session_entry_point = this.entryPoint_;
@@ skipping 144 matching lines @@
     case 'relay':
       return remoting.ChromotingEvent.ConnectionType.RELAY;
     default:
       throw new Error('Unknown ConnectionType :=' + type);
   }
 }
 
 // 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;
-
 })();