Add a timeline view to about:net-internals.

chrome/test/data/webui/net_internals/net_internals_test.js

 // Copyright (c) 2011 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 The way these tests work is as follows:
  * C++ in net_internals_ui_browsertest.cc does any necessary setup, and then
  * calls the entry point for a test with RunJavascriptTest.  The called
  * function can then use the assert/expect functions defined in test_api.js.
  * All callbacks from the browser are wrapped in such a way that they can
@@ skipping 17 matching lines @@
   /**
    * Map of tab handle names to location hashes.
    * @type {object.<string, string>}
    */
   var hashToTabHandleIdMap = {
     capture: CaptureView.TAB_HANDLE_ID,
     export: ExportView.TAB_HANDLE_ID,
     import: ImportView.TAB_HANDLE_ID,
     proxy: ProxyView.TAB_HANDLE_ID,
     events: EventsView.TAB_HANDLE_ID,
+    timeline: TimelineView.TAB_HANDLE_ID,
     dns: DnsView.TAB_HANDLE_ID,
     sockets: SocketsView.TAB_HANDLE_ID,
     spdy: SpdyView.TAB_HANDLE_ID,
     httpCache: HttpCacheView.TAB_HANDLE_ID,
     httpThrottling: HttpThrottlingView.TAB_HANDLE_ID,
     serviceProviders: ServiceProvidersView.TAB_HANDLE_ID,
     tests: TestView.TAB_HANDLE_ID,
     hsts: HSTSView.TAB_HANDLE_ID,
     logs: LogsView.TAB_HANDLE_ID,
     prerender: PrerenderView.TAB_HANDLE_ID
@@ skipping 263 matching lines @@
      * Adds a Task to the end of the queue.  Each Task may only be added once
      * to a single queue.
      * @param {Task}: task The Task to add.
      */
     addTask: function(task) {
       this.tasks_.push(task);
       task.setTaskQueue_(this);
     },
 
     /**
+     * Adds a Task to the end of the queue.  The task will call the provided
+     * function, and then complete.
+     * @param {function}: taskFunction The function the task will call.
+     */
+    addFunctionTask: function(taskFunction) {
+      this.addTask(new CallFunctionTask(taskFunction));
+    },
+
+    /**
      * Starts running the Tasks in the queue.  Once called, may not be called
      * again.
      */
     run: function() {
       assertFalse(this.isRunning_);
       this.isRunning_ = true;
       this.runNextTask_();
     },
 
     /**
@@ skipping 53 matching lines @@
      * task.  Runs the next task, if any.
      */
     onTaskDone: function() {
       assertFalse(this.isDone_);
       this.isDone_ = true;
       this.taskQueue_.runNextTask_();
     }
   };
 
   /**
+   * A Task that can be added to a TaskQueue.  A Task is started with a call to
+   * the start function, and must call its own onTaskDone when complete.
+   * @constructor
+   */
+  function CallFunctionTask(taskFunction) {
+    Task.call(this);
+    assertEquals('function', typeof taskFunction);
+    this.taskFunction_ = taskFunction;
+  }
+
+  CallFunctionTask.prototype = {
+    __proto__: Task.prototype,
+
+    /**
+     * Runs the function and then completes.
+     */
+    start: function() {
+      this.taskFunction_();
+      this.onTaskDone();
+    }
+  };
+
+  /**
    * Returns true if a node does not have a 'display' property of 'none'.
    * @param {node}: node The node to check.
    */
   function isDisplayed(node) {
     var style = getComputedStyle(node);
     return style.getPropertyValue('display') != 'none';
   }
 
+  /**
+   * Creates a new NetLog source.  Note that the id may conflict with events
+   * received from the browser.
+   * @param {int}: type The source type.
+   * @param {int}: id The source id.
+   * @constructor
+   */
+  function Source(type, id) {
+    assertNotEquals(getKeyWithValue(LogSourceType, type), '?');
+    assertGE(id, 0);
+    this.type = type;
+    this.id = id;
+  }
+
+  /**
+   * Creates a new NetLog event.
+   * @param {Source}: source The source associated with the event.
+   * @param {int}: type The event id.
+   * @param {int}: time When the event occurred.
+   * @param {int}: phase The event phase.
+   * @param {object}: params The event parameters.  May be null.
+   * @constructor
+   */
+  function Event(source, type, time, phase, params) {
+    assertNotEquals(getKeyWithValue(LogEventType, type), '?');
+    assertNotEquals(getKeyWithValue(LogEventPhase, phase), '?');
+
+    this.source = source;
+    this.phase = phase;
+    this.type = type;
+    this.time = "" + time;
+    this.phase = phase;
+    if (params)
+      this.params = params;
+  }
+
+  /**
+   * Creates a new NetLog begin event.  Parameters are the same as Event,
+   * except there's no |phase| argument.
+   * @see Event
+   */
+  function CreateBeginEvent(source, type, time, params) {
+    return new Event(source, type, time,  LogEventPhase.PHASE_BEGIN, params);
+  }
+
+  /**
+   * Creates a new NetLog end event.  Parameters are the same as Event,
+   * except there's no |phase| argument.
+   * @see Event
+   */
+  function CreateEndEvent(source, type, time, params) {
+    return new Event(source, type, time,  LogEventPhase.PHASE_END, params);
+  }
+
+  /**
+   * Creates a new NetLog end event matching the given begin event.
+   * @param {Event}: beginEvent The begin event.  Returned event will have the
+   *                 same source and type.
+   * @param {int}: time When the event occurred.
+   * @param {object}: params The event parameters.  May be null.
+   * @see Event
+   */
+  function CreateMatchingEndEvent(beginEvent, time, params) {
+    return CreateEndEvent(beginEvent.source, beginEvent.type, time, params);
+  }
+
   // Exported functions.
   return {
     test: test,
     checkStyledTableRows: checkStyledTableRows,
     checkTabHandleVisibility: checkTabHandleVisibility,
     getStyledTableText: getStyledTableText,
     isDisplayed: isDisplayed,
     runTest: runTest,
     switchToView: switchToView,
+    TaskQueue: TaskQueue,
     Task: Task,
-    TaskQueue: TaskQueue
+    Source: Source,
+    Event: Event,
+    CreateBeginEvent: CreateBeginEvent,
+    CreateEndEvent: CreateEndEvent,
+    CreateMatchingEndEvent: CreateMatchingEndEvent
   };
 })();
 
 netInternalsTest.test('netInternalsDone', function() {
   testDone();
 });
 
 netInternalsTest.test('netInternalsExpectFail', function() {
   expectNotReached();
 });
@@ skipping 51 matching lines @@
   HostResolverInfoObserver.prototype.onHostResolverInfoChanged = function() {
     assertNotReached();
   };
 
   // Create the observer and add it to |g_browser|.
   g_browser.addHostResolverInfoObserver(new HostResolverInfoObserver());
 
   // Needed to trigger an update.
   netInternalsTest.switchToView('dns');
 });