Home | History | Annotate | Download | only in resources 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 var createClassWrapper = requireNative('utils').createClassWrapper;
      6 var nativeDeepCopy = requireNative('utils').deepCopy;
      7 var schemaRegistry = requireNative('schema_registry');
      8 var CHECK = requireNative('logging').CHECK;
      9 var DCHECK = requireNative('logging').DCHECK;
     10 var WARNING = requireNative('logging').WARNING;
     11 
     12 /**
     13  * An object forEach. Calls |f| with each (key, value) pair of |obj|, using
     14  * |self| as the target.
     15  * @param {Object} obj The object to iterate over.
     16  * @param {function} f The function to call in each iteration.
     17  * @param {Object} self The object to use as |this| in each function call.
     18  */
     19 function forEach(obj, f, self) {
     20   for (var key in obj) {
     21     if ($Object.hasOwnProperty(obj, key))
     22       $Function.call(f, self, key, obj[key]);
     23   }
     24 }
     25 
     26 /**
     27  * Assuming |array_of_dictionaries| is structured like this:
     28  * [{id: 1, ... }, {id: 2, ...}, ...], you can use
     29  * lookup(array_of_dictionaries, 'id', 2) to get the dictionary with id == 2.
     30  * @param {Array.<Object.<string, ?>>} array_of_dictionaries
     31  * @param {string} field
     32  * @param {?} value
     33  */
     34 function lookup(array_of_dictionaries, field, value) {
     35   var filter = function (dict) {return dict[field] == value;};
     36   var matches = array_of_dictionaries.filter(filter);
     37   if (matches.length == 0) {
     38     return undefined;
     39   } else if (matches.length == 1) {
     40     return matches[0]
     41   } else {
     42     throw new Error("Failed lookup of field '" + field + "' with value '" +
     43                     value + "'");
     44   }
     45 }
     46 
     47 function loadTypeSchema(typeName, defaultSchema) {
     48   var parts = $String.split(typeName, '.');
     49   if (parts.length == 1) {
     50     if (defaultSchema == null) {
     51       WARNING('Trying to reference "' + typeName + '" ' +
     52               'with neither namespace nor default schema.');
     53       return null;
     54     }
     55     var types = defaultSchema.types;
     56   } else {
     57     var schemaName = $Array.join($Array.slice(parts, 0, parts.length - 1), '.');
     58     var types = schemaRegistry.GetSchema(schemaName).types;
     59   }
     60   for (var i = 0; i < types.length; ++i) {
     61     if (types[i].id == typeName)
     62       return types[i];
     63   }
     64   return null;
     65 }
     66 
     67 /**
     68  * Takes a private class implementation |cls| and exposes a subset of its
     69  * methods |functions| and properties |properties| and |readonly| in a public
     70  * wrapper class that it returns. Within bindings code, you can access the
     71  * implementation from an instance of the wrapper class using
     72  * privates(instance).impl, and from the implementation class you can access
     73  * the wrapper using this.wrapper (or implInstance.wrapper if you have another
     74  * instance of the implementation class).
     75  * @param {string} name The name of the exposed wrapper class.
     76  * @param {Object} cls The class implementation.
     77  * @param {{superclass: ?Function,
     78  *          functions: ?Array.<string>,
     79  *          properties: ?Array.<string>,
     80  *          readonly: ?Array.<string>}} exposed The names of properties on the
     81  *     implementation class to be exposed. |superclass| represents the
     82  *     constructor of the class to be used as the superclass of the exposed
     83  *     class; |functions| represents the names of functions which should be
     84  *     delegated to the implementation; |properties| are gettable/settable
     85  *     properties and |readonly| are read-only properties.
     86  */
     87 function expose(name, cls, exposed) {
     88   var publicClass = createClassWrapper(name, cls, exposed.superclass);
     89 
     90   if ('functions' in exposed) {
     91     $Array.forEach(exposed.functions, function(func) {
     92       publicClass.prototype[func] = function() {
     93         var impl = privates(this).impl;
     94         return $Function.apply(impl[func], impl, arguments);
     95       };
     96     });
     97   }
     98 
     99   if ('properties' in exposed) {
    100     $Array.forEach(exposed.properties, function(prop) {
    101       $Object.defineProperty(publicClass.prototype, prop, {
    102         enumerable: true,
    103         get: function() {
    104           return privates(this).impl[prop];
    105         },
    106         set: function(value) {
    107           var impl = privates(this).impl;
    108           delete impl[prop];
    109           impl[prop] = value;
    110         }
    111       });
    112     });
    113   }
    114 
    115   if ('readonly' in exposed) {
    116     $Array.forEach(exposed.readonly, function(readonly) {
    117       $Object.defineProperty(publicClass.prototype, readonly, {
    118         enumerable: true,
    119         get: function() {
    120           return privates(this).impl[readonly];
    121         },
    122       });
    123     });
    124   }
    125 
    126   return publicClass;
    127 }
    128 
    129 /**
    130  * Returns a deep copy of |value|. The copy will have no references to nested
    131  * values of |value|.
    132  */
    133 function deepCopy(value) {
    134   return nativeDeepCopy(value);
    135 }
    136 
    137 /**
    138  * Wrap an asynchronous API call to a function |func| in a promise. The
    139  * remaining arguments will be passed to |func|. Returns a promise that will be
    140  * resolved to the result passed to the callback or rejected if an error occurs
    141  * (if chrome.runtime.lastError is set). If there are multiple results, the
    142  * promise will be resolved with an array containing those results.
    143  *
    144  * For example,
    145  * promise(chrome.storage.get, 'a').then(function(result) {
    146  *   // Use result.
    147  * }).catch(function(error) {
    148  *   // Report error.message.
    149  * });
    150  */
    151 function promise(func) {
    152   var args = $Array.slice(arguments, 1);
    153   DCHECK(typeof func == 'function');
    154   return new Promise(function(resolve, reject) {
    155     args.push(function() {
    156       if (chrome.runtime.lastError) {
    157         reject(new Error(chrome.runtime.lastError));
    158         return;
    159       }
    160       if (arguments.length <= 1)
    161         resolve(arguments[0]);
    162       else
    163         resolve($Array.slice(arguments));
    164     });
    165     $Function.apply(func, null, args);
    166   });
    167 }
    168 
    169 exports.forEach = forEach;
    170 exports.loadTypeSchema = loadTypeSchema;
    171 exports.lookup = lookup;
    172 exports.expose = expose;
    173 exports.deepCopy = deepCopy;
    174 exports.promise = promise;
    175