✨ Add updated CachedXMLHttpRequest and CachedXHRExtensions

Author: BenV

Assets/Plugins/WebGLCachedXHRExtensions.meta

@@ -0,0 +1,56 @@
+using UnityEngine;
+using System.Runtime.InteropServices;
+
+namespace Kongregate {
+    public class CacheEntryQuery : CustomYieldInstruction {
+        private readonly string Url;
+        private int Status = 0;
+
+        public CacheEntryQuery(string url) {
+            Url = url;
+            CachedXHRExtensions_SearchCache(url);
+        }
+
+        public override bool keepWaiting {
+            get {
+                Status = CachedXHRExtensions_CheckStatus(Url);
+                return Status == 0;
+            }
+        }
+
+        public bool IsCached {
+            get {
+                if (Status == 0) {
+                    Debug.Log("CacheEntryQuery: returning IsCached=false since query is pending");
+                    return false;
+                }
+
+                return Status == 1;
+            }
+        }
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        private static extern void CachedXHRExtensions_SearchCache(string url);
+
+        [DllImport("__Internal")]
+        private static extern int CachedXHRExtensions_CheckStatus(string url);
+#else
+        private static void CachedXHRExtensions_SearchCache(string url) { }
+        private static int CachedXHRExtensions_CheckStatus(string url) { return -1; }
+#endif
+    }
+
+    public class CachedXHRExtensions {
+        public static void CleanCache() {
+            CachedXHRExtensions_CleanCache();
+        }
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        [DllImport("__Internal")]
+        static extern int CachedXHRExtensions_CleanCache();
+#else
+        static void CachedXHRExtensions_CleanCache() {}
+#endif
+    }
+}

Assets/Plugins/WebGLCachedXHRExtensions/CachedXHRExtensions.cs

@@ -0,0 +1,12 @@
+mergeInto(LibraryManager.library, {
+  CachedXHRExtensions_SearchCache: function(url) { CachedXHRExtensions.searchCache(url); },
+  CachedXHRExtensions_CheckStatus: function(url) { return CachedXHRExtensions.checkStatus(url); },
+  CachedXHRExtensions_CleanCache: function() {
+    try {
+      var self = CachedXMLHttpRequest.cache;
+      self.db.transaction([self.store], "readwrite").objectStore(self.store).clear().onerror = function(){
+        e.preventDefault();
+      };
+    } catch(e) {}
+  }
+});

Assets/Plugins/WebGLCachedXHRExtensions/CachedXHRExtensions.cs.meta

@@ -0,0 +1,32 @@
+setTimeout(function(){
+  var enabled = typeof CachedXMLHttpRequest !== "undefined" && !!CachedXMLHttpRequest.cache;
+  console.log("CachedXHRExtensions initialized, enabled=" + enabled);
+  var CachedXHRExtensions = function() {
+    this._cacheStates = {};
+  };
+
+  CachedXHRExtensions.prototype.searchCache = function(url) {
+    if (!enabled) return;
+    var self = this;
+    url = typeof url === "string" ? url : Pointer_stringify(url);
+    delete this._cacheStates[url];
+
+    CachedXMLHttpRequest.cache.get(url, function(err, result) {
+      if (err || !result || !result.meta) {
+        self._cacheStates[url] = false;
+      } else {
+        self._cacheStates[url] = true;
+      }
+    });
+  };
+
+  CachedXHRExtensions.prototype.checkStatus = function(url) {
+    if (!enabled) return -1;
+
+    url = typeof url === "string" ? url : Pointer_stringify(url);
+    if (this._cacheStates[url] === undefined) return 0;
+    return this._cacheStates[url] ? 1 : -1;
+  };
+
+  window.CachedXHRExtensions = new CachedXHRExtensions();
+}, 0);

Assets/Plugins/WebGLCachedXHRExtensions/CachedXHRExtensions.jslib

@@ -0,0 +1,12 @@
+This plugin provides additional functionality on top of the CachedXMLHttpRequest
+addon. The classes referred to below are in the Kongregate namespace.
+
+* Clearing the cache by calling CachedXHRExtensions.CleanCache()
+* Asynchronously querying the cache to determine if an item exists:
+  IEnumerator CheckIfAssetExists() {
+    var query = new CacheEntryQuery("https://whatever.io/file.xml");
+    yield return query;
+    if (query.IsCached) {
+      Debug.Log("Asset exists in cache!");
+    }
+  }

