Limit the number of captured events held by about:net-internals.

chrome/browser/resources/net_internals/events_tracker.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.
 
 var EventsTracker = (function() {
   'use strict';
 
   /**
    * This class keeps track of all NetLog events.
    * It receives events from the browser and when loading a log file, and passes
    * them on to all its observers.
    *
    * @constructor
    */
   function EventsTracker() {
     assertFirstConstructorCall(EventsTracker);
 
     this.capturedEvents_ = [];
     this.observers_ = [];
+
+    // Controls how large |capturedEvents_| can grow.
+    this.softLimit_ = Infinity;
+    this.hardLimit_ = Infinity;
   }
 
   cr.addSingletonGetter(EventsTracker);
 
   EventsTracker.prototype = {
     /**
      * Returns a list of all captured events.
      */
     getAllCapturedEvents: function() {
       return this.capturedEvents_;
@@ skipping 16 matching lines @@
     },
 
     /**
      * Adds captured events, and broadcasts them to any observers.
      */
     addLogEntries: function(logEntries) {
       this.capturedEvents_ = this.capturedEvents_.concat(logEntries);
       for (var i = 0; i < this.observers_.length; ++i) {
         this.observers_[i].onReceivedLogEntries(logEntries);
       }
+
+      // Check that we haven't grown too big. If so, toss out older events.
+      if (this.getNumCapturedEvents() >  this.hardLimit_) {

[mmenke, 2012/03/06 15:21:18]

nit:  Remove extra space.

[eroman, 2012/03/06 17:14:14]

Done.

+        var originalEvents = this.capturedEvents_;
+        this.deleteAllLogEntries();
+        // Delete the oldest events until we reach the soft limit.
+        originalEvents.splice(0, originalEvents.length - this.softLimit_);
+        this.addLogEntries(originalEvents);
+      }
     },
 
     /**
      * Adds a listener of log entries. |observer| will be called back when new
      * log data arrives or all entries are deleted:
      *
      *   observer.onReceivedLogEntries(entries)
      *   observer.onAllLogEntriesDeleted()
      */
     addLogEntryObserver: function(observer) {
       this.observers_.push(observer);
+    },
+
+    /**
+     * Set bounds on the maximum number of events that will be tracked. This
+     * helps to bound the total amount of memory usage, since otherwise
+     * long-running capture sessions can exhaust the renderer's memory and
+     * crash.
+     *
+     * Once |hardLimit| number of events have been captured we do a garbage
+     * collection and toss out old events, bringing our count down to
+     * |softLimit|.
+     *
+     * To log observers this will look like all the events got deleted, and
+     * then subsequently a bunch of new events were received. In other words, it
+     * behaves the same as if the user had simply started logging a bit later
+     * in time!
+     */
+    setLimits: function(softLimit, hardLimit) {
+      if (hardLimit != Infinity && softLimit >= hardLimit)
+        throw 'hardLimit must be greater than softLimit';
+
+      this.softLimit_ = softLimit;
+      this.hardLimit_ = hardLimit;
     }
   };
 
   return EventsTracker;
 })();