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 blobBuilder = new WebKitBlobBuilder();
+  blobBuilder.append(text.join('\n'), 'native');
+  var textBlob = blobBuilder.getBlob('octet/stream');
 
-  this.selectText_();
+  window.webkitRequestFileSystem(
+      window.TEMPORARY, textBlob.size,
+      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);
-};