Save net-internals log dumps directly to disk.

chrome/browser/resources/net_internals/dataview.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.
 
 /**
  * This view displays options for importing/exporting the captured data. Its
  * primarily usefulness is to allow users to copy-paste their data in an easy
  * to read format for bug reports.
  *
  *   - Has a button to generate a text report.
  *
  *   - Shows how many events have been captured.
  *  @constructor
  */
 function DataView(mainBoxId,
-                  outputTextBoxId,
-                  exportTextButtonId,
+                  downloadIframeId,
+                  exportFileButtonId,
                   securityStrippingCheckboxId,
                   byteLoggingCheckboxId,
                   passivelyCapturedCountId,
                   activelyCapturedCountId,
                   deleteAllId,
                   dumpDataDivId,
                   loadDataDivId,
                   loadLogFileId,
                   capturingTextSpanId,
                   loggingTextSpanId) {
   DivView.call(this, mainBoxId);
 
-  this.textPre_ = document.getElementById(outputTextBoxId);
-
   var securityStrippingCheckbox =
       document.getElementById(securityStrippingCheckboxId);
   securityStrippingCheckbox.onclick =
       this.onSetSecurityStripping_.bind(this, securityStrippingCheckbox);
 
   var byteLoggingCheckbox = document.getElementById(byteLoggingCheckboxId);
   byteLoggingCheckbox.onclick =
       this.onSetByteLogging_.bind(this, byteLoggingCheckbox);
 
-  var exportTextButton = document.getElementById(exportTextButtonId);
-  exportTextButton.onclick = this.onExportToText_.bind(this);
+  this.downloadIframe_ = document.getElementById(downloadIframeId);
+
+  this.exportFileButton_ = document.getElementById(exportFileButtonId);
+  this.exportFileButton_.onclick = this.onExportToText_.bind(this);
 
   this.activelyCapturedCountBox_ =
       document.getElementById(activelyCapturedCountId);
   this.passivelyCapturedCountBox_ =
       document.getElementById(passivelyCapturedCountId);
   document.getElementById(deleteAllId).onclick =
       g_browser.deleteAllEvents.bind(g_browser);
 
   this.dumpDataDiv_ = document.getElementById(dumpDataDivId);
   this.loadDataDiv_ = document.getElementById(loadDataDivId);
   this.capturingTextSpan_ = document.getElementById(capturingTextSpanId);
   this.loggingTextSpan_ = document.getElementById(loggingTextSpanId);
 
   var loadLogFileElement = document.getElementById(loadLogFileId);
   loadLogFileElement.onchange =
       this.logFileChanged.bind(this, loadLogFileElement);
 
   this.updateEventCounts_();
-  this.waitingForUpdate_ = false;
 
   g_browser.addLogObserver(this);
 }
 
 inherits(DataView, DivView);
 
 /**
  * Called whenever a new event is received.
  */
 DataView.prototype.onLogEntryAdded = function(logEntry) {
@@ skipping 17 matching lines @@
 
 /**
  * Called when either a log file is loaded or when going back to actively
  * logging events.  In either case, called after clearing the old entries,
  * but before getting any new ones.
  */
 DataView.prototype.onSetIsViewingLogFile = function(isViewingLogFile) {
   setNodeDisplay(this.dumpDataDiv_, !isViewingLogFile);
   setNodeDisplay(this.capturingTextSpan_, !isViewingLogFile);
   setNodeDisplay(this.loggingTextSpan_, isViewingLogFile);
-  this.setText_('');
 };
 
 /**
  * Updates the counters showing how many events have been captured.
  */
 DataView.prototype.updateEventCounts_ = function() {
   this.activelyCapturedCountBox_.innerText =
       g_browser.getNumActivelyCapturedEvents()
   this.passivelyCapturedCountBox_.innerText =
       g_browser.getNumPassivelyCapturedEvents();
@@ skipping 13 matching lines @@
 
 /**
  * Depending on the value of the checkbox, enables or disables stripping
  * cookies and passwords from log dumps and displayed events.
  */
 DataView.prototype.onSetSecurityStripping_ =
     function(securityStrippingCheckbox) {
   g_browser.setSecurityStripping(securityStrippingCheckbox.checked);
 };
 
-/**
- * Clears displayed text when security stripping is toggled.
- */
 DataView.prototype.onSecurityStrippingChanged = function() {
-  this.setText_('');
-}
+};
 
 /**
  * Called when a log file is selected.
  *
  * Gets the log file from the input element and tries to read from it.
  */
 DataView.prototype.logFileChanged = function(loadLogFileElement) {
   var logFile = loadLogFileElement.files[0];
   if (logFile) {
     var fileReader = new FileReader();
 
     fileReader.onload = this.onLoadLogFile.bind(this);
     fileReader.onerror = this.onLoadLogFileError.bind(this);
 
     fileReader.readAsText(logFile);
   }
-}
+};
 
 /**
  * Displays an error message when unable to read the selected log file.
  */
 DataView.prototype.onLoadLogFileError = function(event) {
   alert('Error ' + event.target.error.code + '.  Unable to load file.');
-}
+};
 
 /**
  * Tries to load the contents of the log file.
  */
 DataView.prototype.onLoadLogFile = function(event) {
   g_browser.loadedLogFile(event.target.result);
-}
+};
+
+DataView.prototype.enableExportFileButton_ = function(enabled) {
+  this.exportFileButton_.disabled = !enabled;
+};
 
 /**
  * If not already waiting for results from all updates, triggers all
  * updates and starts waiting for them to complete.
  */
 DataView.prototype.onExportToText_ = function() {
-  if (this.waitingForUpdate_)
+  if (this.exportFileButton_.disabled)
     return;
-  this.waitingForUpdate = true;
-  this.setText_('Generating...');
+  this.enableExportFileButton_(false);
+
   g_browser.updateAllInfo(this.onUpdateAllCompleted.bind(this));
 };
 
 /**
  * Presents the captured data as formatted text.
  */
 DataView.prototype.onUpdateAllCompleted = function(data) {
   // It's possible for a log file to be loaded while a dump is being generated.
   // When that happens, don't display the log dump, to avoid any confusion.
   if (g_browser.isViewingLogFile())
@@ skipping 207 matching lines @@
       var provider = namespaceProviders[i];
       text.push('name: ' + provider.name);
       text.push('version: ' + provider.version);
       text.push('type: ' +
                 ServiceProvidersView.getNamespaceProviderType(provider));
       text.push('active: ' + provider.active);
       text.push('');
     }
   }
 
