View difference between Paste ID: axaNZDJC and

-
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
 
 /*
  * Modify Headers Header
  */
 function ModifyHeadersHeader() {
   this.aAction   = "";
   this.aName     = "";
   this.aValue    = "";
   this.aComment  = "";
   this.aEnabled  = false;
   this.aSelected = true;
 }
 
 ModifyHeadersHeader.prototype = {
   classDescription: "Modify Headers Header",
   classID:          Components.ID("{6b2f2fc7-a26c-4602-a08d-bd6d065a86e3}"),
   contractID:       "@modifyheaders.mozdev.org/header;1",
 
   QueryInterface: XPCOMUtils.generateQI([Components.interfaces.mhIHeader]),
 
   get action() { return this.aAction },
   set action(action) { this.aAction = action },
 
   get name() { return this.aName },
   set name(name) { this.aName = name },
 
   get value() { return this.aValue },
   set value(value) { this.aValue = value },
 
   get comment() { return this.aComment },
   set comment(comment) { this.aComment = comment },
 
   get enabled() { return this.aEnabled },
   set enabled(enabled) { this.aEnabled = enabled },
 
   get selected() { return this.aSelected },
   set selected(selected) { this.aSelected = selected },
 
   get wrappedJSObject() { return this },
 
   equals: function(obj) {
     return (this.action.toLowerCase() == obj.action.toLowerCase() && this.name.toLowerCase() == obj.name.toLowerCase() && this.value.toLowerCase() == obj.value.toLowerCase()) ? true : false;
   }
 }
 
 /* Defines the modifyheaders service for getting and setting headers */
 function ModifyHeadersService() {
   //dump("\nEntered ModifyHeadersService");
 
   this.headers = new Array();
   this.preferencesUtil = new PreferencesUtil();
 
   // Observer service is used to notify observing ModifyHeadersProxy objects that the headers have been updated
   this.observerService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
 
   this.initiated = false;
   this.winOpen = false;
   //dump("\nExiting ModifyHeadersService");
 }
 
 /*
  * Modify Headers Service
  */
 ModifyHeadersService.prototype = {
   classDescription: "Modify Headers Service",
   classID:          Components.ID("{feb80fc3-9e72-4fc5-bc72-986957ada6cc}"),
   contractID:       "@modifyheaders.mozdev.org/service;1",
 
   QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIModifyheaders]),
 
   get count() {
     if (!this.initiated) {
       this.init();
     }
 
     //dump("\nReturning the header count: " + this.headers.length);
     return this.headers.length;
   },
   set count(c) { /* Do nothing */ },
 
   get alwaysOn() {
     return this.preferencesUtil.getPreference("bool", PreferencesUtil.prefAlwaysOn);
   },
 
   set alwaysOn(alwaysOn) {
     this.preferencesUtil.setPreference("bool", PreferencesUtil.prefAlwaysOn, alwaysOn);
   },
 
   get openAsTab() {
     return this.preferencesUtil.getPreference("bool", PreferencesUtil.prefOpenAsTab);
   },
 
   set openAsTab(openAsTab) {
     this.preferencesUtil.setPreference("bool", PreferencesUtil.prefOpenAsTab, openAsTab);
   },
 
   get windowOpen() {
     return this.winOpen;
   },
 
   set windowOpen(winOpen) {
     this.winOpen = winOpen;
   },
 
   // Load the headers from the preferences
   init: function() {
     //dump("\nEntered ModifyHeadersService.init")
 
     this.headers = new Array();
 
     // Load the headers from the preferences
     var enabled;
     var action;
     var name;
     var value;
     var comment;
 
    	// Read preferences into headersArray
     var headerCount = this.preferencesUtil.getPreference("int", PreferencesUtil.prefHeaderCount);
 
    	for (var i=0; i < headerCount; i++) {
       name = this.preferencesUtil.getPreference("char", PreferencesUtil.prefHeaderName + i);
       value = this.preferencesUtil.getPreference("char", PreferencesUtil.prefHeaderValue + i);
       action = this.preferencesUtil.getPreference("char", PreferencesUtil.prefHeaderAction + i);
       comment = this.preferencesUtil.getPreference("char", PreferencesUtil.prefHeaderComment + i);
       enabled = this.preferencesUtil.getPreference("bool", PreferencesUtil.prefHeaderEnabled + i);
 
       this.addHeader(name, value, action, comment, enabled);
     }
 
     this.initiated = true;
     //dump("\nExiting ModifyHeadersService.init");
   },
 
   getHeader: function(index) {
     var objHeader = Components.classes["@modifyheaders.mozdev.org/header;1"].createInstance(Components.interfaces.mhIHeader);
     objHeader.action = this.headers[index]["action"];
     objHeader.name = this.headers[index]["name"];
     objHeader.value = this.headers[index]["value"];
     objHeader.comment = this.headers[index]["comment"];
     objHeader.enabled = this.headers[index]["enabled"];
 
     return objHeader;
   },
 
   getHeaders: function(count) {
     //dump("\nEntered ModifyHeadersService.getHeaders");
 
     var objHeader = null;
     var aHeaders = new Array();
 
     for (var i=0; i < this.headers.length; i++) {
       objHeader = this.getHeader(i);
       aHeaders[i] = objHeader;
     }
 
   	count.value = aHeaders.length;
   	//dump("\nReturning the header object");
   	return aHeaders;
   },
 
   getHeadersAsXML: function(strHeaderIndices) {
     //dump("\nEntered ModifyHeadersService.getHeadersAsJSONString: " + strHeaderIndices);
     var headerIndices = strHeaderIndices.split(",");
 
     var parser = Components.classes["@mozilla.org/xmlextras/domparser;1"].createInstance(Components.interfaces.nsIDOMParser);
     var headersXML = parser.parseFromString("<modifyheaders></modifyheaders>", "text/xml");
     var root = headersXML.documentElement;
 
     // Loop over the values
     for (var i=0; i < headerIndices.length; i++) {
       objHeader = this.getHeader(headerIndices[i]);
 
       var action = headersXML.createTextNode(objHeader.action);
       var actionElem = headersXML.createElement("action");
       actionElem.appendChild(action);
 
       var name = headersXML.createTextNode(objHeader.name);
       var nameElem = headersXML.createElement("name");
       nameElem.appendChild(name);
 
       var value = headersXML.createTextNode(objHeader.value);
       var valueElem = headersXML.createElement("value");
       valueElem.appendChild(value);
 
       var comment = headersXML.createTextNode(objHeader.comment);
       var commentElem = headersXML.createElement("comment");
       commentElem.appendChild(comment);
 
       var header = headersXML.createElement("header");
       header.appendChild(actionElem);
       header.appendChild(nameElem);
       header.appendChild(valueElem);
       header.appendChild(commentElem);
 
       root.appendChild(header);
     }
 
     var serializer = Components.classes["@mozilla.org/xmlextras/xmlserializer;1"].createInstance(Components.interfaces.nsIDOMSerializer);
 
     //dump("\nExiting ModifyHeadersService.getHeadersAsJSONString");
     // Return a XML string
     return "<?xml version=\"1.0\"?>" + serializer.serializeToString(headersXML);
   },
 
   // Adds a header to the headers array
   addHeader: function(name, value, action, comment, enabled) {
     //dump("\nEntered ModifyHeadersService.addHeader");
 
     // TODO Validate the arguments
 
     // Add the header to the Array
     var header = new Array();
     header["enabled"] = enabled;
     header["action"]  = action;
     header["name"]    = name;
     header["value"]   = value;
     header["comment"] = comment;
 
     this.headers.push(header);
 
     this.savePreferences();
     //dump("\nExiting ModifyHeadersService.addHeader");
   },
 
   setHeader: function(index, name, value, action, comment, enabled) {
     //dump("\nEntered ModifyHeadersService.setHeader");
 
     // TODO Validate the arguments
 
     // Update the values
     this.headers[index]["enabled"] = enabled;
     this.headers[index]["action"]  = action;
     this.headers[index]["name"]    = name;
     this.headers[index]["value"]   = value;
     this.headers[index]["comment"] = comment;
 
     this.savePreferences()
     //dump("\nExiting ModifyHeadersService.setHeader")
   },
 
   // Remove the header with the specified index
   removeHeader: function(index) {
     //dump("\nEntered ModifyHeadersService.removeHeader");
     this.headers.splice(index, 1);
     this.savePreferences();
     //dump("\nExiting ModifyHeadersService.removeHeader");
   },
 
   isHeaderEnabled: function(index) {
     return this.headers[index]["enabled"];
   },
 
   setHeaderEnabled: function(index, enabled) {
     this.headers[index]["enabled"] = enabled;
     this.savePreferences();
   },
 
   getHeaderAction: function(index) {
     return this.headers[index]["action"];
   },
 
   getHeaderName: function(index) {
     return this.headers[index]["name"];
   },
 
   getHeaderValue: function(index) {
     return this.headers[index]["value"];
   },
 
   getHeaderComment: function(index) {
     return this.headers[index]["comment"];
   },
 
   switchHeaders: function(index1, index2) {
     var header = this.headers[index1];
     this.headers[index1] = this.headers[index2];
     this.headers[index2] = header;
     this.savePreferences();
   },
 
   // Persist the headers to the preferences.
   savePreferences: function() {
     //dump("\nEntered ModifyHeadersService.savePreferences");
     // Only save headers if the service has been initiated
     if (this.initiated) {
       // TODO Clear the preferences first
       // This ensures old headers are not maintained in the preferences
       // I'm sure there is a better way than this
 
       // Loop over the headers
       for (var i=0; i < this.count; i++) {
         this.preferencesUtil.setPreference("char", PreferencesUtil.prefHeaderAction + i, this.headers[i]["action"]);
         this.preferencesUtil.setPreference("char", PreferencesUtil.prefHeaderName + i, this.headers[i]["name"]);
         this.preferencesUtil.setPreference("char", PreferencesUtil.prefHeaderValue + i, this.headers[i]["value"]);
         this.preferencesUtil.setPreference("char", PreferencesUtil.prefHeaderComment + i, this.headers[i]["comment"]);
         this.preferencesUtil.setPreference("bool", PreferencesUtil.prefHeaderEnabled + i, this.headers[i]["enabled"]);
       }
 
       this.preferencesUtil.setPreference("int", PreferencesUtil.prefHeaderCount, this.count);
     }
     //dump("\nExiting ModifyHeadersService.savePreferences");
   },
 
   // Clear the headers from their preferences
   clearPreferences: function() {
     // Loop over the headers
     for (var i=0; i < this.count; i++) {
       this.preferencesUtil.deletePreference(PreferencesUtil.prefHeaderAction + i);
       this.preferencesUtil.deletePreference(PreferencesUtil.prefHeaderEnabled + i);
       this.preferencesUtil.deletePreference(PreferencesUtil.prefHeaderName + i);
       this.preferencesUtil.deletePreference(PreferencesUtil.prefHeaderValue + i);
       this.preferencesUtil.deletePreference(PreferencesUtil.prefHeaderComment + i);
     }
   }
 }
 
 /*
  * Modify Headers Proxy
  */
 function ModifyHeadersProxy() {
   //dump("\nEntered ModifyHeadersProxy");
   this.headers = new Array();
   this.preferencesUtil = new PreferencesUtil();
 
   this.modifyheadersService = Components.classes["@modifyheaders.mozdev.org/service;1"].getService(Components.interfaces.nsIModifyheaders);
   //dump("\nExiting ModifyHeadersProxy");
 }
 
 ModifyHeadersProxy.prototype = {
   classDescription: "Modify Headers Proxy",
   classID:          Components.ID("{0eff9eeb-c51a-4f07-9823-27bc32fdae13}"),
   contractID:       "@modifyheaders.mozdev.org/proxy;1",
 
   QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIObserver]),
 
   _xpcom_categories: [
     {
       category: "profile-after-change",
       entry: "Modify Headers Proxy"
     }
   ],
 
 
   // nsIObserver interface method
   observe: function(subject, topic, data) {
 
     //dump("\nEntered ModifyHeadersProxy.prototype.observe");
 
     if (topic == 'http-on-modify-request') {
       //dump("\ntopic is http-on-modify-request");
       subject.QueryInterface(Components.interfaces.nsIHttpChannel);
 
       if (this.modifyheadersService.windowOpen || this.modifyheadersService.alwaysOn) {
         var headerCount = this.modifyheadersService.count;
 
         for (var i=0; i < headerCount; i++) {
           //dump("\niteration: " + i);
 
           if (this.modifyheadersService.isHeaderEnabled(i)) {
             var headerName = this.modifyheadersService.getHeaderName(i);
 
             // This is the default for action = Modify
             var headerValue = this.modifyheadersService.getHeaderValue(i);
             var headerAppend = false;
 
             if (this.modifyheadersService.getHeaderAction(i) == "Add") {
               headerAppend = true;
             } else if (this.modifyheadersService.getHeaderAction(i) == "Filter") {
               headerValue = "";
             }
             //dump("\nAdded header: " + headerName);
             subject.setRequestHeader(headerName, headerValue, headerAppend);
           }
         }
         // TODO Add an optional ModifyHeaders header so that users know the tool is active
         // subject.setRequestHeader("x-modifyheaders", "version 0.4", true)
       }
     } else if (topic == 'profile-after-change') {
       //dump("\ntopic is profile-after-change");
 
       if ("nsINetModuleMgr" in Components.interfaces) {
         // Should be an old version of Mozilla (before september 15, 2003
         // Do Nothing as these old versions of firefox (firebird, phoenix etc) are not supported
   	  } else {
         // Should be a new version of  Mozilla (after september 15, 2003)
         var observerService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
         observerService.addObserver(this, "http-on-modify-request", false);
       }
     } else {
       //dump("\nNo observable topic defined");
     }
     //dump("\nExiting ModifyHeadersProxy.prototype.observe");
   }
 }
 
 //A utility class for getting and setting user preferences
 function PreferencesUtil() {
   //dump("\nEntered PreferencesUtil");
   this.prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);
   this.prefService = this.prefService.getBranch("");
   //dump("\nExiting PreferencesUtil");
 }
 
 // Static strings that specify the names of the preferences used by modifyheaders
 PreferencesUtil.prefAlwaysOn      = "modifyheaders.config.alwaysOn";
 PreferencesUtil.prefHeaderCount   = "modifyheaders.headers.count";
 PreferencesUtil.prefHeaderAction  = "modifyheaders.headers.action";
 PreferencesUtil.prefHeaderEnabled = "modifyheaders.headers.enabled";
 PreferencesUtil.prefHeaderName    = "modifyheaders.headers.name";
 PreferencesUtil.prefHeaderValue   = "modifyheaders.headers.value";
 PreferencesUtil.prefHeaderComment = "modifyheaders.headers.comment";
 PreferencesUtil.prefLogMsgs       = "modifyheaders.config.logMsgs";
 PreferencesUtil.prefOpenAsTab     = "modifyheaders.config.openNewTab";
 
 // Convenience method to get a user preference value
 PreferencesUtil.prototype.getPreference = function(type, name) {
   var prefValue;
 
   if (this.prefService.prefHasUserValue(name)) {
     if (type=='bool') {
       prefValue = this.prefService.getBoolPref(name);
     } else if (type=='char') {
       prefValue = this.prefService.getCharPref(name);
     } else if (type=='int') {
       prefValue = this.prefService.getIntPref(name);
     }
 
   // Set the preference with a default value
   } else {
     if (type=='bool') {
  	    this.setPreference(type, name, false);
  	    prefValue = false;
     } else if (type=='char') {
  	    this.setPreference(type, name, "");
  	    prefValue = "";
     } else if (type=='int') {
       this.setPreference(type, name, 0);
       prefValue = 0;
     }
   }
 
   return prefValue;
 }
 
 // Convenience method to set a user preference
 PreferencesUtil.prototype.setPreference = function(type, name, value) {
   if (type=='bool') {
     this.prefService.setBoolPref(name, value);
   } else if (type=='char') {
     this.prefService.setCharPref(name, value);
   } else if (type=='int') {
     this.prefService.setIntPref(name, value);
   }
 }
 
 PreferencesUtil.prototype.deletePreference = function(name) {
   this.prefService.clearUserPref(name);
 }
 
 /* Entry point - registers the component with the browser */
 if (XPCOMUtils.generateNSGetFactory) {
 	//dump("\nUsing NSGetFactory");
     var NSGetFactory = XPCOMUtils.generateNSGetFactory([ModifyHeadersService,ModifyHeadersHeader,ModifyHeadersProxy]);
 } else {
 	//dump("\nUsing NSGetModule");
     var NSGetModule = XPCOMUtils.generateNSGetModule([ModifyHeadersService,ModifyHeadersHeader,ModifyHeadersProxy]);
 }