Assets/Plugins/WebGLCachedXHRExtensions/CachedXHRExtensions.jslib.meta

@@ -15,7 +15,7 @@ function CachedXMLHttpRequest() {
         meta.size = xhr.response.byteLength;
         CachedXMLHttpRequest.cache.put(cache.requestURL, meta, xhr.response, function (err) {
           CachedXMLHttpRequest.log("'" + cache.requestURL + "' downloaded successfully (" + xhr.response.byteLength + " bytes) " +
-            (err ? "but not stored in indexedDB cache due to error." : "and stored in indexedDB cache."));
+            (err ? "but not stored in indexedDB cache due to error: " + err.message : "and stored in indexedDB cache."));
           if (onload)
             onload(e);
         });
@@ -27,22 +27,28 @@ function CachedXMLHttpRequest() {
         if (onload)
           onload(e);
       }
-    }
+    };
     return xhr.send.apply(xhr, arguments);
   }
 
-  function revalidateCrossOriginRequest(meta, self, sendArguments) {
-    var headXHR = new CachedXMLHttpRequest.XMLHttpRequest();
-    headXHR.open("HEAD", meta.requestURL, false);
-    headXHR.send();
-    cache.override = meta.lastModified ? meta.lastModified == headXHR.getResponseHeader("Last-Modified") : meta.eTag && meta.eTag == headXHR.getResponseHeader("ETag");
-    if (!cache.override)
-      return send.apply(self, sendArguments);
+  function loadComplete() {
     CachedXMLHttpRequest.log("'" + cache.requestURL + "' served from indexedDB cache (" + cache.response.byteLength + " bytes).");
     if (xhr.onload)
       xhr.onload();
   }
 
+  function revalidateCrossOriginRequest(meta, self, sendArguments) {
+    var headXHR = new CachedXMLHttpRequest.XMLHttpRequest();
+    headXHR.open("HEAD", meta.requestURL, cache.async);
+    headXHR.onload = function() {
+      cache.override = meta.lastModified ? meta.lastModified == headXHR.getResponseHeader("Last-Modified") : meta.eTag && meta.eTag == getETag(headXHR);
+      if (!cache.override)
+        return send.apply(self, sendArguments);
+      loadComplete();
+    };
+    headXHR.send();
+  }
+
   Object.defineProperty(self, "open", { value: function (method, url, async) {
     cache = { method: method, requestURL: CachedXMLHttpRequest.cache.requestURL(url), async: async };
     return xhr.open.apply(xhr, arguments);
@@ -65,6 +71,12 @@ function CachedXMLHttpRequest() {
       cache.statusText = "OK";
       cache.response = result.response;
       cache.responseURL = result.meta.responseURL;
+
+      if (CachedXMLHttpRequest.checkBlacklist(Module.CachedXMLHttpRequestRevalidateBlacklist, cache.requestURL)) {
+        cache.override = true;
+        return loadComplete();
+      }
+
       if (window.location.href.lastIndexOf(absoluteUrlMatch[0], 0))
         return revalidateCrossOriginRequest(result.meta, self, sendArguments);
       if (result.meta.lastModified)
@@ -97,6 +109,17 @@ CachedXMLHttpRequest.log = function (message) {
     console.log("[CachedXMLHttpRequest] " + message);
 };
 
+CachedXMLHttpRequest.checkBlacklist = function(list, url) {
+  list = list || [];
+  list = Array.isArray(list) ? list : [list];
+  for (var i = 0; i < list.length; i++) {
+    var regexp = list[i];
+    if (typeof regexp === "string") regexp = new RegExp(regexp);
+    if (regexp instanceof RegExp && regexp.test(url)) return true;
+  }
+  return false;
+};
+
 CachedXMLHttpRequest.cache = {
   database: "CachedXMLHttpRequest",
   version: 1,
@@ -115,19 +138,24 @@ CachedXMLHttpRequest.cache = {
   queue: [],
   processQueue: function () {
     var self = this;
-    self.queue.forEach(function (queued) { self[queued.action].apply(self, queued.arguments) });
+    self.queue.forEach(function (queued) { self[queued.action].apply(self, queued.arguments); });
     self.queue = [];
 
   },
   init: function () {
-    var self = this;
+    var self = this, onError = function(e) {
+      CachedXMLHttpRequest.log("can not open indexedDB database: " + e.message);
+      self.indexedDB = null;
+      self.processQueue();
+      if (e.preventDefault) e.preventDefault();
+    };
     if (!self.indexedDB)
       return CachedXMLHttpRequest.log("indexedDB is not available");
     var openDB;
     try {
       openDB = indexedDB.open(self.database, self.version);
     } catch(e) {
-      return CachedXMLHttpRequest.log("indexedDB access denied");
+      return onError(new Error("indexedDB access denied"));
     }
     openDB.onupgradeneeded = function (e) {
       var db = e.target.result;
@@ -140,56 +168,57 @@ CachedXMLHttpRequest.cache = {
         objectStore.createIndex("meta", "meta", {unique: false});
       }
       objectStore.clear();
-    }
-    openDB.onerror = function (e) {
-      CachedXMLHttpRequest.log("can not open indexedDB database");
-      self.indexedDB = null;
-      self.processQueue();
-    }
+    };
+    openDB.onerror = onError;
     openDB.onsuccess = function (e) {
       self.db = e.target.result;
       self.processQueue();
-    }
+    };
 
   },
   put: function (requestURL, meta, response, callback) {
+    if (CachedXMLHttpRequest.checkBlacklist(Module.CachedXMLHttpRequestBlacklist, requestURL))
+      return callback(new Error("requestURL was on the cache blacklist"));
+
     var self = this;
     if (!self.indexedDB)
       return callback(new Error("indexedDB is not available"));
     if (!self.db)
       return self.queue.push({action: "put", arguments: arguments});
     meta.version = self.version;
     var putDB = self.db.transaction([self.store], "readwrite").objectStore(self.store).put({id: self.id(requestURL), meta: meta, response: response});
-    putDB.onerror = function (e) { callback(new Error("failed to put request into indexedDB cache")); }
-    putDB.onsuccess = function (e) { callback(null); }
+    putDB.onerror = function (e) { e.preventDefault(); callback(new Error("failed to put request into indexedDB cache")); };
+    putDB.onsuccess = function () { callback(null); };
 
   },
   get: function (requestURL, callback) {
+    if (CachedXMLHttpRequest.checkBlacklist(Module.CachedXMLHttpRequestBlacklist, requestURL))
+      return callback(new Error("requestURL was on the cache blacklist"));
+
     var self = this;
     if (!self.indexedDB)
       return callback(new Error("indexedDB is not available"));
     if (!self.db)
       return self.queue.push({action: "get", arguments: arguments});
     var getDB = self.db.transaction([self.store], "readonly").objectStore(self.store).get(self.id(requestURL));
-    getDB.onerror = function (e) { callback(new Error("failed to get request from indexedDB cache")); }
-    getDB.onsuccess = function (e) { callback(null, e.target.result); }
-
-  },
+    getDB.onerror = function (e) { e.preventDefault(); callback(new Error("failed to get request from indexedDB cache")); };
+    getDB.onsuccess = function (e) { callback(null, e.target.result); };
+  }
 };
 
 CachedXMLHttpRequest.cache.init();
 
 CachedXMLHttpRequest.wrap = function (func) {
   return function () {
-    var realXMLHttpRequest = XMLHttpRequest;
-    XMLHttpRequest = CachedXMLHttpRequest;
+    var realXMLHttpRequest = XMLHttpRequest, result;
+    window.XMLHttpRequest = CachedXMLHttpRequest;
     try {
-      var result = func.apply(this, arguments);
+      result = func.apply(this, arguments);
     } catch (e) {
-      XMLHttpRequest = realXMLHttpRequest;
+      window.XMLHttpRequest = realXMLHttpRequest;
       throw e;
     }
-    XMLHttpRequest = realXMLHttpRequest;
+    window.XMLHttpRequest = realXMLHttpRequest;
     return result;
   };
 };