-  // Open a new window to display this text.
-  this.setText_(text.join('\n'));
+  var flatText = text.join('\n');
+  // Use Windows-style line breaks under Windows, so text file can be viewed
+  // with notepad.
+  if (g_browser.isPlatformWindows())
+    flatText.replace(/\n/g, '\r\n');

[eroman, 2011/06/16 19:16:45]

I suspect the file API might have something similar to "text mode" for files,
which does the conversion transparently.

This is fine though.

[mmenke, 2011/06/16 19:23:55]

Specs don't seem to mention it.  I could see it using mime type, but as we want
to force a download, anyways, can't use text/plain.

[kinuko, 2011/06/17 08:00:16]

BlobBuilder has some support for line-ending conversion.  I think you can use
"native" in this case.

http://dev.w3.org/2009/dap/file-system/file-writer.html#widl-BlobBuilder-appe...

[mmenke, 2011/06/17 13:45:59]

Tried it, and it works.

 
-  this.selectText_();
+  var blobBuilder = new WebKitBlobBuilder();
+  blobBuilder.append(flatText);
+  var textBlob = blobBuilder.getBlob('octet/stream');
+
+  window.webkitRequestFileSystem(
+      window.TEMPORARY, 10*1024 + textBlob.size,

[eroman, 2011/06/16 19:16:45]

what is the 10kb padding for?

[mmenke, 2011/06/16 19:23:55]

The file API doesn't specify what the size actually means.  I don't trust it to
not include some sort of padding, or file index, etc.  10 KB is a little small
for that, though, I suppose.

[kinuko, 2011/06/17 08:00:16]

For now this 'size' has no significant meaning but in the future this might be
used to request some quota for the filesystem.  For now any reasonable number
should work as far as you're using TEMPORARY filesystem.  (Or you'll just get
quota error when the physical disk is really getting tight)

