DevTools: Implement console message logging through an extension

Source/devtools/front_end/sdk/TempFile.js

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 70 matching lines @@
         function didTruncate(e)
         {
             this._writer = writer;
             writer.onwrite = null;
             writer.onerror = null;
             callback(this);
         }
 
         function onTruncateError(e)
         {
-            WebInspector.console.log("Failed to truncate temp file " + e.code + " : " + e.message,
-                             WebInspector.ConsoleMessage.MessageLevel.Error);
+            WebInspector.messageSink.addErrorMessage("Failed to truncate temp file " + e.code + " : " + e.message);
             callback(null);
         }
 
         if (writer.length) {
             writer.onwrite = didTruncate.bind(this);
             writer.onerror = onTruncateError;
             writer.truncate(0);
         } else {
             this._writer = writer;
             callback(this);
         }
     }
 
     function errorHandler(e)
     {
-        WebInspector.console.log("Failed to create temp file " + e.code + " : " + e.message,
-                         WebInspector.ConsoleMessage.MessageLevel.Error);
+        WebInspector.messageSink.addErrorMessage("Failed to create temp file " + e.code + " : " + e.message);
         callback(null);
     }
 
     /**
      * @this {WebInspector.TempFile}
      */
     function didClearTempStorage()
     {
         window.requestFileSystem(window.TEMPORARY, 10, didInitFs.bind(this), errorHandler);
     }
     WebInspector.TempFile._ensureTempStorageCleared(didClearTempStorage.bind(this));
 }
 
 WebInspector.TempFile.prototype = {
     /**
      * @param {!string} data
      * @param {!function(boolean)} callback
      */
     write: function(data, callback)
     {
         var blob = new Blob([data], {type: 'text/plain'});
         this._writer.onerror = function(e)
         {
-            WebInspector.console.log("Failed to write into a temp file: " + e.message,
-                             WebInspector.ConsoleMessage.MessageLevel.Error);
+            WebInspector.messageSink.addErrorMessage("Failed to write into a temp file: " + e.message);
             callback(false);
         }
         this._writer.onwrite = function(e)
         {
             callback(true);
         }
         this._writer.write(blob);
     },
 
     finishWriting: function()
@@ skipping 15 matching lines @@
 
             /**
              * @this {FileReader}
              */
             reader.onloadend = function(e)
             {
                 callback(/** @type {?string} */ (this.result));
             }
             reader.onerror = function(error)
             {
-                WebInspector.console.log("Failed to read from temp file: " + error.message,
-                                 WebInspector.ConsoleMessage.MessageLevel.Error);
+                WebInspector.messageSink.addErrorMessage("Failed to read from temp file: " + error.message);
             }
             reader.readAsText(file);
         }
         function didFailToGetFile(error)
         {
-            WebInspector.console.log("Failed to load temp file: " + error.message,
-                              WebInspector.ConsoleMessage.MessageLevel.Error);
+            WebInspector.messageSink.addErrorMessage("Failed to load temp file: " + error.message);
             callback(null);
         }
         this._fileEntry.file(didGetFile, didFailToGetFile);
     },
 
     /**
      * @param {!WebInspector.OutputStream} outputStream
      * @param {!WebInspector.OutputStreamDelegate} delegate
      */
     writeToOutputSteam: function(outputStream, delegate)
     {
         /**
          * @param {!File} file
          */
         function didGetFile(file)
         {
             var reader = new WebInspector.ChunkedFileReader(file, 10*1000*1000, delegate);
             reader.start(outputStream);
         }
 
         function didFailToGetFile(error)
         {
-            WebInspector.console.log("Failed to load temp file: " + error.message,
-                             WebInspector.ConsoleMessage.MessageLevel.Error);
+            WebInspector.messageSink.addErrorMessage("Failed to load temp file: " + error.message);
             outputStream.close();
         }
 
         this._fileEntry.file(didGetFile, didFailToGetFile);
     },
 
     remove: function()
     {
         if (this._fileEntry)
             this._fileEntry.remove(function() {});
@@ skipping 17 matching lines @@
 
 WebInspector.BufferedTempFileWriter.prototype = {
     /**
      * @param {!string} data
      */
     write: function(data)
     {
         if (!this._chunks)
             return;
         if (this._finishCallback)
-            throw new Error("Now writes are allowed after close.");
+            throw new Error("No writes are allowed after close.");
         this._chunks.push(data);
         if (this._tempFile && !this._isWriting)
             this._writeNextChunk();
     },
 
     /**
      * @param {!function(?WebInspector.TempFile)} callback
      */
     close: function(callback)
     {
@@ skipping 76 matching lines @@
         if (this._callbacks)
             this._callbacks.push(callback);
         else
             callback();
     },
 
     _handleMessage: function(event)
     {
         if (event.data.type === "tempStorageCleared") {
             if (event.data.error)
-                WebInspector.console.log(event.data.error, WebInspector.ConsoleMessage.MessageLevel.Error);
+                WebInspector.messageSink.addErrorMessage(event.data.error);
             this._notifyCallbacks();
         }
     },
 
     _handleError: function(event)
     {
-        WebInspector.console.log(WebInspector.UIString("Failed to clear temp storage: %s", event.data),
-                         WebInspector.ConsoleMessage.MessageLevel.Error);
+        WebInspector.messageSink.addErrorMessage(WebInspector.UIString("Failed to clear temp storage: %s", event.data));
         this._notifyCallbacks();
     },
 
     _notifyCallbacks: function()
     {
         var callbacks = this._callbacks;
         this._callbacks = null;
         for (var i = 0; i < callbacks.length; i++)
             callbacks[i]();
     }
 }
 
 /**
  * @param {!function()} callback
  */
 WebInspector.TempFile._ensureTempStorageCleared = function(callback)
 {
     if (!WebInspector.TempFile._storageCleaner)
         WebInspector.TempFile._storageCleaner = new WebInspector.TempStorageCleaner();
     WebInspector.TempFile._storageCleaner.ensureStorageCleared(callback);
 }