doc/webdeveloper/common/file.js

   1 // Gets the size of a file
   2 function webdeveloper_getFileSize(url)
   3 {
   4     var cacheService = Components.classes["@mozilla.org/network/cache-service;1"].getService(Components.interfaces.nsICacheService);
   5     var cacheSession = null;
   6     var file         = null;
   7     var fileSize     = null;
   8     var readAccess   = Components.interfaces.nsICache.ACCESS_READ;
   9
  10     // Try to get the file size from the HTTP cache
  11     try
  12     {
  13         cacheSession                      = cacheService.createSession("HTTP", 0, true);
  14         cacheSession.doomEntriesIfExpired = false;
  15         file                              = cacheSession.openCacheEntry(url, readAccess, false);
  16
  17         // If there is a file
  18         if(file)
  19         {
  20             fileSize = file.dataSize;
  21         }
  22     }
  23     catch(exception)
  24     {
  25         // Try to get the file size from the FTP cache
  26         try
  27         {
  28             cacheSession                      = cacheService.createSession("FTP", 0, true);
  29             cacheSession.doomEntriesIfExpired = false;
  30             file                              = cacheSession.openCacheEntry(url, readAccess, false);
  31
  32             // If there is a file
  33             if(file)
  34             {
  35                 fileSize = file.dataSize;
  36             }
  37         }
  38         catch(exception)
  39         {
  40             fileSize = null;
  41         }
  42     }
  43
  44     // If the file size could not be retrieved from the cache
  45     if(!fileSize)
  46     {
  47         // Try to download the file
  48         try
  49         {
  50             var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  51
  52             fileSize = ioService.newChannelFromURI(ioService.newURI(url, null, null)).open().available();
  53         }
  54         catch(exception)
  55         {
  56             fileSize = null;
  57         }
  58     }
  59
  60     return fileSize;
  61 }
  62
  63 // Gets the uncompressed size of a file
  64 function webdeveloper_getUncompressedFileSize(url)
  65 {
  66     var cacheService   = Components.classes["@mozilla.org/network/cache-service;1"].getService(Components.interfaces.nsICacheService);
  67     var cacheSession   = null;
  68     var file           = null;
  69     var fileCompressed = true;
  70     var fileSize       = null;
  71     var readAccess     = Components.interfaces.nsICache.ACCESS_READ;
  72
  73     // Try to get the file size from the HTTP cache
  74     try
  75     {
  76         cacheSession                      = cacheService.createSession("HTTP", 0, true);
  77         cacheSession.doomEntriesIfExpired = false;
  78         file                              = cacheSession.openCacheEntry(url, readAccess, false);
  79     }
  80     catch(exception)
  81     {
  82         // Try to get the file size from the FTP cache
  83         try
  84         {
  85             cacheSession                      = cacheService.createSession("FTP", 0, true);
  86             cacheSession.doomEntriesIfExpired = false;
  87             file                              = cacheSession.openCacheEntry(url, readAccess, false);
  88         }
  89         catch(exception)
  90         {
  91             file = null;
  92         }
  93     }
  94
  95     // If there is a file
  96     if(file)
  97     {
  98         var encoding        = null;
  99         var responseHeaders = null;
 100
 101         // Try to get the cache encoding
 102         try
 103         {
 104             // Specific case-sensitive required
 105             encoding = file.getMetaDataElement("request-Accept-Encoding");
 106         }
 107         catch(exception)
 108         {
 109             encoding = null;
 110
 111             // Try to get the response headers
 112             try
 113             {
 114                 // Specific case-sensitive required
 115                 responseHeaders = file.getMetaDataElement("response-head");
 116             }
 117             catch(exception)
 118             {
 119                 responseHeaders = null;
 120             }
 121         }
 122
 123         // If the cache is not GZIP encoded
 124         if((!encoding || encoding.indexOf("gzip") == -1) && (!responseHeaders || responseHeaders.indexOf("Content-Encoding: gzip") == -1))
 125         {
 126             fileCompressed = false;
 127         }
 128     }
 129
 130     // If the file is compressed
 131     if(fileCompressed)
 132     {
 133         // Try to download the file
 134         try
 135         {
 136             var request = new XMLHttpRequest();
 137
 138             request.open("get", url, false);
 139             request.send(null);
 140
 141             fileSize = request.responseText.length;
 142         }
 143         catch(exception)
 144         {
 145             fileSize = null;
 146         }
 147     }
 148
 149     return fileSize;
 150 }
 151
 152 // Retrieves the source from the given URL
 153 function webdeveloper_retrieveSource(url)
 154 {
 155     var source = null;
 156
 157     // If the URL is not entirely generated
 158     if(url.indexOf("wyciwyg://") != 0)
 159     {
 160         var cacheService = Components.classes["@mozilla.org/network/cache-service;1"].getService(Components.interfaces.nsICacheService);
 161         var cacheSession = null;
 162         var file         = null;
 163         var readAccess   = Components.interfaces.nsICache.ACCESS_READ;
 164
 165         // Try to get the file size from the HTTP cache
 166         try
 167         {
 168             cacheSession                      = cacheService.createSession("HTTP", 0, true);
 169             cacheSession.doomEntriesIfExpired = false;
 170             file                              = cacheSession.openCacheEntry(url, readAccess, false);
 171         }
 172         catch(exception)
 173         {
 174             // Try to get the file size from the FTP cache
 175             try
 176             {
 177                 cacheSession                      = cacheService.createSession("FTP", 0, true);
 178                 cacheSession.doomEntriesIfExpired = false;
 179                 file                              = cacheSession.openCacheEntry(url, readAccess, false);
 180             }
 181             catch(exception)
 182             {
 183                 file = null;
 184             }
 185         }
 186
 187         // If there is a file
 188         if(file)
 189         {
 190             var encoding        = null;
 191             var responseHeaders = null;
 192
 193             // Try to get the cache encoding
 194             try
 195             {
 196                 // Specific case-sensitive required
 197                 encoding = file.getMetaDataElement("request-Accept-Encoding");
 198             }
 199             catch(exception)
 200             {
 201                 encoding = null;
 202
 203                 // Try to get the response headers
 204                 try
 205                 {
 206                     // Specific case-sensitive required
 207                     responseHeaders = file.getMetaDataElement("response-head");
 208                 }
 209                 catch(exception)
 210                 {
 211                     responseHeaders = null;
 212                 }
 213             }
 214
 215             // If the cache is not GZIP encoded
 216             if((!encoding || encoding.indexOf("gzip") == -1) && (!responseHeaders || (responseHeaders.indexOf("Content-Encoding: deflate") == -1 && responseHeaders.indexOf("Content-Encoding: gzip") == -1)))
 217             {
 218                 var inputStream      = file.openInputStream(0);
 219                 var scriptableStream = Components.classes["@mozilla.org/scriptableinputstream;1"].createInstance(Components.interfaces.nsIScriptableInputStream);
 220
 221                 scriptableStream.init(inputStream);
 222
 223                 source = scriptableStream.read(scriptableStream.available());
 224
 225                 scriptableStream.close();
 226                 inputStream.close();
 227             }
 228         }
 229
 230         // If the source has not been loaded
 231         if(!source)
 232         {
 233             // Try to load the URL
 234             try
 235             {
 236                 var request = new XMLHttpRequest();
 237
 238                 request.open("get", url, false);
 239                 request.send(null);
 240
 241                 source = request.responseText;
 242             }
 243             catch(exception)
 244             {
 245                 source = null;
 246             }
 247         }
 248     }
 249
 250     return source;
 251 }