home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / AIMP2 / aimp_2.61.583.exe / $TEMP / YandexPackSetup.msi / fil5C5F2E43DDC7289EF6282B6E03A54392 < prev    next >
Text File  |  2010-07-12  |  9KB  |  240 lines
  1. /*
  2.  * ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is Mozilla code.
  16.  *
  17.  * The Initial Developer of the Original Code is
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 2004
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *    Alex Fritze <alex@croczilla.com> (original author)
  24.  *    Nickolay Ponomarev <asqueella@gmail.com>
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40.  
  41. var EXPORTED_SYMBOLS = [ "XPCOMUtilsEx" ];
  42.  
  43. const ARBITER_NAME = "arbiter"
  44. const ARBITER_CONTRACT_ID = "@yandex.ru/" + ARBITER_NAME + ";1";
  45.  
  46. const Cc = Components.classes;
  47. const Ci = Components.interfaces;
  48. const Cr = Components.results;
  49.  
  50. var XPCOMUtilsEx = {
  51.   /**
  52.    * Generate a QueryInterface implementation. The returned function must be
  53.    * assigned to the 'QueryInterface' property of a JS object. When invoked on
  54.    * that object, it checks if the given iid is listed in the |interfaces|
  55.    * param, and if it is, returns |this| (the object it was called on).
  56.    */
  57.   generateQI: function(interfaces) {
  58.     return makeQI([i.name for each (i in interfaces) if (i)]);
  59.   },
  60.  
  61.   /**
  62.    * Generate the NSGetModule function (along with the module definition).
  63.    * See the parameters to generateModule.
  64.    */
  65.   generateNSGetModule: function(componentsArray, postRegister, preUnregister) {
  66.     return function NSGetModule(compMgr, fileSpec) {
  67.       return XPCOMUtilsEx.generateModule(componentsArray,
  68.                                        postRegister,
  69.                                        preUnregister);
  70.     }
  71.   },
  72.  
  73.   /**
  74.    * Generate a module implementation.
  75.    *
  76.    * @param componentsArray  Array of component constructors. See the comment
  77.    *                         at the top of this file for details.
  78.    * @param postRegister  optional post-registration function with
  79.    *                      signature 'postRegister(nsIComponentManager,
  80.    *                                              nsIFile, componentsArray)'
  81.    * @param preUnregister optional pre-unregistration function with
  82.    *                      signature 'preUnregister(nsIComponentManager,
  83.    *                                               nsIFile, componentsArray)'
  84.    */
  85.   generateModule: function(componentsArray, postRegister, preUnregister) {
  86.     let classes = [];
  87.     for each (let component in componentsArray) {
  88.       classes.push({
  89.         cid:          component.prototype.classID,
  90.         className:    component.prototype.classDescription,
  91.         contractID:   component.prototype.contractID,
  92.         factory:      this._getFactory(component),
  93.         categories:   component.prototype._xpcom_categories,
  94.         version:      component.prototype.version,
  95.         registred:    false
  96.       });
  97.     }
  98.  
  99.     return { // nsIModule impl.
  100.       getClassObject: function(compMgr, cid, iid) {
  101.         // We only support nsIFactory queries, not nsIClassInfo
  102.         if (!iid.equals(Ci.nsIFactory))
  103.           throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  104.  
  105.         for each (let classDesc in classes) {
  106.           if (classDesc.cid.equals(cid))
  107.             return classDesc.factory;
  108.         }
  109.  
  110.         throw Cr.NS_ERROR_FACTORY_NOT_REGISTERED;
  111.       },
  112.  
  113.       registerSelf: function(compMgr, fileSpec, location, type) {
  114.         var componentCount = 0;
  115.         debug("*** registering " + fileSpec.leafName + ": [ ");
  116.         compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  117.         
  118.         var again = false;
  119.         var arbiter = null;
  120.         if ((ARBITER_CONTRACT_ID in Cc) && (compMgr.isContractIDRegistered(ARBITER_CONTRACT_ID)))
  121.           arbiter = Cc[ARBITER_CONTRACT_ID].getService(Ci.yIArbiter);
  122.         
  123.         for each (let classDesc in classes) {
  124.           debug((componentCount++ ? ", " : "") + classDesc.className);
  125.           
  126.           if (arbiter) {
  127.             if (classDesc.registred) {
  128.               if (arbiter.accept(classDesc.contractID, classDesc.version)) {
  129.                 compMgr.registerFactoryLocation(classDesc.cid,
  130.                                                 classDesc.className,
  131.                                                 classDesc.contractID,
  132.                                                 fileSpec,
  133.                                                 location,
  134.                                                 type);
  135.                 
  136.                 // categories
  137.                 if (classDesc.categories) {
  138.                   let catMan = XPCOMUtilsEx.categoryManager;
  139.                   for each (let cat in classDesc.categories) {
  140.                     let defaultValue = (cat.service ? "service," : "") + classDesc.contractID;
  141.                     catMan.addCategoryEntry(cat.category,
  142.                                             cat.entry || classDesc.className,
  143.                                             cat.value || defaultValue,
  144.                                             true, true);
  145.                   }
  146.                 }
  147.               }
  148.               continue;
  149.             }
  150.             else {
  151.               arbiter.register(classDesc.contractID, classDesc.version);
  152.               classDesc.registred = true;
  153.             }
  154.           }
  155.           
  156.           again = true;
  157.         } /* for */
  158.  
  159.         if (postRegister)
  160.           postRegister(compMgr, fileSpec, componentsArray);
  161.         debug(" ]\n");
  162.  
  163.         if (again)
  164.           throw Cr.NS_ERROR_FACTORY_REGISTER_AGAIN;
  165.       },
  166.  
  167.       unregisterSelf: function(compMgr, fileSpec, location) {
  168.         var componentCount = 0;
  169.         debug("*** unregistering " + fileSpec.leafName + ": [ ");
  170.         compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  171.         if (preUnregister)
  172.           preUnregister(compMgr, fileSpec, componentsArray);
  173.  
  174.         for each (let classDesc in classes) {
  175.           debug((componentCount++ ? ", " : "") + classDesc.className);
  176.           if (classDesc.categories) {
  177.             let catMan = XPCOMUtilsEx.categoryManager;
  178.             for each (let cat in classDesc.categories) {
  179.               catMan.deleteCategoryEntry(cat.category,
  180.                                          cat.entry || classDesc.className,
  181.                                          true);
  182.             }
  183.           }
  184.           compMgr.unregisterFactoryLocation(classDesc.cid, fileSpec);
  185.         }
  186.         debug(" ]\n");
  187.       },
  188.  
  189.       canUnload: function(compMgr) {
  190.         return true;
  191.       }
  192.     };
  193.   },
  194.  
  195.   /**
  196.    * Convenience access to category manager
  197.    */
  198.   get categoryManager() {
  199.     return Components.classes["@mozilla.org/categorymanager;1"]
  200.            .getService(Ci.nsICategoryManager);
  201.   },
  202.  
  203.   /**
  204.    * Returns an nsIFactory for |component|.
  205.    */
  206.   _getFactory: function(component) {
  207.     var factory = component.prototype._xpcom_factory;
  208.     if (!factory) {
  209.       factory = {
  210.         createInstance: function(outer, iid) {
  211.           if (outer != null)
  212.               throw Components.results.NS_ERROR_NO_AGGREGATION;
  213.           
  214.           if (!this._instance)
  215.               this._instance = new component();
  216.           return this._instance.QueryInterface(iid);
  217.         }
  218.       }
  219.     }
  220.     return factory;
  221.   }
  222. };
  223.  
  224. /**
  225.  * Helper for XPCOMUtilsEx.generateQI to avoid leaks - see bug 381651#c1
  226.  */
  227. function makeQI(interfaceNames) {
  228.   return function XPCOMUtilsEx_QueryInterface(iid) {
  229.     if (iid.equals(Ci.nsISupports))
  230.       return this;
  231.     
  232.     for each (let interfaceName in interfaceNames) {
  233.       if (Ci[interfaceName].equals(iid))
  234.         return this;
  235.     }
  236.  
  237.     throw Cr.NS_ERROR_NO_INTERFACE;
  238.   };
  239. }
  240.