[mmenke, 2011/06/17 13:45:59]

Ok.  I'll just go ahead and remove the 10 kB, then.

+      this.onFileSystemCreate_.bind(this, textBlob),
+      this.onFileError_.bind(this, 'Unable to create file system.'));
+};
+
+// Once we have access to the file system, create a log file.
+DataView.prototype.onFileSystemCreate_ = function(textBlob, fileSystem) {
+  fileSystem.root.getFile(
+      'net_internals_log.txt', {create: true},
+      this.onFileCreate_.bind(this, textBlob),
+      this.onFileError_.bind(this, 'Unable to create file.'));
+};
+
+// Once the file is created, or an existing one has been opened, create a
+// writer for it.
+DataView.prototype.onFileCreate_ = function(textBlob, fileEntry) {
+  fileEntry.createWriter(
+      this.onFileCreateWriter_.bind(this, textBlob, fileEntry),
+      this.onFileError_.bind(this, 'Unable to create writer.'));
+};
+
+// Once the |fileWriter| has been created, truncate the file, in case it already
+// existed.
+DataView.prototype.onFileCreateWriter_ = function(textBlob,
+                                                  fileEntry, fileWriter) {
+  fileWriter.onerror = this.onFileError_.bind(this, 'Truncate failed.');
+  fileWriter.onwriteend = this.onFileTruncate_.bind(this, textBlob,
+                                                    fileWriter, fileEntry);
+  fileWriter.truncate(0);
+};
+
+// Once the file has been truncated, write |textBlob| to the file.
+DataView.prototype.onFileTruncate_ = function(textBlob, fileWriter, fileEntry) {
+  fileWriter.onerror = this.onFileError_.bind(this, 'Write failed.');
+  fileWriter.onwriteend = this.onFileWriteComplete_.bind(this, fileEntry);
+  fileWriter.write(textBlob);
+};
+
+// Once the file has been written to, start the download.
+DataView.prototype.onFileWriteComplete_ = function(fileEntry) {
+  this.downloadIframe_.src = fileEntry.toURL();
+  this.enableExportFileButton_(true);
+};
+
+// On any Javascript File API error, enable the export button and display
+// |errorText|, followed by the specific error.
+DataView.prototype.onFileError_ = function(errorText, error) {
+  this.enableExportFileButton_(true);
+  alert(errorText + '  ' + getKeyWithValue(FileError, error.code));
 };
 
 DataView.prototype.appendEventsPrintedAsText_ = function(out) {
   var allEvents = g_browser.getAllCapturedEvents();
 
   // Group the events into buckets by source ID, and buckets by source type.
   var sourceIds = [];
   var sourceIdToEventList = {};
   var sourceTypeToSourceIdList = {};
 
@@ skipping 52 matching lines @@
 
   for (var i = 0; i < socketPools.length; ++i) {
     if (socketPools[i].origPool.groups == undefined)
       continue;
     var groupTablePrinter = socketPools[i].createGroupTablePrinter();
     text.push(groupTablePrinter.toText(2));
   }
 };
 
 /**
- * Helper function to set this view's content to |text|.
- */
-DataView.prototype.setText_ = function(text) {
-  this.textPre_.innerHTML = '';
-  addTextNode(this.textPre_, text);
-};
-
-/**
  * Format a time ticks count as a timestamp.
  */
 DataView.prototype.formatExpirationTime_ = function(timeTicks) {
   var d = g_browser.convertTimeTicksToDate(timeTicks);
   var isExpired = d.getTime() < (new Date()).getTime();
   return 't=' + d.getTime() + (isExpired ? ' [EXPIRED]' : '');
 };
-
-/**
- * Select all text from log dump.
- */
-DataView.prototype.selectText_ = function() {
-  var selection = window.getSelection();
-  selection.removeAllRanges();
-
-  var range = document.createRange();
-  range.selectNodeContents(this.textPre_);
-  selection.addRange(range);
-};