this addresses AMO feedback from uBlock

platform/firefox/vapi-background.js

@@ -129,53 +129,66 @@ window.addEventListener('unload', function() {
 
 /******************************************************************************/
 
-var SQLite = {
+// API matches that of chrome.storage.local:
-    db: null,
+//   https://developer.chrome.com/extensions/storage
 
-    open: function() {
+vAPI.storage = (function() {
+    var db = null;
+
+    var close = function() {
+        if ( db === null ) {
+            return;
+        }
+        db.createAsyncStatement('VACUUM').executeAsync();
+        db.asyncClose();
+        db = null;
+    };
+
+    var open = function() {
+        if ( db !== null ) {
+            return db;
+        }
+
+        // Create path
         var path = Services.dirsvc.get('ProfD', Ci.nsIFile);
         path.append('extension-data');
-
         if ( !path.exists() ) {
             path.create(Ci.nsIFile.DIRECTORY_TYPE, parseInt('0774', 8));
         }
-
         if ( !path.isDirectory() ) {
             throw Error('Should be a directory...');
         }
-
         path.append(location.host + '.sqlite');
-        this.db = Services.storage.openDatabase(path);
-        this.db.executeSimpleSQL(
-            'CREATE TABLE IF NOT EXISTS settings' +
-            '(name TEXT PRIMARY KEY NOT NULL, value TEXT);'
-        );
 
-        cleanupTasks.push(function() {
+        // Open database
-            // VACUUM somewhere else, instead on unload?
+        try {
-            SQLite.run('VACUUM');
+            db = Services.storage.openDatabase(path);
-            SQLite.db.asyncClose();
+            if ( db.connectionReady === false ) {
-        });
+                db.asyncClose();
-    },
+                db = null;
+            }
+        } catch (ex) {
+        }
 
-    run: function(query, values, callback) {
+        if ( db === null ) {
-        if ( !this.db ) {
+            return null;
-            this.open();
         }
 
-        var result = {};
+        // Database was opened, register cleanup task
+        cleanupTasks.push(close);
 
-        query = this.db.createAsyncStatement(query);
+        // Setup database
+        db.createAsyncStatement('CREATE TABLE IF NOT EXISTS settings(name TEXT PRIMARY KEY NOT NULL, value TEXT);')
+          .executeAsync();
 
-        if ( Array.isArray(values) && values.length ) {
+        return db;
-            var i = values.length;
+    };
 
-            while ( i-- ) {
+    // Execute a query
-                query.bindByIndex(i, values[i]);
+    var runStatement = function(stmt, callback) {
-            }
+        var result = {};
-        }
 
-        query.executeAsync({
+        stmt.executeAsync({
             handleResult: function(rows) {
                 if ( !rows || typeof callback !== 'function' ) {
                     return;
@@ -196,122 +209,161 @@ var SQLite = {
             },
             handleError: function(error) {
                 console.error('SQLite error ', error.result, error.message);
+                // Caller expects an answer regardless of failure.
+                if ( typeof callback === 'function' ) {
+                    callback(null);
+                }
             }
         });
-    }
+    };
-};
-
-/******************************************************************************/
-
-vAPI.storage = {
-    QUOTA_BYTES: 100 * 1024 * 1024,
 
-    sqlWhere: function(col, params) {
+    var bindNames = function(stmt, names) {
-        if ( params > 0 ) {
+        if ( Array.isArray(names) === false || names.length === 0 ) {
-            params = new Array(params + 1).join('?, ').slice(0, -2);
+            return;
-            return ' WHERE ' + col + ' IN (' + params + ')';
+        }
+        var params = stmt.newBindingParamsArray();
+        var i = names.length, bp;
+        while ( i-- ) {
+            bp = params.newBindingParams();
+            bp.bindByName('name', names[i]);
+            params.addParams(bp);
         }
+        stmt.bindParameters(params);
+    };
 
-        return '';
+    var clear = function(callback) {
-    },
+        if ( open() === null ) {
+            if ( typeof callback === 'function' ) {
+                callback();
+            }
+            return;
+        }
+        runStatement(db.createAsyncStatement('DELETE FROM settings; VACUUM;'), callback);
+    };
 
-    get: function(details, callback) {
+    var getBytesInUse = function(keys, callback) {
         if ( typeof callback !== 'function' ) {
             return;
         }
 
-        var values = [], defaults = false;
+        if ( open() === null ) {
+            callback(0);
+            return;
+        }
 
-        if ( details !== null ) {
+        var stmt;
-            if ( Array.isArray(details) ) {
+        if ( Array.isArray(keys) ) {
-                values = details;
+            stmt = db.createAsyncStatement('SELECT "size" AS size, SUM(LENGTH(value)) FROM settings WHERE name = :name');
-            } else if ( typeof details === 'object' ) {
+            bindNames(keys);
-                defaults = true;
+        } else {
-                values = Object.keys(details);
+            stmt = db.createAsyncStatement('SELECT "size" AS size, SUM(LENGTH(value)) FROM settings');
-            } else {
-                values = [details.toString()];
-            }
         }
 
-        SQLite.run(
+        runStatement(stmt, function(result) {
-            'SELECT * FROM settings' + this.sqlWhere('name', values.length),
+            callback(result.size);
-            values,
+        });
-            function(result) {
+    };
-                var key;
+    var read = function(details, callback) {
+        if ( typeof callback !== 'function' ) {
+            return;
+        }
 
-                for ( key in result ) {
+        var prepareResult = function(result) {
-                    result[key] = JSON.parse(result[key]);
+            var key;
+            for ( key in result ) {
+                if ( result.hasOwnProperty(key) === false ) {
+                    continue;
                 }
-
+                result[key] = JSON.parse(result[key]);
-                if ( defaults ) {
+            }
-                    for ( key in details ) {
+            if ( typeof details === 'object' && details !== null ) {
-                        if ( result[key] === undefined ) {
+                for ( key in details ) {
-                            result[key] = details[key];
+                    if ( result.hasOwnProperty(key) === false ) {
-                        }
+                        result[key] = details[key];
                     }
                 }
-
-                callback(result);
             }
-        );
+            callback(result);
-    },
+        };
 
-    set: function(details, callback) {
+        if ( open() === null ) {
-        var key, values = [], placeholders = [];
+            prepareResult({});
+            return;
+        }
 
-        for ( key in details ) {
+        var names = [];
-            if ( !details.hasOwnProperty(key) ) {
+        if ( details !== null ) {
-                continue;
+            if ( Array.isArray(details) ) {
+                names = details;
+            } else if ( typeof details === 'object' ) {
+                names = Object.keys(details);
+            } else {
+                names = [details.toString()];
             }
-            values.push(key);
-            values.push(JSON.stringify(details[key]));
-            placeholders.push('?, ?');
         }
 
-        if ( !values.length ) {
+        var stmt;
-            return;
+        if ( names.length === 0 ) {
+            stmt = db.createAsyncStatement('SELECT * FROM settings');
+        } else {
+            stmt = db.createAsyncStatement('SELECT * FROM settings WHERE name = :name');
+            bindNames(stmt, names);
         }
 
-        SQLite.run(
+        runStatement(stmt, prepareResult);
-            'INSERT OR REPLACE INTO settings (name, value) SELECT ' +
+    };
-                placeholders.join(' UNION SELECT '),
-            values,
-            callback
-        );
-    },
 
-    remove: function(keys, callback) {
+    var remove = function(keys, callback) {
-        if ( typeof keys === 'string' ) {
+        if ( open() === null ) {
-            keys = [keys];
+            if ( typeof callback === 'function' ) {
+                callback();
+            }
+            return;
         }
+        var stmt = db.createAsyncStatement('DELETE FROM settings WHERE name = :name');
+        bindNames(stmt, typeof keys === 'string' ? [keys] : keys);
+        runStatement(stmt, callback);
+    };
 
-        SQLite.run(
+    var write = function(details, callback) {
-            'DELETE FROM settings' + this.sqlWhere('name', keys.length),
+        if ( open() === null ) {
-            keys,
+            if ( typeof callback === 'function' ) {
-            callback
+                callback();
-        );
+            }
-    },
-
-    clear: function(callback) {
-        SQLite.run('DELETE FROM settings');
-        SQLite.run('VACUUM', null, callback);
-    },
-
-    getBytesInUse: function(keys, callback) {
-        if ( typeof callback !== 'function' ) {
             return;
         }
 
-        SQLite.run(
+        var stmt = db.createAsyncStatement('INSERT OR REPLACE INTO settings (name, value) VALUES(:name, :value)');
-            'SELECT "size" AS size, SUM(LENGTH(value)) FROM settings' +
+        var params = stmt.newBindingParamsArray(), bp;
-                this.sqlWhere('name', Array.isArray(keys) ? keys.length : 0),
+        for ( var key in details ) {
-            keys,
+            if ( details.hasOwnProperty(key) === false ) {
-            function(result) {
+                continue;
-                callback(result.size);
             }
-        );
+            bp = params.newBindingParams();
-    }
+            bp.bindByName('name', key);
-};
+            bp.bindByName('value', JSON.stringify(details[key]));
+            params.addParams(bp);
+        }
+        if ( params.length === 0 ) {
+            return;
+        }
+
+        stmt.bindParameters(params);
+        runStatement(stmt, callback);
+    };
+
+    // Export API
+    var api = {
+        QUOTA_BYTES: 100 * 1024 * 1024,
+        clear: clear,
+        get: read,
+        getBytesInUse: getBytesInUse,
+        remove: remove,
+        set: write
+    };
+    return api;
+})();
 
 /******************************************************************************/