Display active media players on chrome://media-internals.

chrome/browser/resources/media_internals/media_internals.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.
 
 <include src="cache_entry.js"/>
+<include src="disjoint_range_set.js"/>
+<include src="event_list.js"/>
 <include src="item_store.js"/>
-<include src="disjoint_range_set.js"/>
+<include src="media_player.js"/>
+<include src="metrics.js"/>
+<include src="util.js"/>
 
 cr.define('media', function() {
 
   // Stores information on open audio streams, referenced by id.
   var audioStreams = new media.ItemStore;
 
+  // Active media players, indexed by 'render_id:player_id'.
+  var mediaPlayers = {};
+
   // Cached files indexed by key and source id.
   var cacheEntriesByKey = {};
   var cacheEntries = {};
 
   // Map of event source -> url.
   var requestURLs = {};
 
   // Constants passed to us from Chrome.
   var eventTypes = {};
   var eventPhases = {};
 
   // The <div>s on the page in which to display information.
   var audioStreamDiv;
   var cacheDiv;
+  var mediaPlayerDiv;
+
+  // A timer used to limit the rate of redrawing the Media Players section.
+  var redrawTimer = null;
 
   /**
    * Initialize variables and ask MediaInternals for all its data.
    */
   initialize = function() {
     audioStreamDiv = document.getElementById('audio-streams');
     cacheDiv = document.getElementById('cache-entries');
+    mediaPlayerDiv = document.getElementById('media-players');
+
     // Get information about all currently active media.
     chrome.send('getEverything');
   };
 
   /**
    * Write the set of audio streams to the DOM.
    */
   printAudioStreams = function() {
 
     /**
@@ skipping 16 matching lines @@
     var out = document.createElement('ul');
     audioStreams.map(printStream).forEach(function(s) {
       out.appendChild(s)
     });
 
     audioStreamDiv.textContent = '';
     audioStreamDiv.appendChild(out);
   };
 
   /**
+   * Write the set of media players to the DOM.
+   */
+  printMediaPlayers = function() {

[arv (Not doing code reviews), 2011/08/16 19:29:03]

missing var here and in other places

[Scott Franklin, 2011/08/16 23:33:52]

Done.

+    var out = document.createElement('ul');
+    for (id in mediaPlayers)

[arv (Not doing code reviews), 2011/08/16 19:29:03]

missing var

Maybe you should swith to strict mode to catch theses errors?

cr.define('media', function() {
  'use strict';

  ...
});

[Scott Franklin, 2011/08/16 23:33:52]

Done.

+      out.appendChild(mediaPlayers[id].toListItem());
+
+    mediaPlayerDiv.textContent = '';
+    mediaPlayerDiv.appendChild(out);
+
+    redrawTimer = null;
+  };
+
+  /**
    * Write the set of sparse CacheEntries to the DOM.
    */
   printSparseCacheEntries = function() {
     var out = document.createElement('ul');
     for (var key in cacheEntriesByKey) {
       if (cacheEntriesByKey[key].sparse)
         out.appendChild(cacheEntriesByKey[key].toListItem());
     }
 
     cacheDiv.textContent = '';
@@ skipping 22 matching lines @@
   };
 
   /**
    * Removing an item from the appropriate store.
    * @param {string} id The id of the item to be removed, in the format
    *    "item_type.identifying_info".
    */
   onItemDeleted = function(id) {
     var type = id.split('.')[0];
     switch (type) {
     case 'audio_streams':

[arv (Not doing code reviews), 2011/08/16 19:29:03]

indent

[Scott Franklin, 2011/08/16 23:33:52]

Done.

       audioStreams.removeItem(id);
       printAudioStreams();
       break;
     }
   };
 
   /**
+   * A render process has ended, delete any media players associated with it.
+   * @param {int} renderer The id of the render process.
+   */
+  onRendererTerminated = function(renderer) {
+    for (var key in mediaPlayers) {
+      if (mediaPlayers[key].renderer == renderer)
+        delete mediaPlayers[key];
+    }
+    printMediaPlayers();
+  };
+
+  /**
    * Receiving net events.
    * Update cache information and update that section of the page.
    * @param {Array} updates A list of net events that have occurred.
    */
   onNetUpdate = function(updates) {
     updates.forEach(function(update) {
       var id = update.source.id;
       if (!cacheEntries[id])
         cacheEntries[id] = new media.CacheEntry;
 
@@ skipping 28 matching lines @@
         break;
 
       case 'PHASE_NONE.HTTP_TRANSACTION_READ_RESPONSE_HEADERS':
         // Record the total size of the file if this was a range request.
         var range = /content-range:\s*bytes\s*\d+-\d+\/(\d+)/i.exec(
             update.params.headers);
         var key = requestURLs[update.source.id];
         delete requestURLs[update.source.id];
         if (range && key) {
           if (!cacheEntriesByKey[key]) {
-            cacheEntriesByKey[key] = new CacheEntry;
+            cacheEntriesByKey[key] = new media.CacheEntry;
             cacheEntriesByKey[key].key = key;
           }
           cacheEntriesByKey[key].size = range[1];
         }
         break;
       }
     });
 
     printSparseCacheEntries();
   };
 
   /**
    * Receiving values for constants. Store them for later use.
    * @param {Object} constants A dictionary of constants.
    * @param {Object} constants.eventTypes A dictionary of event name -> int.
    * @param {Object} constants.eventPhases A dictionary of event phase -> int.
    */
   onReceiveConstants = function(constants) {
     var events = constants.eventTypes;
     for (var e in events)
       eventTypes[events[e]] = e;
 
     var phases = constants.eventPhases;
     for (var p in phases)
       eventPhases[phases[p]] = p;
   };
 
+  /**
+   * Receiving notification of a media event.
+   * @param {Object} event The json representation of a MediaLog::Event.
+   */
+  onMediaEvent = function(event) {
+    // List everything in miliseconds.
+    event.time *= 1000;
+
+    var source = event.renderer + ':' + event.player;
+    var item = mediaPlayers[source] ||
+        new media.MediaPlayer(source, event.renderer);
+    mediaPlayers[source] = item;
+    item.addEvent(event);
+
+    // Both media and net events could provide the size of the file.
+    // Media takes priority, but keep the size in both places synchronized.
+    if (cacheEntriesByKey[item.properties.url]) {
+      item.properties.total_bytes = item.properties.total_bytes ||
+                                    cacheEntriesByKey[item.properties.url].size;
+      cacheEntriesByKey[item.properties.url].size = item.properties.total_bytes;
+    }
+
+    // Events tend to arrive in groups; don't redraw the page too often.
+    if (!redrawTimer)
+      redrawTimer = setTimeout("printMediaPlayers()", 50);

[arv (Not doing code reviews), 2011/08/16 19:29:03]

Don't use string based setTimout since it is a global eval.

redrawTimer = setTimeout(printMediaPlayers, 50);

[Scott Franklin, 2011/08/16 23:33:52]

Done.

+  };
+
   return {
     initialize: initialize,
     addAudioStream: addAudioStream,
+    cacheEntriesByKey: cacheEntriesByKey,
     onReceiveEverything: onReceiveEverything,
     onItemDeleted: onItemDeleted,
+    onRendererTerminated: onRendererTerminated,
     onNetUpdate: onNetUpdate,
     onReceiveConstants: onReceiveConstants,
+    onMediaEvent: onMediaEvent,
   };
 });
 
 /**
  * Initialize everything once we have access to the DOM.
  */
 window.onload = function() {
   media.initialize();
 };