Clear DevTools temp storage

Source/devtools/front_end/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 89 matching lines @@
             callback(this);
         }
     }
 
     function errorHandler(e)
     {
         WebInspector.log("Failed to create temp file " + e.code + " : " + e.message,
                          WebInspector.ConsoleMessage.MessageLevel.Error);
         callback(null);
     }
+
     var boundErrorHandler = errorHandler.bind(this)
-    window.requestFileSystem(window.TEMPORARY, 10, didInitFs.bind(this), errorHandler.bind(this));
+    /**
+     * @this {WebInspector.TempFile}
+     */
+    function didClearTempStorage()
+    {
+        window.requestFileSystem(window.TEMPORARY, 10, didInitFs.bind(this), boundErrorHandler);
+    }
+    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'});
@@ skipping 56 matching lines @@
      */
     getFile: function(callback)
     {
         function didFailToGetFile(error)
         {
             WebInspector.log("Failed to load temp file: " + error.message,
                               WebInspector.ConsoleMessage.MessageLevel.Error);
             callback(null);
         }
         this._fileEntry.file(callback, didFailToGetFile.bind(this));
+    },
+
+    remove: function()
+    {
+        if (this._fileEntry)
+            this._fileEntry.remove(function() {});
     }
 }
 
 /**
  * @constructor
  * @param {!string} dirPath
  * @param {!string} name
  */
 WebInspector.BufferedTempFileWriter = function(dirPath, name)
 {
@@ skipping 74 matching lines @@
 
     _notifyFinished: function()
     {
         this._isFinished = true;
         if (this._tempFile)
             this._tempFile.finishWriting();
         if (this._finishCallback)
             this._finishCallback(this._tempFile);
     }
 }
+
+/**
+ * @constructor
+ */
+WebInspector.TempStorageCleaner = function()
+{
+    this._worker = new SharedWorker("TempStorageSharedWorker.js", "TempStorage");
+    this._callbacks = [];
+    this._worker.port.onmessage = this._handleMessage.bind(this);
+    this._worker.port.onerror = this._handleError.bind(this);
+}
+
+WebInspector.TempStorageCleaner.prototype = {
+    /**
+     * @param {!function()} callback
+     */
+    ensureStorageCleared: function(callback)
+    {
+        if (this._callbacks)
+            this._callbacks.push(callback);
+        else
+            callback();
+    },
+
+    _handleMessage: function(event)
+    {
+        if (event.data.type === "tempStorageCleared") {
+            if (event.data.error)
+                WebInspector.log(event.data.error, WebInspector.ConsoleMessage.MessageLevel.Error);
+            this._notifyCallbacks();
+        }
+    },
+
+    _handleError: function(event)
+    {
+        WebInspector.log(WebInspector.UIString("Failed to clear temp storage: %s", event.data),
+                         WebInspector.ConsoleMessage.MessageLevel.Error);
+        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);
+}