Bug 1280898 - Set up eslint for calendar files - enable func-names rule. r=MakeMyDay
authoreslint <eslint@bugzilla.kewis.ch>
Fri, 08 Jul 2016 14:09:04 +0200
changeset 26001 5e136b6a5e3e41cb11cdea756880e425c08d853c
parent 26000 a53c49ed8ab37da97d6a5fc6f660efd9841a259b
child 26002 289338a394d31814b30269ba6752035e303e04a3
push id1771
push userclokep@gmail.com
push dateMon, 14 Nov 2016 17:47:53 +0000
treeherdercomm-beta@399ae9d71595 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersMakeMyDay
bugs1280898
Bug 1280898 - Set up eslint for calendar files - enable func-names rule. r=MakeMyDay MozReview-Commit-ID: DgsK9FXLRFz
calendar/.eslintrc
calendar/base/backend/calBackendLoader.js
calendar/base/backend/icaljs/calICSService-worker.js
calendar/base/backend/icaljs/calICSService.js
calendar/base/content/agenda-listbox.js
calendar/base/content/calendar-base-view.xml
calendar/base/content/calendar-common-sets.js
calendar/base/content/calendar-extract.js
calendar/base/content/calendar-invitations-manager.js
calendar/base/content/calendar-item-editing.js
calendar/base/content/calendar-management.js
calendar/base/content/calendar-menus.xml
calendar/base/content/calendar-statusbar.js
calendar/base/content/calendar-task-editing.js
calendar/base/content/calendar-task-tree.xml
calendar/base/content/calendar-task-view.js
calendar/base/content/calendar-unifinder.js
calendar/base/content/calendar-view-core.xml
calendar/base/content/calendar-views.js
calendar/base/content/calendar-views.xml
calendar/base/content/dialogs/calendar-alarm-dialog.js
calendar/base/content/dialogs/calendar-event-dialog-attendees.js
calendar/base/content/dialogs/calendar-event-dialog-attendees.xml
calendar/base/content/dialogs/calendar-event-dialog-freebusy.xml
calendar/base/content/dialogs/calendar-event-dialog-recurrence-preview.xml
calendar/base/content/dialogs/calendar-invitations-dialog.js
calendar/base/content/dialogs/calendar-print-dialog.js
calendar/base/content/dialogs/calendar-subscriptions-dialog.js
calendar/base/content/dialogs/calendar-summary-dialog.js
calendar/base/content/import-export.js
calendar/base/content/preferences/alarms.js
calendar/base/content/preferences/categories.js
calendar/base/content/preferences/general.js
calendar/base/content/preferences/views.js
calendar/base/content/today-pane.js
calendar/base/content/widgets/calendar-list-tree.xml
calendar/base/modules/calAlarmUtils.jsm
calendar/base/modules/calAuthUtils.jsm
calendar/base/modules/calExtract.jsm
calendar/base/modules/calHashedArray.jsm
calendar/base/modules/calItemUtils.jsm
calendar/base/modules/calIteratorUtils.jsm
calendar/base/modules/calItipUtils.jsm
calendar/base/modules/calPrintUtils.jsm
calendar/base/modules/calProviderUtils.jsm
calendar/base/modules/calUtils.jsm
calendar/base/modules/calXMLUtils.jsm
calendar/base/src/calAlarm.js
calendar/base/src/calAlarmMonitor.js
calendar/base/src/calAlarmService.js
calendar/base/src/calAttachment.js
calendar/base/src/calAttendee.js
calendar/base/src/calCachedCalendar.js
calendar/base/src/calCalendarManager.js
calendar/base/src/calCalendarSearchService.js
calendar/base/src/calDateTimeFormatter.js
calendar/base/src/calDefaultACLManager.js
calendar/base/src/calDeletedItems.js
calendar/base/src/calEvent.js
calendar/base/src/calFilter.js
calendar/base/src/calFreeBusyService.js
calendar/base/src/calIcsParser.js
calendar/base/src/calIcsSerializer.js
calendar/base/src/calItemBase.js
calendar/base/src/calItipItem.js
calendar/base/src/calProtocolHandler.js
calendar/base/src/calRecurrenceDate.js
calendar/base/src/calRecurrenceInfo.js
calendar/base/src/calRelation.js
calendar/base/src/calSleepMonitor.js
calendar/base/src/calStartupService.js
calendar/base/src/calTimezone.js
calendar/base/src/calTimezoneService.js
calendar/base/src/calTodo.js
calendar/base/src/calTransactionManager.js
calendar/base/src/calUtils.js
calendar/import-export/calHtmlExport.js
calendar/import-export/calIcsImportExport.js
calendar/import-export/calListFormatter.js
calendar/import-export/calMonthGridPrinter.js
calendar/import-export/calOutlookCSVImportExport.js
calendar/import-export/calWeekPrinter.js
calendar/itip/calItipEmailTransport.js
calendar/lightning/components/lightningTextCalendarConverter.js
calendar/lightning/content/imip-bar.js
calendar/lightning/content/lightning-calendar-creation.js
calendar/lightning/content/lightning-calendar-properties.js
calendar/lightning/content/lightning-item-iframe.js
calendar/lightning/content/messenger-overlay-preferences.js
calendar/lightning/content/messenger-overlay-sidebar.js
calendar/lightning/content/suite-overlay-sidebar.js
calendar/providers/caldav/calDavCalendar.js
calendar/providers/caldav/calDavRequestHandlers.js
calendar/providers/composite/calCompositeCalendar.js
calendar/providers/ics/calICSCalendar.js
calendar/providers/memory/calMemoryCalendar.js
calendar/providers/storage/calStorageCalendar.js
calendar/providers/storage/calStorageUpgrade.jsm
calendar/providers/wcap/calWcapCalendar.js
calendar/providers/wcap/calWcapCalendarItems.js
calendar/providers/wcap/calWcapRequest.js
calendar/providers/wcap/calWcapSession.js
calendar/providers/wcap/calWcapUtils.js
calendar/test/unit/.eslintrc
calendar/test/unit/head_consts.js
calendar/test/unit/test_alarmservice.js
calendar/test/unit/test_bug494140.js
calendar/test/unit/test_calmgr.js
calendar/test/unit/test_deleted_items.js
calendar/test/unit/test_gdata_provider.js
calendar/test/unit/test_ics.js
calendar/test/unit/test_storage.js
--- a/calendar/.eslintrc
+++ b/calendar/.eslintrc
@@ -383,13 +383,16 @@
     "consistent-this": [2, "self"],
 
     // Disallow unnecessary .call() and .apply()
     "no-useless-call": 2,
 
     // Require dot notation when accessing properties
     "dot-notation": 2,
 
+    // Disallow named function expressions
+    "func-names": [2, "never"],
+
     // The following rules will not be enabled currently, but are kept here for
     // easier updates in the future.
     "no-else-return": 0,
   }
 }
--- a/calendar/base/backend/calBackendLoader.js
+++ b/calendar/base/backend/calBackendLoader.js
@@ -28,17 +28,17 @@ calBackendLoader.prototype = {
     }),
 
     loaded: false,
 
     observe: function() {
         // Nothing to do here, just need the entry so this is instanciated
     },
 
-    loadBackend: function loadBackend() {
+    loadBackend: function() {
         if (this.loaded) {
             return;
         }
 
         let backend = Services.prefs.getBoolPref("calendar.icaljs") ? "icaljs" : "libical";
 
         let uri = Services.io.getProtocolHandler("resource")
                           .QueryInterface(Components.interfaces.nsIResProtocolHandler)
--- a/calendar/base/backend/icaljs/calICSService-worker.js
+++ b/calendar/base/backend/icaljs/calICSService-worker.js
@@ -6,17 +6,17 @@
  * ChromeWorker for parseICSAsync method in calICSService.js
  */
 
 var NS_OK = 0;
 var NS_ERROR_FAILURE = 2147500037;
 
 importScripts("resource://calendar/modules/ical.js");
 
-onmessage = function onmessage(event) {
+onmessage = function(event) {
     try {
         let comp = ICAL.parse(event.data);
         postMessage({ rc: NS_OK, data: comp });
     } catch (e) {
         postMessage({ rc: NS_ERROR_FAILURE, data: "Exception occurred: " + e });
     }
     close();
 };
--- a/calendar/base/backend/icaljs/calICSService.js
+++ b/calendar/base/backend/icaljs/calICSService.js
@@ -349,17 +349,17 @@ calIcalComponent.prototype = {
 
     addSubcomponent: function(comp) {
         comp.getReferencedTimezones({}).forEach(this.addTimezoneReference, this);
         let jscomp = unwrapSingle(ICAL.Component, comp);
         this.innerObject.addSubcomponent(jscomp);
     },
 
     propertyIterator: null,
-    getFirstProperty: function getFirstProperty(kind) {
+    getFirstProperty: function(kind) {
         if (kind == "ANY") {
             kind = null;
         } else if (kind) {
             kind = kind.toLowerCase();
         }
         let innerObject = this.innerObject;
         this.propertyIterator = (function* () {
             let props = innerObject.getAllProperties(kind);
@@ -382,17 +382,17 @@ calIcalComponent.prototype = {
                     yield new calIcalProperty(prop);
                 }
             }
         })();
 
         return this.getNextProperty(kind);
     },
 
-    getNextProperty: function getNextProperty(kind) {
+    getNextProperty: function(kind) {
         if (this.propertyIterator) {
             let next = this.propertyIterator.next();
             if (next.done) {
                 this.propertyIterator = null;
             }
 
             return next.value;
         } else {
@@ -462,24 +462,24 @@ calICSService.prototype = {
     classID: calICSServiceClassID,
     classInfo: XPCOMUtils.generateCI({
         contractID: "@mozilla.org/calendar/ics-service;1",
         classDescription: "ICS component and property service",
         classID: calICSServiceClassID,
         interfaces: [Components.interfaces.calIICSService]
     }),
 
-    parseICS: function parseICS(serialized, tzProvider) {
+    parseICS: function(serialized, tzProvider) {
         // TODO ical.js doesn't support tz providers, but this is usually null
         // or our timezone service anyway.
         let comp = ICAL.parse(serialized);
         return new calIcalComponent(new ICAL.Component(comp));
     },
 
-    parseICSAsync: function parseICSAsync(serialized, tzProvider, listener) {
+    parseICSAsync: function(serialized, tzProvider, listener) {
         // There are way too many error checking messages here, but I had so
         // much pain with this method that I don't want it to break again.
         try {
             let worker = new ChromeWorker("resource://calendar/calendar-js/calICSService-worker.js");
             worker.onmessage = function(event) {
                 let rc = Components.results.NS_ERROR_FAILURE;
                 let icalComp = null;
                 try {
@@ -501,20 +501,20 @@ calICSService.prototype = {
             worker.postMessage(serialized);
         } catch (e) {
             // If an error occurs above, the calling code will hang. Catch the exception just in case
             cal.ERROR("[calICSService] Error starting parsing worker: " + e);
             listener.onParsingComplete(Components.results.NS_ERROR_FAILURE, null);
         }
     },
 
-    createIcalComponent: function createIcalComponent(kind) {
+    createIcalComponent: function(kind) {
         return new calIcalComponent(new ICAL.Component(kind.toLowerCase()));
     },
 
-    createIcalProperty: function createIcalProperty(kind) {
+    createIcalProperty: function(kind) {
         return new calIcalProperty(new ICAL.Property(kind.toLowerCase()));
     },
 
     createIcalPropertyFromString: function(str) {
         return new calIcalProperty(ICAL.Property.fromString(str.trim(), ICAL.design.icalendar));
     }
 };
--- a/calendar/base/content/agenda-listbox.js
+++ b/calendar/base/content/agenda-listbox.js
@@ -18,58 +18,56 @@ var agendaListbox = {
     kDefaultTimezone: null,
     showsToday: false,
     soonDays: 5
 };
 
 /**
  * Initialize the agenda listbox, used on window load.
  */
-agendaListbox.init =
-function initAgendaListbox() {
+agendaListbox.init = function() {
     this.agendaListboxControl = document.getElementById("agenda-listbox");
     this.agendaListboxControl.removeAttribute("suppressonselect");
     let showTodayHeader = (document.getElementById("today-header-hidden").getAttribute("checked") == "true");
     let showTomorrowHeader = (document.getElementById("tomorrow-header-hidden").getAttribute("checked") == "true");
     let showSoonHeader = (document.getElementById("nextweek-header-hidden").getAttribute("checked") == "true");
     this.today = new Synthetic(showTodayHeader, 1, false);
     this.addPeriodListItem(this.today, "today-header");
     this.tomorrow = new Synthetic(showTomorrowHeader, 1, false);
     this.soonDays = getSoondaysPreference();
     this.soon = new Synthetic(showSoonHeader, this.soonDays, true);
     this.periods = [this.today, this.tomorrow, this.soon];
     this.mPendingRefreshJobs = new Map();
 
     let prefObserver = {
-        observe: function aL_observe(aSubject, aTopic, aPrefName) {
+        observe: function(aSubject, aTopic, aPrefName) {
             switch (aPrefName) {
                 case "calendar.agendaListbox.soondays":
                     agendaListbox.soonDays = getSoondaysPreference();
                     agendaListbox.updateSoonSection();
                     break;
             }
         }
     };
     Services.prefs.addObserver("calendar.agendaListbox", prefObserver, false);
 
     // Make sure the agenda listbox is unloaded
     let self = this;
     window.addEventListener("unload",
-                            function unload_agendaListbox() {
+                            function() {
                                 Services.prefs.removeObserver("calendar.agendaListbox", prefObserver);
                                 self.uninit();
                             },
                             false);
 };
 
 /**
  * Clean up the agenda listbox, used on window unload.
  */
-agendaListbox.uninit =
-function uninit() {
+agendaListbox.uninit = function() {
     if (this.calendar) {
         this.calendar.removeObserver(this.calendarObserver);
     }
 
     for (let period of this.periods) {
         if (period.listItem) {
             period.listItem.getCheckbox()
                   .removeEventListener("CheckboxStateChange",
@@ -83,47 +81,44 @@ function uninit() {
  * Adds a period item to the listbox. This is a section of the today pane like
  * "Today", "Tomorrow", and is usually a <agenda-checkbox-richlist-item> tag. A
  * copy of the template node is made and added to the agenda listbox.
  *
  * @param aPeriod       The period item to add.
  * @param aItemId       The id of an <agenda-checkbox-richlist-item> to add to,
  *                        without the "-hidden" suffix.
  */
-agendaListbox.addPeriodListItem =
-function addPeriodListItem(aPeriod, aItemId) {
+agendaListbox.addPeriodListItem = function(aPeriod, aItemId) {
     aPeriod.listItem = document.getElementById(aItemId + "-hidden").cloneNode(true);
     agendaListbox.agendaListboxControl.appendChild(aPeriod.listItem);
     aPeriod.listItem.id = aItemId;
     aPeriod.listItem.getCheckbox().setChecked(aPeriod.open);
     aPeriod.listItem.getCheckbox().addEventListener("CheckboxStateChange", this.onCheckboxChange, true);
 };
 
 /**
  * Remove a period item from the agenda listbox.
  * @see agendaListbox::addPeriodListItem
  */
-agendaListbox.removePeriodListItem =
-function removePeriodListItem(aPeriod) {
+agendaListbox.removePeriodListItem = function(aPeriod) {
     if (aPeriod.listItem) {
         aPeriod.listItem.getCheckbox().removeEventListener("CheckboxStateChange", this.onCheckboxChange, true);
         if (aPeriod.listItem) {
             aPeriod.listItem.remove();
             aPeriod.listItem = null;
         }
     }
 };
 
 /**
  * Handler function called when changing the checkbox state on period items.
  *
  * @param event     The DOM event that triggered the checkbox state change.
  */
-agendaListbox.onCheckboxChange =
-function onCheckboxChange(event) {
+agendaListbox.onCheckboxChange = function(event) {
     let periodCheckbox = event.target;
     let lopen = (periodCheckbox.getAttribute("checked") == "true");
     let listItem = getParentNodeOrThis(periodCheckbox, "agenda-checkbox-richlist-item");
     let period = listItem.getItem();
     period.open = lopen;
     // as the agenda-checkboxes are only transient we have to set the "checked"
     // attribute at their hidden origins to make that attribute persistent.
     document.getElementById(listItem.id + "-hidden").setAttribute("checked",
@@ -148,48 +143,44 @@ function onCheckboxChange(event) {
     calendarController.onSelectionChanged({ detail: [] });
 };
 
 /**
  * Handler function called when an agenda listbox item is selected
  *
  * @param aListItem     The agenda-base-richlist-item that was selected.
  */
-agendaListbox.onSelect =
-function onSelect(aListItem) {
+agendaListbox.onSelect = function(aListItem) {
     let listbox = document.getElementById("agenda-listbox");
     let item = aListItem || listbox.selectedItem;
     if (aListItem) {
         listbox.selectedItem = item;
     }
     calendarController.onSelectionChanged({ detail: agendaListbox.getSelectedItems() });
 };
 
 /**
  * Handler function called when the agenda listbox becomes focused
  */
-agendaListbox.onFocus =
-function onFocus() {
+agendaListbox.onFocus = function() {
     calendarController.onSelectionChanged({ detail: agendaListbox.getSelectedItems() });
 };
 
 /**
  * Handler function called when the agenda listbox loses focus.
  */
-agendaListbox.onBlur =
-function onBlur() {
+agendaListbox.onBlur = function() {
     calendarController.onSelectionChanged({ detail: [] });
 };
 
 
 /**
  * Handler function called when a key was pressed on the agenda listbox
  */
-agendaListbox.onKeyPress =
-function onKeyPress(aEvent) {
+agendaListbox.onKeyPress = function(aEvent) {
     let listItem = aEvent.target;
     if (listItem.localName == "richlistbox") {
         listItem = listItem.selectedItem;
     }
     switch (aEvent.keyCode) {
         case aEvent.DOM_VK_RETURN:
             document.getElementById("agenda_edit_event_command").doCommand();
             break;
@@ -209,63 +200,59 @@ function onKeyPress(aEvent) {
             }
             break;
     }
 };
 
 /**
  * Calls the event dialog to edit the currently selected item
  */
-agendaListbox.editSelectedItem =
-function editSelectedItem() {
+agendaListbox.editSelectedItem = function() {
     let listItem = document.getElementById("agenda-listbox").selectedItem;
     if (listItem) {
         modifyEventWithDialog(listItem.occurrence, null, true);
     }
 };
 
 /**
  * Finds the appropriate period for the given item, i.e finds "Tomorrow" if the
  * item occurrs tomorrow.
  *
  * @param aItem     The item to find the period for.
  */
-agendaListbox.findPeriodsForItem =
-function findPeriodsForItem(aItem) {
+agendaListbox.findPeriodsForItem = function(aItem) {
     let retPeriods = [];
     for (let i = 0; i < this.periods.length; i++) {
         if (this.periods[i].open) {
             if (checkIfInRange(aItem, this.periods[i].start, this.periods[i].end)) {
                 retPeriods.push(this.periods[i]);
             }
         }
     }
     return retPeriods;
 };
 
 /**
  * Gets the start of the earliest period shown in the agenda listbox
  */
-agendaListbox.getStart =
-function getStart() {
+agendaListbox.getStart = function() {
     let retStart = null;
     for (let i = 0; i < this.periods.length; i++) {
         if (this.periods[i].open) {
             retStart = this.periods[i].start;
             break;
         }
     }
     return retStart;
 };
 
 /**
  * Gets the end of the latest period shown in the agenda listbox
  */
-agendaListbox.getEnd =
-function getEnd() {
+agendaListbox.getEnd = function() {
     let retEnd = null;
     for (let i = this.periods.length - 1; i >= 0; i--) {
         if (this.periods[i].open) {
             retEnd = this.periods[i].end;
             break;
         }
     }
     return retEnd;
@@ -275,18 +262,17 @@ function getEnd() {
  * Adds an item to an agenda period before another existing item.
  *
  * @param aNewItem      The calIItemBase to add.
  * @param aAgendaItem   The existing item to insert before.
  * @param aPeriod       The period to add the item to.
  * @param visible       If true, the item should be visible.
  * @return              The newly created XUL element.
  */
-agendaListbox.addItemBefore =
-function addItemBefore(aNewItem, aAgendaItem, aPeriod, visible) {
+agendaListbox.addItemBefore = function(aNewItem, aAgendaItem, aPeriod, visible) {
     let newelement = null;
     if (aNewItem.startDate.isDate) {
         newelement = createXULElement("agenda-allday-richlist-item");
     } else {
         newelement = createXULElement("agenda-richlist-item");
     }
     // set the item at the richlistItem. When the duration of the period
     // is bigger than 1 (day) the starttime of the item has to include
@@ -303,18 +289,17 @@ function addItemBefore(aNewItem, aAgenda
 
 /**
  * Adds an item to the agenda listbox. This function finds the correct period
  * for the item and inserts it correctly so the period stays sorted.
  *
  * @param aItem         The calIItemBase to add.
  * @return              The newly created XUL element.
  */
-agendaListbox.addItem =
-function addItem(aItem) {
+agendaListbox.addItem = function(aItem) {
     if (!isEvent(aItem)) {
         return null;
     }
     let periods = this.findPeriodsForItem(aItem);
     if (periods.length == 0) {
         return null;
     }
     let newlistItem = null;
@@ -358,18 +343,17 @@ function addItem(aItem) {
 /**
  * Checks if the given item happens before the comparison item.
  *
  * @param aItem         The item to compare.
  * @param aCompItem     The item to compare with.
  * @param aPeriod       The period where the items are inserted.
  * @return              True, if the aItem happens before aCompItem.
  */
-agendaListbox.isBefore =
-function isBefore(aItem, aCompItem, aPeriod) {
+agendaListbox.isBefore = function(aItem, aCompItem, aPeriod) {
     let itemDate = this.comparisonDate(aItem, aPeriod);
     let compItemDate = this.comparisonDate(aCompItem, aPeriod);
     let itemDateEndDate = itemDate.clone();
     itemDateEndDate.day++;
 
     if (compItemDate.day == itemDate.day) {
         // In the same day the order is:
         // - all-day events (single day);
@@ -411,18 +395,17 @@ function isBefore(aItem, aCompItem, aPer
 /**
  * Returns the start or end date of an item according to which of them
  * must be displayed in a given period of the agenda
  *
  * @param aItem         The item to compare.
  * @param aPeriod       The period where the item is inserted.
  * @return              The start or end date of the item showed in the agenda.
  */
-agendaListbox.comparisonDate =
-function comparisonDate(aItem, aPeriod) {
+agendaListbox.comparisonDate = function(aItem, aPeriod) {
     let periodStartDate = aPeriod.start.clone();
     periodStartDate.isDate = true;
     let periodEndDate = aPeriod.end.clone();
     periodEndDate.day--;
     let startDate = aItem.startDate.clone();
     startDate.isDate = true;
     let endDate = aItem.endDate.clone();
 
@@ -450,18 +433,17 @@ function comparisonDate(aItem, aPeriod) 
 
 /**
  * Gets the listitems for a given item, possibly in a given period.
  *
  * @param aItem         The item to get the list items for.
  * @param aPeriod       (optional) the period to search in.
  * @return              An array of list items for the given item.
  */
-agendaListbox.getListItems =
-function getListItems(aItem, aPeriod) {
+agendaListbox.getListItems = function(aItem, aPeriod) {
     let retlistItems = [];
     let periods = [aPeriod];
     if (!aPeriod) {
         periods = this.findPeriodsForItem(aItem);
     }
     if (periods.length > 0) {
         for (let i = 0; i < periods.length; i++) {
             let period = periods[i];
@@ -485,18 +467,17 @@ function getListItems(aItem, aPeriod) {
 /**
  * Removes the given item from the agenda listbox
  *
  * @param aItem             The item to remove.
  * @param aMoveSelection    If true, the selection will be moved to the next
  *                            sibling that is not an period item.
  * @return                  Returns true if the removed item was selected.
  */
-agendaListbox.deleteItem =
-function deleteItem(aItem, aMoveSelection) {
+agendaListbox.deleteItem = function(aItem, aMoveSelection) {
     let isSelected = false;
     let listItems = this.getListItems(aItem);
     if (listItems.length > 0) {
         for (let i = listItems.length - 1; i >= 0; i--) {
             let listItem = listItems[i];
             let isSelected2 = listItem.selected;
             if (isSelected2 && !isSelected) {
                 isSelected = true;
@@ -510,18 +491,17 @@ function deleteItem(aItem, aMoveSelectio
     return isSelected;
 };
 
 /**
  * Remove all items belonging to the specified calendar.
  *
  * @param aCalendar         The item to compare.
  */
-agendaListbox.deleteItemsFromCalendar =
-function deleteItemsFromCalendar(aCalendar) {
+agendaListbox.deleteItemsFromCalendar = function(aCalendar) {
     let childNodes = Array.from(this.agendaListboxControl.childNodes);
     for (let childNode of childNodes) {
         if (childNode && childNode.occurrence &&
             childNode.occurrence.calendar.id == aCalendar.id) {
             childNode.remove();
         }
     }
 };
@@ -529,80 +509,75 @@ function deleteItemsFromCalendar(aCalend
 /**
  * Compares two items to see if they have the same id and their start date
  * matches
  *
  * @param aItem         The item to compare.
  * @param aCompItem     The item to compare with.
  * @return              True, if the items match with the above noted criteria.
  */
-agendaListbox.isSameEvent =
-function isSameEvent(aItem, aCompItem) {
+agendaListbox.isSameEvent = function(aItem, aCompItem) {
     return aItem.id == aCompItem.id &&
            aItem[calGetStartDateProp(aItem)].compare(aCompItem[calGetStartDateProp(aCompItem)]) == 0;
 };
 
 /**
  * Checks if the currently selected node in the listbox is an Event item (not a
  * period item).
  *
  * @return              True, if the node is not a period item.
  */
-agendaListbox.isEventSelected =
-function isEventSelected() {
+agendaListbox.isEventSelected = function() {
     let listItem = this.agendaListboxControl.selectedItem;
     if (listItem) {
         return this.isEventListItem(listItem);
     }
     return false;
 };
 
 /**
  * Delete the selected item from its calendar (if it is an event item)
  *
  * @param aDoNotConfirm     If true, the user will not be prompted.
  */
-agendaListbox.deleteSelectedItem =
-function deleteSelectedItem(aDoNotConfirm) {
+agendaListbox.deleteSelectedItem = function(aDoNotConfirm) {
     let listItem = this.agendaListboxControl.selectedItem;
     if (this.isEventListItem(listItem)) {
         let selectedItems = [listItem.occurrence];
         calendarViewController.deleteOccurrences(selectedItems.length,
                                                  selectedItems,
                                                  false,
                                                  aDoNotConfirm);
     }
 };
 
 /**
  * If a Period item is targeted by the passed DOM event, opens the event dialog
  * with the period's start date prefilled.
  *
  * @param aEvent            The DOM event that targets the period.
  */
-agendaListbox.createNewEvent =
-function createNewEvent(aEvent) {
+agendaListbox.createNewEvent = function(aEvent) {
     if (!this.isEventListItem(aEvent.target)) {
         // Create new event for the date currently displayed in the agenda. Setting
         // isDate = true automatically makes the start time be the next full hour.
         let eventStart = agendaListbox.today.start.clone();
         eventStart.isDate = true;
         if (calendarController.isCommandEnabled("calendar_new_event_command")) {
             createEventWithDialog(getSelectedCalendar(), eventStart);
         }
     }
 };
 
 /**
  * Sets up the context menu for the agenda listbox
  *
  * @param popup         The <menupopup> element to set up.
  */
-agendaListbox.setupContextMenu =
-function setupContextMenu(popup) {
+agendaListbox.setupContextMenu = function(popup) {
     let listItem = this.agendaListboxControl.selectedItem;
     let enabled = this.isEventListItem(listItem);
     let menuitems = popup.childNodes;
     for (let i = 0; i < menuitems.length; i++) {
         setBooleanAttribute(menuitems[i], "disabled", !enabled);
     }
 
     let menu = document.getElementById("calendar-today-pane-menu-attendance-menu");
@@ -614,18 +589,17 @@ function setupContextMenu(popup) {
  * Refreshes the agenda listbox. If aStart or aEnd is not passed, the agenda
  * listbox's limiting dates will be used.
  *
  * @param aStart        (optional) The start date for the item query.
  * @param aEnd          (optional) The end date for the item query.
  * @param aCalendar     (optional) If specified, the single calendar from
  *                                   which the refresh will occur.
  */
-agendaListbox.refreshCalendarQuery =
-function refreshCalendarQuery(aStart, aEnd, aCalendar) {
+agendaListbox.refreshCalendarQuery = function(aStart, aEnd, aCalendar) {
     let refreshJob = {
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
         agendaListbox: this,
         calendar: null,
         calId: null,
         operation: null,
         cancelled: false,
 
@@ -704,18 +678,17 @@ function refreshCalendarQuery(aStart, aE
     };
 
     refreshJob.execute();
 };
 
 /**
  * Sets up the calendar for the agenda listbox.
  */
-agendaListbox.setupCalendar =
-function setupCalendar() {
+agendaListbox.setupCalendar = function() {
     this.init();
     if (this.calendar == null) {
         this.calendar = getCompositeCalendar();
     }
     if (this.calendar) {
         // XXX This always gets called, does that happen on purpose?
         this.calendar.removeObserver(this.calendarObserver);
     }
@@ -729,18 +702,17 @@ function setupCalendar() {
  * Refreshes the period dates, especially when a period is showing "today".
  * Usually called at midnight to update the agenda pane. Also retrieves the
  * items from the calendar.
  *
  * @see #refreshCalendarQuery
  * @param newDate       The first date to show if the agenda pane doesn't show
  *                        today.
  */
-agendaListbox.refreshPeriodDates =
-function refreshPeriodDates(newDate) {
+agendaListbox.refreshPeriodDates = function(newDate) {
      this.kDefaultTimezone = calendarDefaultTimezone();
     // Today: now until midnight of tonight
     let oldshowstoday = this.showstoday;
     this.showstoday = this.showsToday(newDate);
     if ((this.showstoday) && (!oldshowstoday)) {
         this.addPeriodListItem(this.tomorrow, "tomorrow-header");
         this.addPeriodListItem(this.soon, "nextweek-header");
     } else if (!this.showstoday) {
@@ -763,30 +735,28 @@ function refreshPeriodDates(newDate) {
     this.refreshCalendarQuery();
 };
 
 /**
  * Adds a listener to this agenda listbox.
  *
  * @param aListener     The listener to add.
  */
-agendaListbox.addListener =
-function addListener(aListener) {
+agendaListbox.addListener = function(aListener) {
     this.mListener = aListener;
 };
 
 /**
  * Checks if the agenda listbox is showing "today". Without arguments, this
  * function assumes the today attribute of the agenda listbox.
  *
  * @param aStartDate    (optional) The day to check if its "today".
  * @return              Returns true if today is shown.
  */
-agendaListbox.showsToday =
-function showsToday(aStartDate) {
+agendaListbox.showsToday = function(aStartDate) {
     let lstart = aStartDate;
     if (!lstart) {
         lstart = this.today.start;
     }
     let lshowsToday = sameDay(now(), lstart);
     if (lshowsToday) {
         this.periods = [this.today, this.tomorrow, this.soon];
     } else {
@@ -794,65 +764,61 @@ function showsToday(aStartDate) {
     }
     return lshowsToday;
 };
 
 /**
  * Moves the selection. Moves down unless the next item is a period item, in
  * which case the selection moves up.
  */
-agendaListbox.moveSelection =
-function moveSelection() {
+agendaListbox.moveSelection = function() {
     if (!this.isEventListItem(this.agendaListboxControl.selectedItem.nextSibling)) {
         this.agendaListboxControl.goUp();
     } else {
         this.agendaListboxControl.goDown();
     }
 };
 
 /**
  * Gets an array of selected items. If a period node is selected, it is not
  * included.
  *
  * @return      An array with all selected items.
  */
-agendaListbox.getSelectedItems =
-function getSelectedItems() {
+agendaListbox.getSelectedItems = function() {
     let items = [];
     if (this.isEventListItem(this.agendaListboxControl.selectedItem)) {
         // If at some point we support selecting multiple items, this array can
         // be expanded.
         items = [this.agendaListboxControl.selectedItem.occurrence];
     }
     return items;
 };
 
 /**
  * Checks if the passed node in the listbox is an Event item (not a
  * period item).
  *
  * @param aListItem     The node to check for.
  * @return              True, if the node is not a period item.
  */
-agendaListbox.isEventListItem =
-function isEventListItem(aListItem) {
+agendaListbox.isEventListItem = function(aListItem) {
     let isListItem = (aListItem != null);
     if (isListItem) {
         let localName = aListItem.localName;
         isListItem = (localName == "agenda-richlist-item" ||
                       localName == "agenda-allday-richlist-item");
     }
     return isListItem;
 };
 
 /**
  * Removes all Event items, keeping the period items intact.
  */
-agendaListbox.removeListItems =
-function removeListItems() {
+agendaListbox.removeListItems = function() {
     let listItem = this.agendaListboxControl.lastChild;
     if (listItem) {
         let leaveloop = false;
         do {
             let newlistItem = null;
             if (listItem) {
                 newlistItem = listItem.previousSibling;
             } else {
@@ -870,18 +836,17 @@ function removeListItems() {
     }
 };
 
 /**
  * Gets the list item node by its associated event's hashId.
  *
  * @return The XUL node if successful, otherwise null.
  */
-agendaListbox.getListItemByHashId =
-function getListItemByHashId(ahashId) {
+agendaListbox.getListItemByHashId = function(ahashId) {
     let listItem = this.agendaListboxControl.firstChild;
     let leaveloop = false;
     do {
         if (this.isEventListItem(listItem)) {
             if (listItem.occurrence.hashId == ahashId) {
                 return listItem;
             }
         }
@@ -903,83 +868,77 @@ agendaListbox.calendarOpListener = {
  * Calendar and composite observer, used to keep agenda listbox up to date.
  * @see calIObserver
  * @see calICompositeObserver
  */
 agendaListbox.calendarObserver = {
     agendaListbox: agendaListbox
 };
 
-agendaListbox.calendarObserver.QueryInterface =
-function agenda_QI(aIID) {
+agendaListbox.calendarObserver.QueryInterface = function(aIID) {
     if (!aIID.equals(Components.interfaces.calIObserver) &&
         !aIID.equals(Components.interfaces.calICompositeObserver) &&
         !aIID.equals(Components.interfaces.nsISupports)) {
         throw Components.results.NS_ERROR_NO_INTERFACE;
     }
     return this;
 };
 
 // calIObserver:
-agendaListbox.calendarObserver.onStartBatch = function agenda_onBatchStart() {
+agendaListbox.calendarObserver.onStartBatch = function() {
 };
 
-agendaListbox.calendarObserver.onEndBatch =
-function() {
+agendaListbox.calendarObserver.onEndBatch = function() {
 };
 
 agendaListbox.calendarObserver.onLoad = function() {
     this.agendaListbox.refreshCalendarQuery();
 };
 
-agendaListbox.calendarObserver.onAddItem = function observer_onAddItem(item) {
+agendaListbox.calendarObserver.onAddItem = function(item) {
     if (!isEvent(item)) {
         return;
     }
     // get all sub items if it is a recurring item
     let occs = this.getOccurrencesBetween(item);
     occs.forEach(this.agendaListbox.addItem, this.agendaListbox);
     setCurrentEvent();
 };
 
-agendaListbox.calendarObserver.getOccurrencesBetween =
-function getOccurrencesBetween(aItem) {
+agendaListbox.calendarObserver.getOccurrencesBetween = function(aItem) {
     let occs = [];
     let start = this.agendaListbox.getStart();
     let end = this.agendaListbox.getEnd();
     if (start && end) {
         occs = aItem.getOccurrencesBetween(start, end, {});
     }
     return occs;
 };
 
-agendaListbox.calendarObserver.onDeleteItem =
-function observer_onDeleteItem(item, rebuildFlag) {
+agendaListbox.calendarObserver.onDeleteItem = function(item, rebuildFlag) {
     this.onLocalDeleteItem(item, true);
 };
 
-agendaListbox.calendarObserver.onLocalDeleteItem =
-function observer_onLocalDeleteItem(item, moveSelection) {
+agendaListbox.calendarObserver.onLocalDeleteItem = function(item, moveSelection) {
     if (!isEvent(item)) {
         return false;
     }
     let selectedItemHashId = -1;
 // get all sub items if it is a recurring item
     let occs = this.getOccurrencesBetween(item);
     for (let i = 0; i < occs.length; i++) {
         let isSelected = this.agendaListbox.deleteItem(occs[i], moveSelection);
         if (isSelected) {
             selectedItemHashId = occs[i].hashId;
         }
     }
     return selectedItemHashId;
 };
 
-agendaListbox.calendarObserver.onModifyItem =
-function observer_onModifyItem(newItem, oldItem) {
+agendaListbox.calendarObserver.onModifyItem = function(newItem, oldItem) {
     let selectedItemHashId = this.onLocalDeleteItem(oldItem, false);
     if (!isEvent(newItem)) {
         return;
     }
     this.onAddItem(newItem);
     if (selectedItemHashId != -1) {
         let listItem = agendaListbox.getListItemByHashId(selectedItemHashId);
         if (listItem) {
@@ -1013,38 +972,35 @@ agendaListbox.calendarObserver.onPropert
     }
 };
 
 agendaListbox.calendarObserver.onPropertyDeleting = function(aCalendar, aName) {
     this.onPropertyChanged(aCalendar, aName, null, null);
 };
 
 
-agendaListbox.calendarObserver.onCalendarRemoved =
-function agenda_calRemoved(aCalendar) {
+agendaListbox.calendarObserver.onCalendarRemoved = function(aCalendar) {
     if (!aCalendar.getProperty("disabled")) {
         this.agendaListbox.deleteItemsFromCalendar(aCalendar);
     }
 };
 
-agendaListbox.calendarObserver.onCalendarAdded =
-function agenda_calAdded(aCalendar) {
+agendaListbox.calendarObserver.onCalendarAdded = function(aCalendar) {
     if (!aCalendar.getProperty("disabled")) {
         this.agendaListbox.refreshCalendarQuery(null, null, aCalendar);
     }
 };
 
 agendaListbox.calendarObserver.onDefaultCalendarChanged = function(aCalendar) {
 };
 
 /**
  * Updates the "Upcoming" section of today pane when preference soondays changes
  **/
-agendaListbox.updateSoonSection =
-function updateSoonSection() {
+agendaListbox.updateSoonSection = function() {
     this.soon.duration = this.soonDays;
     this.soon.open = true;
     let soonHeader = document.getElementById("nextweek-header");
     if (soonHeader) {
         soonHeader.setItem(this.soon, true);
         agendaListbox.refreshPeriodDates(now());
     }
 };
--- a/calendar/base/content/calendar-base-view.xml
+++ b/calendar/base/content/calendar-base-view.xml
@@ -46,17 +46,17 @@
       ({ WorkdaysOnly:  1,
          TasksInView:   2,
          ShowCompleted: 4,
       })
       ]]></field>
 
       <field name="mPrefObserver"><![CDATA[
       ({ calView: this,
-         observe: function calViewPrefChange(subj, topic, pref) {
+         observe: function(subj, topic, pref) {
              this.calView.handlePreference(subj, topic, pref);
              return;
          }
       })
       ]]></field>
 
       <field name="mObserver"><![CDATA[
         // the calIObserver, calICompositeObserver, and calIAlarmServiceObserver
@@ -64,26 +64,26 @@
             QueryInterface: XPCOMUtils.generateQI([
                 Components.interfaces.calIObserver,
                 Components.interfaces.calIAlarmServiceObserver,
                 Components.interfaces.calICompositeObserver
             ]),
 
             calView: this,
 
-            onStartBatch: function onStartBatch() {
+            onStartBatch: function() {
             },
-            onEndBatch: function onEndBatch() {
+            onEndBatch: function() {
             },
 
-            onLoad: function onLoad() {
+            onLoad: function() {
                 this.calView.refresh();
             },
 
-            onAddItem: function onAddItem(aItem) {
+            onAddItem: function(aItem) {
                 if (cal.isToDo(aItem)) {
                     if (!aItem.entryDate && !aItem.dueDate) {
                         return;
                     }
                     if (!this.calView.mTasksInView) {
                         return;
                     }
                     if (aItem.isCompleted && !this.calView.mShowCompleted) {
@@ -95,17 +95,17 @@
                                                        this.calView.queryEndDate,
                                                        {});
                 for (let occ of occs) {
                     this.calView.doAddItem(occ);
                 }
                 return;
             },
 
-            onModifyItem: function onModifyItem(aNewItem, aOldItem) {
+            onModifyItem: function(aNewItem, aOldItem) {
                 if (cal.isToDo(aNewItem) && cal.isToDo(aOldItem) &&
                     !this.calView.mTasksInView) {
                     return;
                 }
                 let occs;
 
                 if (!cal.isToDo(aOldItem) || aOldItem.entryDate || aOldItem.dueDate) {
                     occs = aOldItem.getOccurrencesBetween(this.calView.startDate,
@@ -127,17 +127,17 @@
                 occs = aNewItem.getOccurrencesBetween(this.calView.startDate,
                                                       this.calView.queryEndDate,
                                                       {});
                 for (let occ of occs) {
                     this.calView.doAddItem(occ);
                 }
             },
 
-            onDeleteItem: function onDeleteItem(aItem) {
+            onDeleteItem: function(aItem) {
                 if (cal.isToDo(aItem)) {
                     if (!this.calView.mTasksInView) {
                         return;
                     }
                     if (!aItem.entryDate && !aItem.dueDate) {
                         return;
                     }
                     if (aItem.isCompleted && !this.calView.mShowCompleted) {
@@ -148,17 +148,17 @@
                 let occs = aItem.getOccurrencesBetween(this.calView.startDate,
                                                        this.calView.queryEndDate,
                                                        {});
                 for (let occ of occs) {
                     this.calView.doDeleteItem(occ);
                 }
             },
 
-            onError: function onError(aCalendar, aErrNo, aMessage) { },
+            onError: function(aCalendar, aErrNo, aMessage) { },
 
             onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {
                 switch (aName) {
                     case "suppressAlarms":
                         if (!Preferences.get("calendar.alarms.indicator.show", true) ||
                             aCalendar.getProperty("capabilities.alarms.popup.supported") === false) {
                             break;
                         }
@@ -174,55 +174,54 @@
             onPropertyDeleting: function(aCalendar, aName) {
                 // Values are not important here yet.
                 this.onPropertyChanged(aCalendar, aName, null, null);
             },
 
             //
             // calIAlarmServiceObserver stuff
             //
-            onAlarm: function onAlarm(aAlarmItem) {
+            onAlarm: function(aAlarmItem) {
                 this.calView.flashAlarm(aAlarmItem, false);
             },
 
-            onRemoveAlarmsByItem: function onRemoveAlarmsByItem(aItem) {
+            onRemoveAlarmsByItem: function(aItem) {
                 // Stop the flashing for the item.
                 this.calView.flashAlarm(aItem, true);
             },
 
-            onRemoveAlarmsByCalendar: function onRemoveAlarmsByCalendar(aCalendar) {
+            onRemoveAlarmsByCalendar: function(aCalendar) {
                 // Stop the flashing for all items of this calendar
                 for (let key in this.calView.mFlashingEvents) {
                     let item = this.calView.mFlashingEvents[key];
                     if (item.calendar.id == aCalendar.id) {
                         this.calView.flashAlarm(item, true);
                     }
                 }
             },
 
-            onAlarmsLoaded: function _onAlarmsLoaded(aCalendar) {},
+            onAlarmsLoaded: function(aCalendar) {},
 
             //
             // calICompositeObserver stuff
             // XXXvv we can be smarter about how we handle this stuff
             //
-            onCalendarAdded: function onCalendarAdded(aCalendar) {
+            onCalendarAdded: function(aCalendar) {
                 if (!aCalendar.getProperty("disabled")) {
                     this.calView.addItemsFromCalendar(aCalendar);
                 }
             },
 
-            onCalendarRemoved: function onCalendarRemoved(aCalendar) {
+            onCalendarRemoved: function(aCalendar) {
                 if (!aCalendar.getProperty("disabled")) {
                     this.calView.deleteItemsFromCalendar(aCalendar);
                 }
             },
 
-            onDefaultCalendarChanged:
-            function onDefaultCalendarChanged(aNewDefaultCalendar) {
+            onDefaultCalendarChanged: function(aNewDefaultCalendar) {
                 // don't care, for now
             }
         })
       ]]></field>
 
       <constructor><![CDATA[
         Components.utils.import("resource://gre/modules/Services.jsm");
         Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
@@ -242,20 +241,19 @@
                                 .getAttribute("checked") == "true");
         this.showCompleted = (document.getElementById(kShowCompleted)
                                 .getAttribute("checked") == "true");
 
         this.mTimezone = calendarDefaultTimezone();
         let alarmService = Components.classes["@mozilla.org/calendar/alarm-service;1"]
                            .getService(Components.interfaces.calIAlarmService);
         alarmService.addObserver(this.mObserver);
-        let self = this;
         this.setAttribute("type", this.type);
-        this.mResizeHandler = function resizeHandler() {
-            self.onResize(self);
+        this.mResizeHandler = () => {
+            this.onResize(this);
         };
         this.viewBroadcaster.addEventListener(this.getAttribute("type") + "viewresized", this.mResizeHandler, true);
         // add a preference observer to monitor changes
         Services.prefs.addObserver("calendar.", this.mPrefObserver, false);
         this.weekStartOffset = Preferences.get("calendar.week.start", 0);
         this.updateDaysOffPrefs();
         this.mPendingRefreshJobs = new Map();
         this.mLog = Log4Moz.getConfiguredLogger("calBaseView");
--- a/calendar/base/content/calendar-common-sets.js
+++ b/calendar/base/content/calendar-common-sets.js
@@ -88,33 +88,33 @@ var calendarController = {
         "calendar_in_foreground": true,
         "calendar_in_background": true,
         "calendar_mode_calendar": true,
         "calendar_mode_task": true,
 
         "cmd_selectAll": true
     },
 
-    updateCommands: function cC_updateCommands() {
+    updateCommands: function() {
         for (let command in this.commands) {
             goUpdateCommand(command);
         }
     },
 
-    supportsCommand: function cC_supportsCommand(aCommand) {
+    supportsCommand: function(aCommand) {
         if (aCommand in this.commands) {
             return true;
         }
         if (this.defaultContoller) {
             return this.defaultContoller.supportsCommand(aCommand);
         }
         return false;
     },
 
-    isCommandEnabled: function cC_isCommandEnabled(aCommand) {
+    isCommandEnabled: function(aCommand) {
         switch (aCommand) {
             case "calendar_new_event_command":
             case "calendar_new_event_context_command":
                 return CalendarNewEventsCommandEnabled;
             case "calendar_modify_focused_item_command":
                 return this.item_selected;
             case "calendar_modify_event_command":
                 return this.item_selected;
@@ -252,17 +252,17 @@ var calendarController = {
                 if (aCommand in this.commands) {
                     // All other commands we support should be enabled by default
                     return true;
                 }
         }
         return false;
     },
 
-    doCommand: function cC_doCommand(aCommand) {
+    doCommand: function(aCommand) {
         switch (aCommand) {
             // Common Commands
             case "calendar_new_event_command":
                 createEventWithDialog(getSelectedCalendar(),
                                       getDefaultStartDate(currentView().selectedDay));
                 break;
             case "calendar_new_event_context_command": {
                 let newStart = currentView().selectedDateTime;
@@ -425,36 +425,36 @@ var calendarController = {
                     this.defaultController.doCommand(aCommand);
                     return;
                 }
 
         }
         return;
     },
 
-    onEvent: function cC_onEvent(aEvent) {
+    onEvent: function(aEvent) {
     },
 
-    isCalendarInForeground: function cC_isCalendarInForeground() {
+    isCalendarInForeground: function() {
         return gCurrentMode && gCurrentMode != "mail";
     },
 
-    isInMode: function cC_isInMode(mode) {
+    isInMode: function(mode) {
         switch (mode) {
             case "mail":
                 return !isCalendarInForeground();
             case "calendar":
                 return gCurrentMode && gCurrentMode == "calendar";
             case "task":
                 return gCurrentMode && gCurrentMode == "task";
         }
         return false;
     },
 
-    onSelectionChanged: function cC_onSelectionChanged(aEvent) {
+    onSelectionChanged: function(aEvent) {
         let selectedItems = aEvent.detail;
 
         calendarUpdateDeleteCommand(selectedItems);
         calendarController.item_selected = selectedItems && (selectedItems.length > 0);
 
         let selLength = (selectedItems === undefined ? 0 : selectedItems.length);
         let selected_events_readonly = 0;
         let selected_events_requires_network = 0;
@@ -669,17 +669,17 @@ var calendarController2 = {
         "cmd_showQuickFilterBar": true
     },
 
     // These functions can use the same from the calendar controller for now.
     updateCommands: calendarController.updateCommands,
     supportsCommand: calendarController.supportsCommand,
     onEvent: calendarController.onEvent,
 
-    isCommandEnabled: function isCommandEnabled(aCommand) {
+    isCommandEnabled: function(aCommand) {
         switch (aCommand) {
             // Thunderbird Commands
             case "cmd_cut":
                 return calendarController.selected_items_writable;
             case "cmd_copy":
                 return calendarController.item_selected;
             case "cmd_paste":
                 return canPaste();
@@ -702,17 +702,17 @@ var calendarController2 = {
                 return false;
             case "cmd_showQuickFilterBar":
                 return calendarController.isInMode("task");
             default:
                 return true;
         }
     },
 
-    doCommand: function doCommand(aCommand) {
+    doCommand: function(aCommand) {
         switch (aCommand) {
             case "cmd_cut":
                 cutToClipboard();
                 break;
             case "cmd_copy":
                 copyToClipboard();
                 break;
             case "cmd_paste":
--- a/calendar/base/content/calendar-extract.js
+++ b/calendar/base/content/calendar-extract.js
@@ -2,17 +2,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 Components.utils.import("resource://calendar/modules/calExtract.jsm");
 Components.utils.import("resource://calendar/modules/calUtils.jsm");
 Components.utils.import("resource://gre/modules/Preferences.jsm");
 
 var calendarExtract = {
-    onShowLocaleMenu: function onShowLocaleMenu(target) {
+    onShowLocaleMenu: function(target) {
         let localeList = document.getElementById(target.id);
         let langs = [];
         let chrome = Components.classes["@mozilla.org/chrome/chrome-registry;1"]
                                .getService(Components.interfaces.nsIXULChromeRegistry);
         chrome.QueryInterface(Components.interfaces.nsIToolkitChromeRegistry);
         let locales = chrome.getLocalesForPackage("calendar");
         let langRegex = /^(([^-]+)-*(.*))$/;
 
@@ -54,23 +54,23 @@ var calendarExtract = {
         });
         removeChildren(localeList);
 
         for (let lang of langs) {
             addMenuItem(localeList, lang[0], lang[1], null);
         }
     },
 
-    extractWithLocale: function extractWithLocale(event, isEvent) {
+    extractWithLocale: function(event, isEvent) {
         event.stopPropagation();
         let locale = event.target.value;
         this.extractFromEmail(isEvent, true, locale);
     },
 
-    extractFromEmail: function extractFromEmail(isEvent, fixedLang, fixedLocale) {
+    extractFromEmail: function(isEvent, fixedLang, fixedLocale) {
         // TODO would be nice to handle multiple selected messages,
         // though old conversion functionality didn't
         let message = gFolderDisplay.selectedMessage;
         let messenger = Components.classes["@mozilla.org/messenger;1"]
                                   .createInstance(Components.interfaces.nsIMessenger);
         let listener = Components.classes["@mozilla.org/network/sync-stream-listener;1"]
                                  .createInstance(Components.interfaces.nsISyncStreamListener);
         let uri = message.folder.getUriForMsg(message);
@@ -204,34 +204,34 @@ var calendarExtract = {
                 createEventWithDialog(null, null, null, null, item);
             }
         }
 
         let timeSpent = (new Date()).getTime() - time;
         cal.LOG("[calExtract] Total time spent for conversion (including loading of dictionaries): " + timeSpent + "ms");
     },
 
-    addListeners: function addListeners() {
+    addListeners: function() {
         if (window.top.document.location == "chrome://messenger/content/messenger.xul") {
             // covers initial load and folder change
             let folderTree = document.getElementById("folderTree");
             folderTree.addEventListener("select", this.setState, false);
 
             // covers selection change in a folder
             let msgTree = window.top.GetThreadTree();
             msgTree.addEventListener("select", this.setState, false);
 
             window.addEventListener("unload", () => {
                 folderTree.removeEventListener("select", this.setState, false);
                 msgTree.removeEventListener("select", this.setState, false);
             }, false);
         }
     },
 
-    setState: function setState() {
+    setState: function() {
         let eventButton = document.getElementById("extractEventButton");
         let taskButton = document.getElementById("extractTaskButton");
         let hdrEventButton = document.getElementById("hdrExtractEventButton");
         let hdrTaskButton = document.getElementById("hdrExtractTaskButton");
         let contextMenu = document.getElementById("mailContext-calendar-convert-menu");
         let contextMenuEvent = document.getElementById("mailContext-calendar-convert-event-menuitem");
         let contextMenuTask = document.getElementById("mailContext-calendar-convert-task-menuitem");
         let eventDisabled = (gFolderDisplay.selectedCount == 0);
--- a/calendar/base/content/calendar-invitations-manager.js
+++ b/calendar/base/content/calendar-invitations-manager.js
@@ -16,26 +16,26 @@ var gInvitationsRequestManager = {
     mRequestStatusList: {},
 
     /**
      * Add a request to the request manager.
      *
      * @param calendar    The calendar to add for.
      * @param op          The operation to add
      */
-    addRequestStatus: function IRM_addRequestStatus(calendar, op) {
+    addRequestStatus: function(calendar, op) {
         if (op) {
             this.mRequestStatusList[calendar.id] = op;
         }
     },
 
     /**
      * Cancel all pending requests
      */
-    cancelPendingRequests: function IRM_cancelPendingRequests() {
+    cancelPendingRequests: function() {
         for (let id in this.mRequestStatusList) {
             let request = this.mRequestStatusList[id];
             if (request && request.isPending) {
                 request.cancel(null);
             }
         }
         this.mRequestStatusList = {};
     }
@@ -82,48 +82,45 @@ InvitationsManager.prototype = {
     mTimer: null,
 
     /**
      * Schedule an update for the invitations manager asynchronously.
      *
      * @param firstDelay          The timeout before the operation should start.
      * @param operationListener   The calIGenericOperationListener to notify.
      */
-    scheduleInvitationsUpdate: function IM_scheduleInvitationsUpdate(firstDelay,
-                                                                     operationListener) {
+    scheduleInvitationsUpdate: function(firstDelay, operationListener) {
         this.cancelInvitationsUpdate();
 
-        let self = this;
-        this.mTimer = setTimeout(function startInvitationsTimer() {
+        this.mTimer = setTimeout(() => {
             if (Preferences.get("calendar.invitations.autorefresh.enabled", true)) {
-                self.mTimer = setInterval(function repeatingInvitationsTimer() {
-                    self.getInvitations(operationListener);
+                this.mTimer = setInterval(() => {
+                    this.getInvitations(operationListener);
                     }, Preferences.get("calendar.invitations.autorefresh.timeout", 3) * 60000);
             }
-            self.getInvitations(operationListener);
+            this.getInvitations(operationListener);
         }, firstDelay);
     },
 
     /**
      * Cancel pending any pending invitations update.
      */
-    cancelInvitationsUpdate: function IM_cancelInvitationsUpdate() {
+    cancelInvitationsUpdate: function() {
         clearTimeout(this.mTimer);
     },
 
     /**
      * Retrieve invitations from all calendars. Notify all passed
      * operation listeners.
      *
      * @param operationListener1    The first operation listener to notify.
      * @param operationListener2    (optinal) The second operation listener to
      *                                notify.
      */
-    getInvitations: function IM_getInvitations(operationListener1,
-                                               operationListener2) {
+    getInvitations: function(operationListener1, operationListener2) {
         let listeners = [];
         if (operationListener1) {
             listeners.push(operationListener1);
         }
         if (operationListener2) {
             listeners.push(operationListener2);
         }
 
@@ -234,18 +231,17 @@ InvitationsManager.prototype = {
      * sounds fishy to me. Maybe there is a more encapsulated solution.
      *
      * @param onLoadOpListener          The operation listener to notify when
      *                                    getting invitations. Should be passed
      *                                    to this.getInvitations().
      * @param finishedCallBack          A callback function to call when the
      *                                    dialog has completed.
      */
-    openInvitationsDialog: function IM_openInvitationsDialog(onLoadOpListener,
-                                                             finishedCallBack) {
+    openInvitationsDialog: function(onLoadOpListener, finishedCallBack) {
         let args = {};
         args.onLoadOperationListener = onLoadOpListener;
         args.queue = [];
         args.finishedCallBack = finishedCallBack;
         args.requestManager = gInvitationsRequestManager;
         args.invitationsManager = this;
         // the dialog will reset this to auto when it is done loading
         window.setCursor("wait");
@@ -261,18 +257,17 @@ InvitationsManager.prototype = {
      * Process the passed job queue. A job is an object that consists of an
      * action, a newItem and and oldItem. This processor only takes "modify"
      * operations into account.
      *
      * @param queue                         The array of objects to process.
      * @param jobQueueFinishedCallBack      A callback function called when
      *                                        job has finished.
      */
-    processJobQueue: function IM_processJobQueue(queue,
-                                                 jobQueueFinishedCallBack) {
+    processJobQueue: function(queue, jobQueueFinishedCallBack) {
         // TODO: undo/redo
         function operationListener(mgr, queueCallback, oldItem_) {
             this.mInvitationsManager = mgr;
             this.mJobQueueFinishedCallBack = queueCallback;
             this.mOldItem = oldItem_;
         }
         operationListener.prototype = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
@@ -327,31 +322,28 @@ InvitationsManager.prototype = {
 
     /**
      * Checks if the internal item list contains the given item
      * XXXdbo       Please document these correctly.
      *
      * @param item      The item to look for.
      * @return          A boolean value indicating if the item was found.
      */
-    hasItem: function IM_hasItem(item) {
+    hasItem: function(item) {
         let hid = item.hashId;
-        return this.mItemList.some(
-            function someFunc(item_) {
-                return hid == item_.hashId;
-            });
+        return this.mItemList.some(item_ => hid == item_.hashId);
     },
 
     /**
      * Adds an item to the internal item list.
      * XXXdbo       Please document these correctly.
      *
      * @param item      The item to add.
      */
-    addItem: function IM_addItem(item) {
+    addItem: function(item) {
         let recInfo = item.recurrenceInfo;
         if (recInfo && !cal.isOpenInvitation(item)) {
             // scan exceptions:
             let ids = recInfo.getExceptionIds({});
             for (let id of ids) {
                 let ex = recInfo.getExceptionFor(id);
                 if (ex && this.validateItem(ex) && !this.hasItem(ex)) {
                     this.mItemList.push(ex);
@@ -363,52 +355,49 @@ InvitationsManager.prototype = {
     },
 
     /**
      * Removes an item from the internal item list
      * XXXdbo       Please document these correctly.
      *
      * @param item      The item to remove.
      */
-    deleteItem: function IM_deleteItem(item) {
+    deleteItem: function(item) {
         let id = item.id;
-        this.mItemList.filter(
-            function filterFunc(item_) {
-                return id != item_.id;
-            });
+        this.mItemList.filter(item_ => id != item_.id);
     },
 
     /**
      * Remove all items from the internal item list
      * XXXdbo       Please document these correctly.
      */
-    deleteAllItems: function IM_deleteAllItems() {
+    deleteAllItems: function() {
         this.mItemList = [];
     },
 
     /**
      * Helper function to create a start date to search from. This date is the
      * current time with hour/minute/second set to zero.
      *
      * @return      Potential start date.
      */
-    getStartDate: function IM_getStartDate() {
+    getStartDate: function() {
         let date = now();
         date.second = 0;
         date.minute = 0;
         date.hour = 0;
         return date;
     },
 
     /**
      * Updates the start date for the invitations manager to the date returned
      * from this.getStartDate(), unless the previously existing start date is
      * the same or after what getStartDate() returned.
      */
-    updateStartDate: function IM_updateStartDate() {
+    updateStartDate: function() {
         if (!this.mStartDate) {
             this.mStartDate = this.getStartDate();
         } else {
             let startDate = this.getStartDate();
             if (startDate.compare(this.mStartDate) > 0) {
                 this.mStartDate = startDate;
             }
         }
@@ -417,17 +406,17 @@ InvitationsManager.prototype = {
     /**
      * Checks if the item is valid for the invitation manager. Checks if the
      * item is in the range of the invitation manager and if the item is a valid
      * invitation.
      *
      * @param item      The item to check
      * @return          A boolean indicating if the item is a valid invitation.
      */
-    validateItem: function IM_validateItem(item) {
+    validateItem: function(item) {
         if (item.calendar instanceof Components.interfaces.calISchedulingSupport &&
             !item.calendar.isInvitation(item)) {
             return false; // exclude if organizer has invited himself
         }
         let start = item[calGetStartDateProp(item)] || item[calGetEndDateProp(item)];
         return (cal.isOpenInvitation(item) &&
                 start.compare(this.mStartDate) >= 0);
     }
--- a/calendar/base/content/calendar-item-editing.js
+++ b/calendar/base/content/calendar-item-editing.js
@@ -373,21 +373,21 @@ function openEventDialog(calendarItem, c
     // Set up some defaults
     mode = mode || "new";
     calendar = calendar || getSelectedCalendar();
     let calendars = getCalendarManager().getCalendars({});
     calendars = calendars.filter(isCalendarWritable);
 
     let isItemSupported;
     if (isToDo(calendarItem)) {
-        isItemSupported = function isTodoSupported(aCalendar) {
+        isItemSupported = function(aCalendar) {
             return (aCalendar.getProperty("capabilities.tasks.supported") !== false);
         };
     } else if (isEvent(calendarItem)) {
-        isItemSupported = function isEventSupported(aCalendar) {
+        isItemSupported = function(aCalendar) {
             return (aCalendar.getProperty("capabilities.events.supported") !== false);
         };
     }
 
     // Filter out calendars that don't support the given calendar item
     calendars = calendars.filter(isItemSupported);
 
     // Filter out calendar/items that we cannot write to/modify
--- a/calendar/base/content/calendar-management.js
+++ b/calendar/base/content/calendar-management.js
@@ -356,29 +356,29 @@ var compositeObserver = {
     onPropertyChanged: function() {},
     onPropertyDeleting: function() {},
 
     onLoad: function() {
         calendarUpdateNewItemsCommand();
         document.commandDispatcher.updateCommands("calendar_commands");
     },
 
-    onCalendarAdded: function cO_onCalendarAdded(aCalendar) {
+    onCalendarAdded: function(aCalendar) {
         // Update the calendar commands for number of remote calendars and for
         // more than one calendar
         document.commandDispatcher.updateCommands("calendar_commands");
     },
 
-    onCalendarRemoved: function cO_onCalendarRemoved(aCalendar) {
+    onCalendarRemoved: function(aCalendar) {
         // Update commands to disallow deleting the last calendar and only
         // allowing reload remote calendars when there are remote calendars.
         document.commandDispatcher.updateCommands("calendar_commands");
     },
 
-    onDefaultCalendarChanged: function cO_onDefaultCalendarChanged(aNewCalendar) {
+    onDefaultCalendarChanged: function(aNewCalendar) {
         // A new default calendar may mean that the new calendar has different
         // ACLs. Make sure the commands are updated.
         calendarUpdateNewItemsCommand();
         document.commandDispatcher.updateCommands("calendar_commands");
     }
 };
 
 /**
@@ -395,44 +395,44 @@ function openCalendarSubscriptionsDialog
 }
 
 /**
  * Calendar Offline Manager
  */
 var calendarOfflineManager = {
     QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIObserver]),
 
-    init: function cOM_init() {
+    init: function() {
         if (this.initialized) {
             throw Components.results.NS_ERROR_ALREADY_INITIALIZED;
         }
         Services.obs.addObserver(this, "network:offline-status-changed", false);
 
         this.updateOfflineUI(!this.isOnline());
         this.initialized = true;
     },
 
-    uninit: function cOM_uninit() {
+    uninit: function() {
         if (!this.initialized) {
             throw Components.results.NS_ERROR_NOT_INITIALIZED;
         }
         Services.obs.removeObserver(this, "network:offline-status-changed", false);
         this.initialized = false;
     },
 
-    isOnline: function cOM_isOnline() {
+    isOnline: function() {
         return !Services.io.offline;
     },
 
-    updateOfflineUI: function cOM_updateOfflineUI(aIsOffline) {
+    updateOfflineUI: function(aIsOffline) {
         // Refresh the current view
         currentView().goToDay(currentView().selectedDay);
 
         // Set up disabled locks for offline
         document.commandDispatcher.updateCommands("calendar_commands");
     },
 
-    observe: function cOM_observe(aSubject, aTopic, aState) {
+    observe: function(aSubject, aTopic, aState) {
         if (aTopic == "network:offline-status-changed") {
             this.updateOfflineUI(aState == "offline");
         }
     }
 };
--- a/calendar/base/content/calendar-menus.xml
+++ b/calendar/base/content/calendar-menus.xml
@@ -12,18 +12,17 @@
  xmlns:xbl="http://www.mozilla.org/xbl">
 
   <binding id="task-menupopup" extends="xul:menupopup">
     <implementation>
       <field name="mType">null</field>;
       <field name="mPopupHandler">null</field>
       <field name="mParentMenuPopup">null</field>
       <constructor><![CDATA[
-        let self = this;
-        this.mPopupHandler = function popupHandler() { self.changeMenuByPropertyName(); };
+        this.mPopupHandler = () => { this.schangeMenuByPropertyName(); };
         this.mParentMenuPopup = getParentNodeOrThis(this, "menupopup");
         this.mParentMenuPopup.addEventListener("popupshowing", this.mPopupHandler, true);
       ]]></constructor>
       <destructor><![CDATA[
         this.mParentMenuPopup.removeEventListener("popupshowing", this.mPopupHandler, true);
       ]]></destructor>
 
 <!-- This method checks a command which naming follows
--- a/calendar/base/content/calendar-statusbar.js
+++ b/calendar/base/content/calendar-statusbar.js
@@ -20,36 +20,36 @@ Components.utils.import("resource://gre/
      mThrobber: null,
      mProgressMode: Components.interfaces.calIStatusObserver.NO_PROGRESS,
      mCurIndex: 0,
      mInitialized: false,
      mCalendars: {},
 
     QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIStatusObserver]),
 
-     initialize: function cStObs_initialize(aWindow) {
+     initialize: function(aWindow) {
         if (!this.mInitialized) {
             this.mWindow = aWindow;
             this.mStatusText = this.mWindow.document.getElementById("statusText");
             this.mStatusBar = this.mWindow.document.getElementById("statusbar-icon");
             this.mStatusProgressPanel = this.mWindow.document.getElementById("statusbar-progresspanel");
             this.mThrobber = this.mWindow.document.getElementById("navigator-throbber");
             this.mInitialized = true;
         }
      },
 
-     showStatusString: function cStObs_showStatusString(status) {
+     showStatusString: function(status) {
          this.mStatusText.setAttribute("label", status);
      },
 
      get spinning() {
          return this.mProgressMode;
      },
 
-     startMeteors: function cStObs_startMeteors(aProgressMode, aCalendarCount) {
+     startMeteors: function(aProgressMode, aCalendarCount) {
          if (aProgressMode != Components.interfaces.calIStatusObserver.NO_PROGRESS) {
              if (!this.mInitialized) {
                 Components.utils.reportError("StatusObserver has not been initialized!");
                 return;
              }
              this.mCalendars = {};
              this.mCurIndex = 0;
              if (aCalendarCount) {
@@ -66,34 +66,34 @@ Components.utils.import("resource://gre/
                  this.showStatusString(commonStatus);
              }
              if (this.mThrobber) {
                  this.mThrobber.setAttribute("busy", true);
              }
          }
      },
 
-     stopMeteors: function cStObs_stopMeteors() {
+     stopMeteors: function() {
          if (!this.mInitialized) {
             return;
          }
          if (this.spinning != Components.interfaces.calIStatusObserver.NO_PROGRESS) {
              this.mProgressMode = Components.interfaces.calIStatusObserver.NO_PROGRESS;
              this.mStatusProgressPanel.collapsed = true;
              this.mStatusBar.setAttribute("mode", "normal");
              this.mStatusBar.value = 0;
              this.mCalendarCount = 0;
              this.showStatusString("");
              if (this.mThrobber) {
                  this.mThrobber.setAttribute("busy", false);
              }
          }
      },
 
-     calendarCompleted: function cStObs_calendarCompleted(aCalendar) {
+     calendarCompleted: function(aCalendar) {
          if (!this.mInitialized) {
             return;
          }
          if (this.spinning != Components.interfaces.calIStatusObserver.NO_PROGRESS) {
              if (this.spinning == Components.interfaces.calIStatusObserver.DETERMINED_PROGRESS) {
                  if (!this.mCalendars[aCalendar.id] || this.mCalendars[aCalendar.id] === undefined) {
                      this.mCalendars[aCalendar.id] = true;
                      this.mStatusBar.value = parseInt(this.mStatusBar.value, 10) + this.mCalendarStep;
--- a/calendar/base/content/calendar-task-editing.js
+++ b/calendar/base/content/calendar-task-editing.js
@@ -42,28 +42,28 @@ var taskEdit = {
     /**
      * Helper function to set readonly and aria-disabled states and the value
      * for a given target.
      *
      * @param aTarget   The ID or XUL node to set the value
      * @param aDisable  A boolean if the target should be disabled.
      * @param aValue    The value that should be set on the target.
      */
-    setupTaskField: function tE_setupTaskField(aTarget, aDisable, aValue) {
+    setupTaskField: function(aTarget, aDisable, aValue) {
         aTarget.value = aValue;
         setElementValue(aTarget, aDisable && "true", "readonly");
         setElementValue(aTarget, aDisable && "true", "aria-disabled");
     },
 
     /**
      * Handler function to call when the quick-add textbox gains focus.
      *
      * @param aEvent    The DOM focus event
      */
-    onFocus: function tE_onFocus(aEvent) {
+    onFocus: function(aEvent) {
         let edit = aEvent.target;
         if (edit.localName == "input") {
             // For some reason, we only receive an onfocus event for the textbox
             // when debugging with venkman.
             edit = edit.parentNode.parentNode;
         }
 
         let calendar = getSelectedCalendar();
@@ -83,17 +83,17 @@ var taskEdit = {
         }
     },
 
     /**
      * Handler function to call when the quick-add textbox loses focus.
      *
      * @param aEvent    The DOM blur event
      */
-    onBlur: function tE_onBlur(aEvent) {
+    onBlur: function(aEvent) {
         let edit = aEvent.target;
         if (edit.localName == "input") {
             // For some reason, we only receive the blur event for the input
             // element. There are no targets that point to the textbox. Go up
             // the parent chain until we reach the textbox.
             edit = edit.parentNode.parentNode;
         }
 
@@ -122,17 +122,17 @@ var taskEdit = {
         edit.showsInstructions = true;
     },
 
     /**
      * Handler function to call on keypress for the quick-add textbox.
      *
      * @param aEvent    The DOM keypress event
      */
-    onKeyPress: function tE_onKeyPress(aEvent) {
+    onKeyPress: function(aEvent) {
         if (aEvent.keyCode == Components.interfaces.nsIDOMKeyEvent.DOM_VK_RETURN) {
             let edit = aEvent.target;
             if (edit.value && edit.value.length > 0) {
                 let item = cal.createTodo();
                 setDefaultItemValues(item);
                 item.title = edit.value;
 
                 edit.value = "";
@@ -140,32 +140,32 @@ var taskEdit = {
             }
         }
     },
 
     /**
      * Window load function to set up all quick-add textboxes. The texbox must
      * have the class "task-edit-field".
      */
-    onLoad: function tE_onLoad(aEvent) {
+    onLoad: function(aEvent) {
         window.removeEventListener("load", taskEdit.onLoad, false);
         // TODO use getElementsByClassName
         let taskEditFields = document.getElementsByAttribute("class", "task-edit-field");
         for (let i = 0; i < taskEditFields.length; i++) {
             taskEdit.onBlur({ target: taskEditFields[i] });
         }
 
         getCompositeCalendar().addObserver(taskEdit.compositeObserver);
         taskEdit.observedCalendar = getSelectedCalendar();
     },
 
     /**
      * Window load function to clean up all quick-add fields.
      */
-    onUnload: function tE_onUnload() {
+    onUnload: function() {
         getCompositeCalendar().removeObserver(taskEdit.compositeObserver);
         taskEdit.observedCalendar = null;
     },
 
     /**
      * Observer to watch for readonly, disabled and capability changes of the
      * observed calendar.
      *
@@ -178,37 +178,33 @@ var taskEdit = {
         onStartBatch: function() {},
         onEndBatch: function() {},
         onLoad: function(aCalendar) {},
         onAddItem: function(aItem) {},
         onModifyItem: function(aNewItem, aOldItem) {},
         onDeleteItem: function(aDeletedItem) {},
         onError: function(aCalendar, aErrNo, aMessage) {},
 
-        onPropertyChanged: function tE_calObs_onPropertyChanged(aCalendar,
-                                                         aName,
-                                                         aValue,
-                                                         aOldValue) {
+        onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {
             if (aCalendar.id != getSelectedCalendar().id) {
                 // Optimization: if the given calendar isn't the default calendar,
                 // then we don't need to change any readonly/disabled states.
                 return;
             }
             switch (aName) {
                 case "readOnly":
                 case "disabled":
                     let taskEditFields = document.getElementsByAttribute("class", "task-edit-field");
                     for (let i = 0; i < taskEditFields.length; i++) {
                         taskEdit.onBlur({ target: taskEditFields[i] });
                     }
             }
         },
 
-        onPropertyDeleting: function tE_calObs_onPropertyDeleting(aCalendar,
-                                                           aName) {
+        onPropertyDeleting: function(aCalendar, aName) {
             // Since the old value is not used directly in onPropertyChanged,
             // but should not be the same as the value, set it to a different
             // value.
             this.onPropertyChanged(aCalendar, aName, null, null);
         }
     },
 
     /**
@@ -231,19 +227,19 @@ var taskEdit = {
         onAddItem: function(aItem) {},
         onModifyItem: function(aNewItem, aOldItem) {},
         onDeleteItem: function(aDeletedItem) {},
         onError: function(aCalendar, aErrNo, aMessage) {},
         onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {},
         onPropertyDeleting: function(aCalendar, aName) {},
 
         // calICompositeObserver:
-        onCalendarAdded: function onCalendarAdded(aCalendar) {},
-        onCalendarRemoved: function onCalendarRemoved(aCalendar) {},
-        onDefaultCalendarChanged: function tE_compObs_onDefaultCalendarChanged(aNewDefault) {
+        onCalendarAdded: function(aCalendar) {},
+        onCalendarRemoved: function(aCalendar) {},
+        onDefaultCalendarChanged: function(aNewDefault) {
             let taskEditFields = document.getElementsByAttribute("class", "task-edit-field");
             for (let i = 0; i < taskEditFields.length; i++) {
                 taskEdit.onBlur({ target: taskEditFields[i] });
             }
             taskEdit.observedCalendar = aNewDefault;
         }
     }
 };
--- a/calendar/base/content/calendar-task-tree.xml
+++ b/calendar/base/content/calendar-task-tree.xml
@@ -373,28 +373,28 @@
               return (this.mSelectedColumn = aCol);
           },
 
           /**
            * High-level task tree manipulation
            */
 
           // Adds an array of items to the list if they match the currently applied filter.
-          addItems: function tTV_addItems(aItems, aDontSort) {
+          addItems: function(aItems, aDontSort) {
               this.modifyItems(aItems, [], aDontSort, true);
           },
 
           // Removes an array of items from the list.
-          removeItems: function tTV_removeItems(aItems) {
+          removeItems: function(aItems) {
               this.modifyItems([], aItems, true, false);
           },
 
           // Removes an array of old items from the list, and adds an array of new items if
           // they match the currently applied filter.
-          modifyItems: function tTV_modifyItems(aNewItems, aOldItems, aDontSort, aSelectNew) {
+          modifyItems: function(aNewItems, aOldItems, aDontSort, aSelectNew) {
               let selItem = this.binding.currentTask;
               let selIndex = this.tree.currentIndex;
               let firstHash = null;
               let remIndexes = [];
               aNewItems = aNewItems || [];
               aOldItems = aOldItems || [];
 
               this.treebox.beginUpdateBatch();
@@ -461,27 +461,27 @@
               if (selIndex > -1) {
                   this.tree.view.selection.select(selIndex);
                   this.treebox.ensureRowIsVisible(selIndex);
               }
 
               this.treebox.endUpdateBatch();
           },
 
-          clear: function tTV_clear() {
+          clear: function() {
               let count = this.binding.mTaskArray.length;
               if (count > 0) {
                   this.binding.mTaskArray = [];
                   this.binding.mHash2Index = {};
                   this.treebox.rowCountChanged(0, -count);
                   this.tree.view.selection.clearSelection();
               }
           },
 
-          updateItem: function tTV_updateItem(aItem) {
+          updateItem: function(aItem) {
               let index = this.binding.mHash2Index[aItem.hashId];
               if (index) {
                   this.treebox.invalidateRow(index);
               }
           },
 
           /**
            * nsITreeView methods and properties
@@ -490,29 +490,29 @@
           get rowCount() {
               return this.binding.mTaskArray.length;
           },
 
           // TODO this code is currently identical to the unifinder. We should
           // create an itemTreeView that these tree views can inherit, that
           // contains this code, and possibly other code related to sorting and
           // storing items. See bug 432582 for more details.
-          getCellProperties: function mTV_getCellProperties(aRow, aCol) {
+          getCellProperties: function(aRow, aCol) {
               let rowProps = this.getRowProperties(aRow);
               let colProps = this.getColumnProperties(aCol);
               return rowProps + (rowProps && colProps ? " " : "") + colProps;
           },
 
           // Called to get properties to paint a column background.
           // For shading the sort column, etc.
-          getColumnProperties: function mTV_getColumnProperties(aCol) {
+          getColumnProperties: function(aCol) {
               return aCol.element.getAttribute("anonid") || "";
           },
 
-          getRowProperties: function mTV_getRowProperties(aRow) {
+          getRowProperties: function(aRow) {
               let properties = [];
               let item = this.binding.mTaskArray[aRow];
               if (item.priority > 0 && item.priority < 5) {
                   properties.push("highpriority");
               } else if (item.priority > 5 && item.priority < 10) {
                   properties.push("lowpriority");
               }
               properties.push(getProgressAtom(item));
@@ -535,17 +535,17 @@
               properties = properties.concat(item.getCategories({})
                                                  .map(formatStringForCSSRule));
 
               return properties.join(" ");
           },
 
           // Called on the view when a cell in a non-selectable cycling
           // column (e.g., unread/flag/etc.) is clicked.
-          cycleCell: function mTV_cycleCell(aRow, aCol) {
+          cycleCell: function(aRow, aCol) {
               let task = this.binding.mTaskArray[aRow];
 
               // prevent toggling completed status for parent items of
               // repeating tasks or when the calendar is read-only.
               if (!task || task.recurrenceInfo || task.calendar.readOnly) {
                   return;
               }
               if (aCol != null) {
@@ -554,17 +554,17 @@
                       let newTask = task.clone().QueryInterface(Components.interfaces.calITodo);
                       newTask.isCompleted = !task.completedDate;
                       doTransaction("modify", newTask, newTask.calendar, task, null);
                   }
               }
           },
 
           // Called on the view when a header is clicked.
-          cycleHeader: function mTV_cycleHeader(aCol) {
+          cycleHeader: function(aCol) {
               if (!this.selectedColumn) {
                   this.sortDirection = "ascending";
               } else if (!this.sortDirection || this.sortDirection == "descending") {
                   this.sortDirection = "ascending";
               } else {
                   this.sortDirection = "descending";
               }
               this.selectedColumn = aCol.element;
@@ -576,17 +576,17 @@
                       let index = this.binding.mHash2Index[item.hashId];
                       this.tree.view.selection.toggleSelect(index);
                   }
               }
           },
 
           // The text for a given cell. If a column consists only of an
           // image, then the empty string is returned.
-          getCellText: function mTV_getCellText(aRow, aCol) {
+          getCellText: function(aRow, aCol) {
               let task = this.binding.mTaskArray[aRow];
               if (!task) {
                   return false;
               }
 
               switch (aCol.element.getAttribute("itemproperty")) {
                   case "title":
                       // return title, or "Untitled" if empty/null
@@ -612,105 +612,105 @@
                   case "completed":
                   case "priority":
                   default:
                       return "";
               }
           },
 
           // This method is only called for columns of type other than text.
-          getCellValue: function mTV_getCellValue(aRow, aCol) {
+          getCellValue: function(aRow, aCol) {
               let task = this.binding.mTaskArray[aRow];
               if (!task) {
                   return null;
               }
               switch (aCol.element.getAttribute("itemproperty")) {
                   case "percentComplete":
                       return task.percentComplete;
               }
               return null;
           },
 
           // SetCellValue is called when the value of the cell has been set by the user.
           // This method is only called for columns of type other than text.
-          setCellValue: function mTV_setCellValue(aRow, aCol, aValue) {
+          setCellValue: function(aRow, aCol, aValue) {
               return null;
           },
 
           // The image path for a given cell. For defining an icon for a cell.
           // If the empty string is returned, the :moz-tree-image pseudoelement will be used.
-          getImageSrc: function mTV_getImageSrc(aRow, aCol) {
+          getImageSrc: function(aRow, aCol) {
              // Return the empty string in order
              // to use moz-tree-image pseudoelement :
              // it is mandatory to return "" and not false :-(
              return "";
           },
 
           // IsEditable is called to ask the view if the cell contents are editable.
           // A value of true will result in the tree popping up a text field when the user
           // tries to inline edit the cell.
-          isEditable: function mTV_isEditable(aRow, aCol) {
+          isEditable: function(aRow, aCol) {
               return true;
           },
 
           // Called during initialization to link the view to the front end box object.
-          setTree: function mTV_setTree(aTreeBox) {
+          setTree: function(aTreeBox) {
             this.treebox = aTreeBox;
           },
 
           // Methods that can be used to test whether or not a twisty should
           // be drawn, and if so, whether an open or closed twisty should be used.
-          isContainer: function mTV_isContainer(aRow) {
+          isContainer: function(aRow) {
               return false;
           },
-          isContainerOpen: function mTV_isContainerOpen(aRow) {
+          isContainerOpen: function(aRow) {
               return false;
           },
-          isContainerEmpty: function mTV_isContainerEmpty(aRow) {
+          isContainerEmpty: function(aRow) {
               return false;
           },
 
           // IsSeparator is used to determine if the row at index is a separator.
           // A value of true will result in the tree drawing a horizontal separator.
           // The tree uses the ::moz-tree-separator pseudoclass to draw the separator.
-          isSeparator: function mTV_isSeparator(aRow) {
+          isSeparator: function(aRow) {
               return false;
           },
 
           // Specifies if there is currently a sort on any column.
           // Used mostly by drag'n'drop to affect drop feedback.
-          isSorted: function mTV_isSorted(aRow) {
+          isSorted: function(aRow) {
               return false;
           },
 
-          canDrop: function mTV_canDrop() { return false; },
+          canDrop: function() { return false; },
 
-          drop: function mTV_drop(aRow, aOrientation) {},
+          drop: function(aRow, aOrientation) {},
 
-          getParentIndex: function mTV_getParentIndex(aRow) {
+          getParentIndex: function(aRow) {
               return -1;
           },
 
           // The level is an integer value that represents the level of indentation.
           // It is multiplied by the width specified in the :moz-tree-indentation
           // pseudoelement to compute the exact indendation.
-          getLevel: function mTV_getLevel(aRow) {
+          getLevel: function(aRow) {
               return 0;
           },
 
           // The image path for a given cell. For defining an icon for a cell.
           // If the empty string is returned, the :moz-tree-image pseudoelement
           // will be used.
-          getImgSrc: function mTV_getImgSrc(aRow, aCol) {
+          getImgSrc: function(aRow, aCol) {
               return null;
           },
 
           // The progress mode for a given cell. This method is only called for
           // columns of type |progressmeter|.
-          getProgressMode: function mTV_getProgressMode(aRow, aCol) {
+          getProgressMode: function(aRow, aCol) {
               switch (aCol.element.getAttribute("itemproperty")) {
                   case "percentComplete":
                       let task = this.binding.mTaskArray[aRow];
                       if (aCol.element.boxObject.width > 75 &&
                           task.percentComplete > 0) {
                           // XXX Would be nice if we could use relative widths,
                           // i.e "15ex", but there is no scriptable interface.
                           return Components.interfaces.nsITreeView.PROGRESS_NORMAL;
@@ -719,19 +719,19 @@
               }
 
               return Components.interfaces.nsITreeView.PROGRESS_NONE;
           },
 
           /**
            * Task Tree Events
            */
-          onSelect: function tTV_onSelect(event) {},
+          onSelect: function(event) {},
 
-          onDoubleClick: function tTV_onDoubleClick(event) {
+          onDoubleClick: function(event) {
               if (event.button == 0) {
                   let initialDate = getDefaultStartDate(this.binding.getInitialDate());
                   let col = {};
                   let item = this._getItemFromEvent(event, col);
                   if (item) {
                       let colAnonId = col.value.element.getAttribute("itemproperty");
                       if (colAnonId == "completed") {
                           // item holds checkbox state toggled by first click,
@@ -741,17 +741,17 @@
                           modifyEventWithDialog(item, null, true, initialDate);
                       }
                   } else {
                       createTodoWithDialog(null, null, null, null, initialDate);
                   }
               }
           },
 
-          onKeyPress: function tTV_onKeyPress(event) {
+          onKeyPress: function(event) {
               const kKE = Components.interfaces.nsIDOMKeyEvent;
               switch (event.keyCode || event.which) {
                   case kKE.DOM_VK_DELETE:
                       document.popupNode = this.binding;
                       document.getElementById("calendar_delete_todo_command").doCommand();
                       event.preventDefault();
                       event.stopPropagation();
                       break;
@@ -769,42 +769,42 @@
                       if (index > -1) {
                           modifyEventWithDialog(this.binding.mTaskArray[index]);
                       }
                       break;
               }
           },
 
           // Set the context menu on mousedown to change it before it is opened
-          onMouseDown: function tTV_onMouseDown(event) {
+          onMouseDown: function(event) {
               let tree = document.getAnonymousElementByAttribute(this.binding,
                                                                  "anonid",
                                                                  "calendar-task-tree");
 
               if (!this._getItemFromEvent(event)) {
                   tree.view.selection.invalidateSelection();
               }
           },
 
           /**
            * Private methods and attributes
            */
 
-          _getItemFromEvent: function tTV_getItemFromEvent(event, aCol, aRow) {
+          _getItemFromEvent: function(event, aCol, aRow) {
             aRow = aRow || {};
             let childElt = {};
             this.treebox.getCellAt(event.clientX, event.clientY, aRow, aCol || {}, childElt);
             if (!childElt.value) {
                 return false;
             }
             return aRow && aRow.value > -1 && this.binding.mTaskArray[aRow.value];
           },
 
           // Helper function to display datetimes
-          _formatDateTime: function tTV_formatDateTime(aDateTime) {
+          _formatDateTime: function(aDateTime) {
               let dateFormatter = Components.classes["@mozilla.org/calendar/datetime-formatter;1"]
                                             .getService(Components.interfaces.calIDateTimeFormatter);
 
               // datetime is from todo object, it is not a javascript date
               if (aDateTime && aDateTime.isValid) {
                   let dateTime = aDateTime.getInTimezone(calendarDefaultTimezone());
                   return dateFormatter.formatDateTime(dateTime);
               }
@@ -824,81 +824,81 @@
           QueryInterface: XPCOMUtils.generateQI([
               Components.interfaces.calICompositeObserver,
               Components.interfaces.calIObserver
           ]),
 
           /**
            * calIObserver methods and properties
            */
-          onStartBatch: function tTO_onStartBatch() {
+          onStartBatch: function() {
           },
 
-          onEndBatch: function tTO_onEndBatch() {
+          onEndBatch: function() {
           },
 
-          onLoad: function tTO_onLoad() {
+          onLoad: function() {
               this.binding.refresh();
           },
 
-          onAddItem: function tTO_onAddItem(aItem) {
+          onAddItem: function(aItem) {
               if (cal.isToDo(aItem)) {
                   this.binding.mTreeView.addItems(this.binding.mFilter.getOccurrences(aItem));
               }
           },
 
-          onModifyItem: function tTO_onModifyItem(aNewItem, aOldItem) {
-              if ((cal.isToDo(aNewItem) || cal.isToDo(aOldItem))) {
+          onModifyItem: function(aNewItem, aOldItem) {
+              if (cal.isToDo(aNewItem) || cal.isToDo(aOldItem)) {
                   this.binding.mTreeView.modifyItems(this.binding.mFilter.getOccurrences(aNewItem),
                                                      this.binding.mFilter.getOccurrences(aOldItem));
 
                   // we also need to notify potential listeners.
                   let event = document.createEvent("Events");
                   event.initEvent("select", true, false);
                   this.binding.dispatchEvent(event);
               }
           },
 
-          onDeleteItem: function tTO_onDeleteItem(aDeletedItem) {
+          onDeleteItem: function(aDeletedItem) {
               if (cal.isToDo(aDeletedItem)) {
                   this.binding.mTreeView.removeItems(this.binding.mFilter.getOccurrences(aDeletedItem));
               }
           },
 
-          onError: function tTO_onError(aCalendar, aErrNo, aMessage) {},
-          onPropertyChanged: function tTO_onPropertyChanged(aCalendar, aName, aValue, aOldValue) {
+          onError: function(aCalendar, aErrNo, aMessage) {},
+          onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {
               switch (aName) {
                   case "disabled":
                       if (aValue) {
                           this.binding.onCalendarRemoved(aCalendar);
                       } else {
                           this.binding.onCalendarAdded(aCalendar);
                       }
                       break;
               }
           },
 
-          onPropertyDeleting: function tTO_onPropertyDeleting(aCalendar, aName) {
+          onPropertyDeleting: function(aCalendar, aName) {
               this.onPropertyChanged(aCalendar, aName, null, null);
           },
 
           /**
            * calICompositeObserver methods and properties
            */
-          onCalendarAdded: function tTO_onCalendarAdded(aCalendar) {
+          onCalendarAdded: function(aCalendar) {
               if (!aCalendar.getProperty("disabled")) {
                   this.binding.onCalendarAdded(aCalendar);
               }
           },
 
-          onCalendarRemoved: function tTO_onCalendarRemoved(aCalendar) {
+          onCalendarRemoved: function(aCalendar) {
               this.binding.onCalendarRemoved(aCalendar);
           },
 
-          onDefaultCalendarChanged: function tTO_onDefaultCalendarChanged(aNewDefaultCalendar) {}
+          onDefaultCalendarChanged: function(aNewDefaultCalendar) {}
       })
       ]]></field>
 
       <method name="observe">
         <parameter name="aSubject"/>
         <parameter name="aTopic"/>
         <parameter name="aPrefName"/>
         <body><![CDATA[
--- a/calendar/base/content/calendar-task-view.js
+++ b/calendar/base/content/calendar-task-view.js
@@ -11,17 +11,17 @@ Components.utils.import("resource://gre/
 var taskDetailsView = {
 
     /**
      * Task Details Events
      *
      * XXXberend Please document this function, possibly also consolidate since
      * its the only function in taskDetailsView.
      */
-    onSelect: function tDV_onSelect(event) {
+    onSelect: function(event) {
         function displayElement(id, flag) {
             setBooleanAttribute(id, "hidden", !flag);
             return flag;
         }
 
         let dateFormatter =
             Components.classes["@mozilla.org/calendar/datetime-formatter;1"]
             .getService(Components.interfaces.calIDateTimeFormatter);
@@ -142,23 +142,23 @@ var taskDetailsView = {
                                           "if (event.button != 2) launchBrowser(this.value);");
                     urlLabel.setAttribute("context", "taskview-link-context-menu");
                     attachmentRows.appendChild(urlLabel);
                 }
             }
         }
     },
 
-    loadCategories: function loadCategories(event) {
+    loadCategories: function(event) {
         let panel = event.target;
         let item = document.getElementById("calendar-task-tree").currentTask;
         panel.loadItem(item);
     },
 
-    saveCategories: function saveCategories(event) {
+    saveCategories: function(event) {
         let panel = event.target;
         let item = document.getElementById("calendar-task-tree").currentTask;
         let categoriesMap = {};
 
         for (let cat of item.getCategories({})) {
             categoriesMap[cat] = true;
         }
 
--- a/calendar/base/content/calendar-unifinder.js
+++ b/calendar/base/content/calendar-unifinder.js
@@ -58,92 +58,92 @@ function getCurrentUnifinderFilter() {
 var unifinderObserver = {
     QueryInterface: XPCOMUtils.generateQI([
         Components.interfaces.calICompositeObserver,
         Components.interfaces.nsIObserver,
         Components.interfaces.calIObserver
     ]),
 
     // calIObserver:
-    onStartBatch: function uO_onStartBatch() {
+    onStartBatch: function() {
     },
 
-    onEndBatch: function uO_onEndBatch() {
+    onEndBatch: function() {
         refreshEventTree();
     },
 
-    onLoad: function uO_onLoad() {
+    onLoad: function() {
         if (isUnifinderHidden() && !gUnifinderNeedsRefresh) {
             // If the unifinder is hidden, all further item operations might
             // produce invalid entries in the unifinder. From now on, ignore
             // those operations and refresh as soon as the unifinder is shown
             // again.
             gUnifinderNeedsRefresh = true;
             unifinderTreeView.clearItems();
         }
     },
 
-    onAddItem: function uO_onAddItem(aItem) {
+    onAddItem: function(aItem) {
         if (isEvent(aItem) &&
             !gUnifinderNeedsRefresh &&
             unifinderTreeView.mFilter.isItemInFilters(aItem)
             ) {
             this.addItemToTree(aItem);
         }
     },
 
-    onModifyItem: function uO_onModifyItem(aNewItem, aOldItem) {
+    onModifyItem: function(aNewItem, aOldItem) {
         this.onDeleteItem(aOldItem);
         this.onAddItem(aNewItem);
     },
 
-    onDeleteItem: function uO_onDeleteItem(aDeletedItem) {
+    onDeleteItem: function(aDeletedItem) {
         if (isEvent(aDeletedItem) && !gUnifinderNeedsRefresh) {
             this.removeItemFromTree(aDeletedItem);
         }
     },
 
-    onError: function uO_onError(aCalendar, aErrNo, aMessage) {},
+    onError: function(aCalendar, aErrNo, aMessage) {},
 
-    onPropertyChanged: function uO_onPropertyChanged(aCalendar, aName, aValue, aOldValue) {
+    onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {
         switch (aName) {
             case "disabled":
                 refreshEventTree();
                 break;
         }
     },
 
-    onPropertyDeleting: function uO_onPropertyDeleting(aCalendar, aName) {
+    onPropertyDeleting: function(aCalendar, aName) {
       this.onPropertyChanged(aCalendar, aName, null, null);
     },
 
     // calICompositeObserver:
-    onCalendarAdded: function uO_onCalendarAdded(aAddedCalendar) {
+    onCalendarAdded: function(aAddedCalendar) {
         if (!aAddedCalendar.getProperty("disabled")) {
             addItemsFromCalendar(aAddedCalendar,
                                  addItemsFromSingleCalendarInternal);
         }
     },
 
-    onCalendarRemoved: function uO_onCalendarRemoved(aDeletedCalendar) {
+    onCalendarRemoved: function(aDeletedCalendar) {
         if (!aDeletedCalendar.getProperty("disabled")) {
             deleteItemsFromCalendar(aDeletedCalendar);
         }
     },
 
-    onDefaultCalendarChanged: function uO_onDefaultCalendarChanged(aNewDefaultCalendar) {},
+    onDefaultCalendarChanged: function(aNewDefaultCalendar) {},
 
     /**
      * Add an unifinder item to the tree. It is safe to call these for any
      * event. The functions will determine whether or not anything actually
      * needs to be done to the tree.
      *
      * @return aItem        The item to add to the tree.
      */
-    addItemToTree: function uO_addItemToTree(aItem) {
+    addItemToTree: function(aItem) {
         let items;
         let filter = unifinderTreeView.mFilter;
 
         if (filter.startDate && filter.endDate) {
             items = aItem.getOccurrencesBetween(filter.startDate, filter.endDate, {});
         } else {
             items = [aItem];
         }
@@ -152,29 +152,29 @@ var unifinderObserver = {
 
     /**
      * Remove an item from the unifinder tree. It is safe to call these for any
      * event. The functions will determine whether or not anything actually
      * needs to be done to the tree.
      *
      * @return aItem        The item to remove from the tree.
      */
-    removeItemFromTree: function uO_removeItemFromTree(aItem) {
+    removeItemFromTree: function(aItem) {
         let items;
         let filter = unifinderTreeView.mFilter;
         if (filter.startDate && filter.endDate && (aItem.parentItem == aItem)) {
             items = aItem.getOccurrencesBetween(filter.startDate, filter.endDate, {});
         } else {
             items = [aItem];
         }
         // XXX: do we really still need this, we are always checking it in the refreshInternal
         unifinderTreeView.removeItems(items.filter(filter.isItemInFilters, filter));
     },
 
-    observe: function uO_observe(aSubject, aTopic, aPrefName) {
+    observe: function(aSubject, aTopic, aPrefName) {
         switch (aPrefName) {
             case "calendar.date.format":
             case "calendar.timezone.local":
                 refreshEventTree();
                 break;
         }
     }
 };
@@ -439,34 +439,34 @@ var unifinderTreeView = {
     eventIndexMap: {},
 
     /**
      * Add an item to the unifinder tree.
      *
      * @param aItemArray        An array of items to add.
      * @param aDontSort         If true, the items will only be appended.
      */
-    addItems: function uTV_addItems(aItemArray, aDontSort) {
+    addItems: function(aItemArray, aDontSort) {
         this.eventArray = this.eventArray.concat(aItemArray);
         let newCount = (this.eventArray.length - aItemArray.length - 1);
         this.tree.rowCountChanged(newCount, aItemArray.length);
 
         if (aDontSort) {
             this.calculateIndexMap();
         } else {
             this.sortItems();
         }
     },
 
     /**
      * Remove items from the unifinder tree.
      *
      * @param aItemArray        An array of items to remove.
      */
-    removeItems: function uTV_removeItems(aItemArray) {
+    removeItems: function(aItemArray) {
         let indexesToRemove = [];
         // Removing items is a bit tricky. Our getItemRow function takes the
         // index from a cached map, so removing an item from the array will
         // remove the wrong indexes. We don't want to just invalidate the map,
         // since this will cause O(n^2) behavior. Instead, we keep a sorted
         // array of the indexes to remove:
         for (let item of aItemArray) {
             let row = this.getItemRow(item);
@@ -495,28 +495,28 @@ var unifinderTreeView = {
         // (given that Array.unshift doesn't loop but just prepends or maps
         // memory smartly) O(3n) behavior. Lets hope its worth it.
         this.calculateIndexMap(true);
     },
 
     /**
      * Clear all items from the unifinder.
      */
-    clearItems: function uTV_clearItems() {
+    clearItems: function() {
         let oldCount = this.eventArray.length;
         this.eventArray = [];
         this.tree.rowCountChanged(0, -oldCount);
         this.calculateIndexMap();
     },
 
     /**
      * Sets the items that should be in the unifinder. This removes all items
      * that were previously in the unifinder.
      */
-    setItems: function uTV_setItems(aItemArray, aDontSort) {
+    setItems: function(aItemArray, aDontSort) {
         let oldCount = this.eventArray.length;
         this.eventArray = aItemArray.slice(0);
         this.tree.rowCountChanged(oldCount - 1, this.eventArray.length - oldCount);
 
         if (aDontSort) {
             this.calculateIndexMap();
         } else {
             this.sortItems();
@@ -527,31 +527,31 @@ var unifinderTreeView = {
      * Recalculate the index map that improves performance when accessing
      * unifinder items. This is usually done automatically when adding/removing
      * items.
      *
      * @param aDontInvalidate       (optional) Don't invalidate the tree, i.e if
      *                                you correctly issued rowCountChanged
      *                                notices.
      */
-    calculateIndexMap: function uTV_calculateIndexMap(aDontInvalidate) {
+    calculateIndexMap: function(aDontInvalidate) {
         this.eventIndexMap = {};
         for (let i = 0; i < this.eventArray.length; i++) {
             this.eventIndexMap[this.eventArray[i].hashId] = i;
         }
 
         if (!aDontInvalidate) {
             this.tree.invalidate();
         }
     },
 
     /**
      * Sort the items in the unifinder by the currently selected column.
      */
-    sortItems: function uTV_sortItems() {
+    sortItems: function() {
         if (this.selectedColumn) {
             let modifier = (this.sortDirection == "descending" ? -1 : 1);
             let sortKey = unifinderTreeView.selectedColumn.getAttribute("itemproperty");
             let sortType = cal.getSortTypeForSortKey(sortKey);
             // sort (key,item) entries
             cal.sortEntry.mSortKey = sortKey;
             cal.sortEntry.mSortStartedDate = now();
             let entries = this.eventArray.map(cal.sortEntry, cal.sortEntry);
@@ -562,54 +562,54 @@ var unifinderTreeView = {
     },
 
     /**
      * Get the index of the row associated with the passed item.
      *
      * @param item      The item to search for.
      * @return          The row index of the passed item.
      */
-    getItemRow: function uTV_getItemRow(item) {
+    getItemRow: function(item) {
         if (this.eventIndexMap[item.hashId] === undefined) {
             return -1;
         }
         return this.eventIndexMap[item.hashId];
     },
 
     /**
      * Get the item at the given row index.
      *
      * @param item      The row index to get the item for.
      * @return          The item at the given row.
      */
-    getItemAt: function uTV_getItemAt(aRow) {
+    getItemAt: function(aRow) {
         return this.eventArray[aRow];
     },
 
     /**
      * Get the calendar item from the given DOM event
      *
      * @param event     The DOM mouse event to get the item for.
      * @return          The item under the mouse position.
      */
-    getItemFromEvent: function uTV_getItemFromEvent(event) {
+    getItemFromEvent: function(event) {
         let row = this.tree.getRowAt(event.clientX, event.clientY);
 
         if (row > -1) {
             return this.getItemAt(row);
         }
         return null;
     },
 
     /**
      * Change the selection in the unifinder.
      *
      * @param aItemArray        An array of items to select.
      */
-    setSelectedItems: function uTV_setSelectedItems(aItemArray) {
+    setSelectedItems: function(aItemArray) {
         if (this.doingSelection || !this.tree || !this.tree.view) {
             return;
         }
 
         this.doingSelection = true;
 
         // If no items were passed, get the selected items from the view.
         aItemArray = aItemArray || currentView().getSelectedItems({});
@@ -646,17 +646,17 @@ var unifinderTreeView = {
         // This needs to be in a setTimeout
         setTimeout(function() { unifinderTreeView.resetAllowSelection(); }, 1);
     },
 
     /**
      * Due to a selection issue described in bug 168211 this method is needed to
      * re-add the selection listeners selection listeners.
      */
-    resetAllowSelection: function uTV_resetAllowSelection() {
+    resetAllowSelection: function() {
         if (!this.tree) {
             return;
         }
         /**
          * Do not change anything in the following lines, they are needed as
          * described in the selection observer above
          */
         this.doingSelection = false;
@@ -673,22 +673,22 @@ var unifinderTreeView = {
         return this.eventArray.length;
     },
 
 
     // TODO this code is currently identical to the task tree. We should create
     // an itemTreeView that these tree views can inherit, that contains this
     // code, and possibly other code related to sorting and storing items. See
     // bug 432582 for more details.
-    getCellProperties: function uTV_getCellProperties(aRow, aCol) {
+    getCellProperties: function(aRow, aCol) {
         let rowProps = this.getRowProperties(aRow);
         let colProps = this.getColumnProperties(aCol);
         return rowProps + (rowProps && colProps ? " " : "") + colProps;
     },
-    getRowProperties: function uTV_getRowProperties(aRow) {
+    getRowProperties: function(aRow) {
         let properties = [];
         let item = this.eventArray[aRow];
         if (item.priority > 0 && item.priority < 5) {
             properties.push("highpriority");
         } else if (item.priority > 5 && item.priority < 10) {
             properties.push("lowpriority");
         }
 
@@ -706,63 +706,63 @@ var unifinderTreeView = {
         }
 
         // Task categories
         properties = properties.concat(item.getCategories({})
                                            .map(formatStringForCSSRule));
 
         return properties.join(" ");
     },
-    getColumnProperties: function uTV_getColumnProperties(aCol) { return ""; },
+    getColumnProperties: function(aCol) { return ""; },
 
-    isContainer: function uTV_isContainer() {
+    isContainer: function() {
         return false;
     },
 
-    isContainerOpen: function uTV_isContainerOpen(aRow) {
+    isContainerOpen: function(aRow) {
         return false;
     },
 
-    isContainerEmpty: function uTV_isContainerEmpty(aRow) {
+    isContainerEmpty: function(aRow) {
         return false;
     },
 
-    isSeparator: function uTV_isSeparator(aRow) {
+    isSeparator: function(aRow) {
         return false;
     },
 
-    isSorted: function uTV_isSorted(aRow) {
+    isSorted: function(aRow) {
         return false;
     },
 
-    canDrop: function uTV_canDrop(aRow, aOrientation) {
+    canDrop: function(aRow, aOrientation) {
         return false;
     },
 
-    drop: function uTV_drop(aRow, aOrientation) {},
+    drop: function(aRow, aOrientation) {},
 
-    getParentIndex: function uTV_getParentIndex(aRow) {
+    getParentIndex: function(aRow) {
         return -1;
     },
 
-    hasNextSibling: function uTV_hasNextSibling(aRow, aAfterIndex) {},
+    hasNextSibling: function(aRow, aAfterIndex) {},
 
-    getLevel: function uTV_getLevel(aRow) {
+    getLevel: function(aRow) {
         return 0;
     },
 
-    getImageSrc: function uTV_getImageSrc(aRow, aOrientation) {},
+    getImageSrc: function(aRow, aOrientation) {},
 
-    getProgressMode: function uTV_getProgressMode(aRow, aCol) {},
+    getProgressMode: function(aRow, aCol) {},
 
-    getCellValue: function uTV_getCellValue(aRow, aCol) {
+    getCellValue: function(aRow, aCol) {
         return null;
     },
 
-    getCellText: function uTV_getCellText(row, column) {
+    getCellText: function(row, column) {
         let calendarEvent = this.eventArray[row];
 
         switch (column.element.getAttribute("itemproperty")) {
             case "title":
                 return (calendarEvent.title ? calendarEvent.title.replace(/\n/g, " ") : "");
             case "startDate":
                 return formatUnifinderEventDateTime(calendarEvent.startDate);
 
@@ -788,46 +788,46 @@ var unifinderTreeView = {
             case "calendar":
                 return calendarEvent.calendar.name;
 
             default:
                 return false;
         }
     },
 
-    setTree: function uTV_setTree(tree) {
+    setTree: function(tree) {
         this.tree = tree;
     },
 
-    toggleOpenState: function uTV_toggleOpenState(aRow) {},
+    toggleOpenState: function(aRow) {},
 
-    cycleHeader: function uTV_cycleHeader(col) {
+    cycleHeader: function(col) {
         if (!this.selectedColumn) {
             this.sortDirection = "ascending";
         } else if (!this.sortDirection || this.sortDirection == "descending") {
             this.sortDirection = "ascending";
         } else {
             this.sortDirection = "descending";
         }
         this.selectedColumn = col.element;
         this.sortItems();
     },
 
-    isEditable: function uTV_isEditable(aRow, aCol) {
+    isEditable: function(aRow, aCol) {
         return false;
     },
 
-    setCellValue: function uTV_setCellValue(aRow, aCol, aValue) {},
-    setCellText: function uTV_setCellText(aRow, aCol, aValue) {},
+    setCellValue: function(aRow, aCol, aValue) {},
+    setCellText: function(aRow, aCol, aValue) {},
 
-    performAction: function uTV_performAction(aAction) {},
+    performAction: function(aAction) {},
 
-    performActionOnRow: function uTV_performActionOnRow(aAction, aRow) {},
+    performActionOnRow: function(aAction, aRow) {},
 
-    performActionOnCell: function uTV_performActionOnCell(aAction, aRow, aCol) {},
+    performActionOnCell: function(aAction, aRow, aCol) {},
 
     outParameter: {} // used to obtain dates during sort
 };
 
 /**
  * Refresh the unifinder tree by getting items from the composite calendar and
  * applying the current filter.
  */
@@ -877,33 +877,24 @@ function addItemsFromCalendar(aCalendar,
         // If the unifinder is hidden, don't refresh the events to reduce needed
         // getItems calls.
         return;
     }
     let refreshListener = {
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
         mEventArray: [],
 
-        onOperationComplete: function rET_onOperationComplete(aOpCalendar,
-                                                              aStatus,
-                                                              aOperationType,
-                                                              aId,
-                                                              aDateTime) {
+        onOperationComplete: function(aOpCalendar, aStatus, aOperationType, aId, aDateTime) {
             let refreshTreeInternalFunc = function() {
                 aAddItemsInternalFunc(refreshListener.mEventArray);
             };
             setTimeout(refreshTreeInternalFunc, 0);
         },
 
-        onGetResult: function rET_onGetResult(aOpCalendar,
-                                              aStatus,
-                                              aItemType,
-                                              aDetail,
-                                              aCount,
-                                              aItems) {
+        onGetResult: function(aOpCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
             refreshListener.mEventArray = refreshListener.mEventArray.concat(aItems);
         }
     };
 
     let filter = 0;
 
     filter |= aCalendar.ITEM_FILTER_TYPE_EVENT;
 
--- a/calendar/base/content/calendar-view-core.xml
+++ b/calendar/base/content/calendar-view-core.xml
@@ -66,34 +66,33 @@
     </content>
 
     <implementation>
       <constructor><![CDATA[
          Components.utils.import("resource://calendar/modules/calAlarmUtils.jsm");
          Components.utils.import("resource://calendar/modules/calUtils.jsm");
          Components.utils.import("resource://gre/modules/Preferences.jsm");
 
-         let self = this;
-         this.eventNameTextbox.onblur = function onBlur() {
-             self.stopEditing(true);
+         this.eventNameTextbox.onblur = () => {
+             this.stopEditing(true);
          };
-         this.eventNameTextbox.onkeypress = function onKeyPress(event) {
+         this.eventNameTextbox.onkeypress = (event) => {
              // save on enter
              if (event.keyCode == 13) {
-                 self.stopEditing(true);
+                 this.stopEditing(true);
              // abort on escape
              } else if (event.keyCode == 27) {
-                 self.stopEditing(false);
+                 this.stopEditing(false);
              }
          };
-         function stopPropagationIfEditing(event) {
-           if (self.mEditing) {
+         let stopPropagationIfEditing = (event) => {
+           if (this.mEditing) {
              event.stopPropagation();
            }
-         }
+         };
          // while editing, single click positions cursor, so don't propagate.
          this.eventNameTextbox.onclick = stopPropagationIfEditing;
          // while editing, double click selects words, so don't propagate.
          this.eventNameTextbox.ondblclick = stopPropagationIfEditing;
          // while editing, don't propagate mousedown/up (selects calEvent).
          this.eventNameTextbox.onmousedown = stopPropagationIfEditing;
          this.eventNameTextbox.onmouseup = stopPropagationIfEditing;
       ]]></constructor>
@@ -322,21 +321,20 @@
 
         // If the left button was used and the item is already selected
         // and there are no multiple items selected start
         // the 'single click edit' timeout. Otherwise select the item too.
         // Also, check if the calendar is readOnly or we are offline.
 
         if (this.selected && !(event.ctrlKey || event.metaKey) &&
               isCalendarWritable(this.mOccurrence.calendar)) {
-            let self = this;
             if (this.editingTimer) {
                 clearTimeout(this.editingTimer);
             }
-            this.editingTimer = setTimeout(function editingTimeout() { self.startEditing(); }, 350);
+            this.editingTimer = setTimeout(() => this.startEditing(), 350);
         } else {
             this.select(event);
             event.stopPropagation();
         }
       ]]></handler>
 
       <handler event="dblclick" button="0"><![CDATA[
         event.stopPropagation();
--- a/calendar/base/content/calendar-views.js
+++ b/calendar/base/content/calendar-views.js
@@ -400,17 +400,17 @@ function updateStyleSheetForViews(aCalen
  * Note we need to keep the categoryPrefBranch variable outside of
  * initCategories since branch observers only live as long as the branch object
  * is alive, and out of categoryManagement to avoid cyclic references.
  */
 var categoryPrefBranch;
 var categoryManagement = {
     QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIObserver]),
 
-    initCategories: function cM_initCategories() {
+    initCategories: function() {
       categoryPrefBranch = Services.prefs.getBranch("calendar.category.color.");
       let categories = categoryPrefBranch.getChildList("");
 
       // Fix illegally formatted category prefs.
       for (let i in categories) {
           let category = categories[i];
           if (category.search(/[^_0-9a-z-]/) != -1) {
               let categoryFix = formatStringForCSSRule(category);
@@ -426,33 +426,33 @@ var categoryManagement = {
       }
 
       // Add color information to the stylesheets.
       categories.forEach(categoryManagement.updateStyleSheetForCategory,
                          categoryManagement);
       categoryPrefBranch.addObserver("", categoryManagement, false);
     },
 
-    cleanupCategories: function cM_cleanupCategories() {
+    cleanupCategories: function() {
       categoryPrefBranch = Services.prefs.getBranch("calendar.category.color.");
       categoryPrefBranch.removeObserver("", categoryManagement);
     },
 
-    observe: function cM_observe(aSubject, aTopic, aPrefName) {
+    observe: function(aSubject, aTopic, aPrefName) {
         this.updateStyleSheetForCategory(aPrefName);
         // TODO Currently, the only way to find out if categories are removed is
         // to initially grab the calendar.categories.names preference and then
         // observe changes to it. it would be better if we had hooks for this,
         // so we could delete the rule from our style cache and also remove its
         // color preference.
     },
 
     categoryStyleCache: {},
 
-    updateStyleSheetForCategory: function cM_updateStyleSheetForCategory(aCatName) {
+    updateStyleSheetForCategory: function(aCatName) {
         if (!(aCatName in this.categoryStyleCache)) {
             // We haven't created a rule for this category yet, do so now.
             let sheet = getViewStyleSheet();
             let ruleString = '.category-color-box[categories~="' + aCatName + '"] {} ';
             let ruleIndex = sheet.insertRule(ruleString, sheet.cssRules.length);
 
             this.categoryStyleCache[aCatName] = sheet.cssRules[ruleIndex];
         }
@@ -637,23 +637,20 @@ function editSelectedEvents() {
 
 /**
  * Select all events from all calendars. Use with care.
  */
 function selectAllEvents() {
     let items = [];
     let listener = {
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-        onOperationComplete: function selectAll_ooc(aCalendar, aStatus,
-                                                    aOperationType, aId,
-                                                    aDetail) {
+        onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDetail) {
             currentView().setSelectedItems(items.length, items, false);
         },
-        onGetResult: function selectAll_ogr(aCalendar, aStatus, aItemType,
-                                            aDetail, aCount, aItems) {
+        onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
             for (let item of aItems) {
                 items.push(item);
             }
         }
     };
 
     let composite = getCompositeCalendar();
     let filter = composite.ITEM_FILTER_CLASS_OCCURRENCES;
@@ -673,17 +670,17 @@ function selectAllEvents() {
     let end = currentView().endDay.clone();
     end.day += 1;
 
     composite.getItems(filter, 0, currentView().startDay, end, listener);
 }
 
 var cal = cal || {};
 cal.navigationBar = {
-    setDateRange: function setDateRange(aStartDate, aEndDate) {
+    setDateRange: function(aStartDate, aEndDate) {
         let docTitle = "";
         if (aStartDate) {
             let intervalLabel = document.getElementById("intervalDescription");
             let firstWeekNo = getWeekInfoService().getWeekTitle(aStartDate);
             let secondWeekNo = firstWeekNo;
             let weekLabel = document.getElementById("calendarWeek");
             if (aStartDate.nativeTime == aEndDate.nativeTime) {
                 intervalLabel.value = getDateFormatter().formatDate(aStartDate);
--- a/calendar/base/content/calendar-views.xml
+++ b/calendar/base/content/calendar-views.xml
@@ -51,20 +51,19 @@
         </implementation>
     </binding>
 
     <binding id="calendar-week-view"
              extends="chrome://calendar/content/calendar-multiday-view.xml#calendar-multiday-view">
         <implementation implements="calICalendarView">
             <constructor><![CDATA[
                 // add a listener for the mode change
-                let self = this;
-                this.mModeHandler = function modeHandler(event) {
+                this.mModeHandler = (event) => {
                     if (event.attrName == "mode") {
-                        self.onModeChanged(event);
+                        this.onModeChanged(event);
                     }
                 };
                 document.getElementById("modeBroadcaster").addEventListener("DOMAttrModified", this.mModeHandler, true);
             ]]></constructor>
             <destructor><![CDATA[
                 document.getElementById("modeBroadcaster").removeEventListener("DOMAttrModified", this.mModeHandler, true);
             ]]></destructor>
 
--- a/calendar/base/content/dialogs/calendar-alarm-dialog.js
+++ b/calendar/base/content/dialogs/calendar-alarm-dialog.js
@@ -94,17 +94,17 @@ var gRelativeDateUpdateTimer;
 function setupWindow() {
     // We want to update when we are at 0 seconds past the minute. To do so, use
     // setTimeout to wait until we are there, then setInterval to execute every
     // minute. Since setInterval is not totally exact, we may run into problems
     // here. I hope not!
     let current = new Date();
 
     let timeout = (60 - current.getSeconds()) * 1000;
-    gRelativeDateUpdateTimer = setTimeout(function wait_until_next_minute() {
+    gRelativeDateUpdateTimer = setTimeout(() => {
         updateRelativeDates();
         gRelativeDateUpdateTimer = setInterval(updateRelativeDates, 60 * 1000);
     }, timeout);
 
     // Give focus to the alarm richlist after onload completes. See bug 103197
     setTimeout(onFocusWindow, 0);
 }
 
--- a/calendar/base/content/dialogs/calendar-event-dialog-attendees.js
+++ b/calendar/base/content/dialogs/calendar-event-dialog-attendees.js
@@ -104,17 +104,17 @@ function onLoad() {
                                   scrollbar.boxObject.height + "px; }", 0);
             break;
         }
     }
 
     // attach an observer to get notified of changes
     // that are relevant to this dialog.
     let prefObserver = {
-        observe: function aD_observe(aSubject, aTopic, aPrefName) {
+        observe: function(aSubject, aTopic, aPrefName) {
             switch (aPrefName) {
                 case "calendar.view.daystarthour":
                 case "calendar.view.dayendhour":
                     initTimeRange();
                     propagateDateTime();
                     break;
             }
         }
@@ -989,17 +989,17 @@ function onTimeChange(event) {
  * binding. It has been taken out of the binding to prevent leaks.
  */
 function calFreeBusyListener(aFbElement, aBinding) {
     this.mFbElement = aFbElement;
     this.mBinding = aBinding;
 }
 
 calFreeBusyListener.prototype = {
-    onResult: function cFBL_onResult(aRequest, aEntries) {
+    onResult: function(aRequest, aEntries) {
         if (aRequest && !aRequest.isPending) {
             // Find request in list of pending requests and remove from queue:
             this.mBinding.mPendingRequests = this.mBinding.mPendingRequests.filter(aOp => aRequest.id != aOp.id);
         }
         if (aEntries) {
             this.mFbElement.onFreeBusy(aEntries);
         }
     }
--- a/calendar/base/content/dialogs/calendar-event-dialog-attendees.xml
+++ b/calendar/base/content/dialogs/calendar-event-dialog-attendees.xml
@@ -66,21 +66,17 @@
 
       <constructor><![CDATA[
         Components.utils.import("resource://calendar/modules/calUtils.jsm");
         Components.utils.import("resource://gre/modules/Services.jsm");
         Components.utils.import("resource:///modules/mailServices.js");
 
         this.mMaxAttendees = 0;
 
-        let self = this;
-        let load = function loadHandler() {
-            self.onLoad();
-        };
-        window.addEventListener("load", load, true);
+        window.addEventListener("load", this.onLoad.bind(this), true);
       ]]></constructor>
 
       <method name="onLoad">
         <body><![CDATA[
           this.onInitialize();
 
           // this trigger the continous update chain, which
           // effectively calls this.onModify() on predefined
@@ -703,22 +699,20 @@
       <property name="documentSize">
         <getter><![CDATA[
             return this.mRowHeight * this.mMaxAttendees;
         ]]></getter>
       </property>
 
       <method name="fitDummyRows">
         <body><![CDATA[
-          let self = this;
-          let func = function attendees_list_fitDummyRows() {
-              self.calcContentHeight();
-              self.createOrRemoveDummyRows();
-          };
-          setTimeout(func, 0);
+          setTimeout(() => {
+              this.calcContentHeight();
+              this.createOrRemoveDummyRows();
+          }, 0);
         ]]></body>
       </method>
 
       <method name="calcContentHeight">
         <body><![CDATA[
           let listbox =
               document.getAnonymousElementByAttribute(
                   this, "anonid", "listbox");
--- a/calendar/base/content/dialogs/calendar-event-dialog-freebusy.xml
+++ b/calendar/base/content/dialogs/calendar-event-dialog-freebusy.xml
@@ -436,21 +436,17 @@
         // of the timebar starts. The range is the number of days
         // we should be able to show. The start- and enddate
         // is the time the event is scheduled for.
         let kDefaultTimezone = calendarDefaultTimezone();
         this.startDate = startTime.getInTimezone(kDefaultTimezone);
         this.endDate = endTime.getInTimezone(kDefaultTimezone);
         this.mRange = Number(this.getAttribute("range"));
 
-        let self = this;
-        let load = function loadHandler() {
-            self.onLoad();
-        };
-        window.addEventListener("load", load, true);
+        window.addEventListener("load", this.onLoad.bind(this), true);
       ]]></constructor>
 
       <method name="refresh">
         <body><![CDATA[
           let date = this.mStartDate.clone();
           let template =
               document.getAnonymousElementByAttribute(
                   this, "anonid", "template");
@@ -1081,25 +1077,18 @@
 
         this.initTimeRange();
 
         this.mRange = Number(this.getAttribute("range"));
 
         this.mMaxFreeBusy = 0;
         this.mPendingRequests = [];
 
-        let self = this;
-        let load = function freebusy_grid_loadHandler() {
-            self.onLoad();
-        };
-        window.addEventListener("load", load, true);
-        let unload = function freebusy_grid_unloadHandler() {
-            self.onUnload();
-        };
-        window.addEventListener("unload", unload, true);
+        window.addEventListener("load", this.onLoad.bind(this), true);
+        window.addEventListener("unload", this.onUnload.bind(this), true);
       ]]></constructor>
 
       <property name="startDate">
         <getter><![CDATA[
           return this.mStartDate;
         ]]></getter>
         <setter><![CDATA[
           this.mStartDate = val.clone();
@@ -1497,22 +1486,20 @@
               }
           }
           return null;
         ]]></body>
       </method>
 
       <method name="fitDummyRows">
         <body><![CDATA[
-          let self = this;
-          let func = function func() {
-              self.calcContentHeight();
-              self.createOrRemoveDummyRows();
-          };
-          setTimeout(func, 0);
+          setTimeout(() => {
+              this.calcContentHeight();
+              this.createOrRemoveDummyRows();
+          }, 0);
         ]]></body>
       </method>
 
       <method name="calcContentHeight">
         <body><![CDATA[
           let listbox =
               document.getAnonymousElementByAttribute(
                   this, "anonid", "listbox");
--- a/calendar/base/content/dialogs/calendar-event-dialog-recurrence-preview.xml
+++ b/calendar/base/content/dialogs/calendar-event-dialog-recurrence-preview.xml
@@ -32,20 +32,17 @@
 
     <implementation>
 
       <field name="mRecurrenceInfo">null</field>
       <field name="mResizeHandler">null</field>
       <field name="mDateTime">null</field>
 
       <constructor><![CDATA[
-        let self = this;
-        this.mResizeHandler = function recurrence_preview_resizeHandler() {
-            self.onResize();
-        };
+        this.mResizeHandler = this.onResize.bind(this);
         window.addEventListener("resize", this.mResizeHandler, true);
       ]]></constructor>
 
       <destructor><![CDATA[
         window.removeEventListener("resize", this.mResizeHandler, true);
       ]]></destructor>
 
       <property name="dateTime">
--- a/calendar/base/content/dialogs/calendar-invitations-dialog.js
+++ b/calendar/base/content/dialogs/calendar-invitations-dialog.js
@@ -10,38 +10,29 @@ Components.utils.import("resource://gre/
 
 /**
  * Sets up the invitations dialog from the window arguments, retrieves the
  * invitations from the invitations manager.
  */
 function onLoad() {
     let operationListener = {
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-        onOperationComplete: function oL_onOperationComplete(aCalendar,
-                                                             aStatus,
-                                                             aOperationType,
-                                                             aId,
-                                                             aDetail) {
+        onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDetail) {
             let updatingBox = document.getElementById("updating-box");
             updatingBox.setAttribute("hidden", "true");
             let richListBox = document.getElementById("invitations-listbox");
             if (richListBox.getRowCount() > 0) {
                 richListBox.selectedIndex = 0;
             } else {
                 let noInvitationsBox =
                     document.getElementById("noinvitations-box");
                 noInvitationsBox.removeAttribute("hidden");
             }
         },
-        onGetResult: function oL_onGetResult(aCalendar,
-                                             aStatus,
-                                             aItemType,
-                                             aDetail,
-                                             aCount,
-                                             aItems) {
+        onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
             if (!Components.isSuccessCode(aStatus)) {
                 return;
             }
             document.title = invitationsText + " (" + aCount + ")";
             let updatingBox = document.getElementById("updating-box");
             updatingBox.setAttribute("hidden", "true");
             let richListBox = document.getElementById("invitations-listbox");
             for (let item of aItems) {
--- a/calendar/base/content/dialogs/calendar-print-dialog.js
+++ b/calendar/base/content/dialogs/calendar-print-dialog.js
@@ -134,22 +134,20 @@ function getPrintSettings(receiverFunc) 
         dump("Error : no case in printDialog.js::printCalendar()");
     }
 
     // Some filters above might have filled the events list themselves. If not,
     // then fetch the items here.
     if (requiresFetch) {
         let listener = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-            onOperationComplete:
-            function onOperationComplete(aCalendar, aStatus, aOperationType, aId, aDateTime) {
+            onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDateTime) {
                 receiverFunc(settings);
             },
-            onGetResult:
-            function onGetResult(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
+            onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
                 settings.eventList = settings.eventList.concat(aItems);
                 if (!settings.printTasksWithNoDueDate) {
                     eventWithDueDate = [];
                     for (let item of settings.eventList) {
                         if (item.dueDate || item.endDate) {
                             eventWithDueDate.push(item);
                         }
                     }
@@ -194,17 +192,17 @@ function getFilter(settings) {
 }
 
 /**
  * Looks at the selections the user has made (start date, layout, etc.), and
  * updates the HTML in the iframe accordingly. This is also called when a
  * dialog UI element has changed, since we'll want to refresh the preview.
  */
 function refreshHtml(finishFunc) {
-    getPrintSettings(function getSettingsResponse(settings) {
+    getPrintSettings((settings) => {
             document.title = calGetString("calendar", "PrintPreviewWindowTitle", [settings.title]);
 
             let printformatter = Components.classes[settings.layoutCId]
                                            .createInstance(Components.interfaces.calIPrintFormatter);
             let html = "";
             try {
                 let pipe = Components.classes["@mozilla.org/pipe;1"]
                                      .createInstance(Components.interfaces.nsIPipe);
@@ -245,61 +243,60 @@ function refreshHtml(finishFunc) {
     );
 }
 
 /**
  * This is a nsIWebProgressListener that closes the dialog on completion, makes
  * sure printing works without issues
  */
 var closeOnComplete = {
-    onStateChange: function onStateChange(aProgress, aRequest, aStateFlags, aStatus) {
+    onStateChange: function(aProgress, aRequest, aStateFlags, aStatus) {
         if (aStateFlags & Components.interfaces.nsIWebProgressListener.STATE_STOP) {
             // The request is complete, close the window.
             document.documentElement.cancelDialog();
         }
     },
 
     onProgressChange: function() {},
     onLocationChange: function() {},
     onStatusChange: function() {},
     onSecurityChange: function() {}
 };
 
 /**
  * Prints the document and then closes the window
  */
 function printAndClose() {
-    refreshHtml(
-        function finish() {
-            let webBrowserPrint = PrintUtils.getWebBrowserPrint();
-            let printSettings = PrintUtils.getPrintSettings();
+    refreshHtml(() => {
+        let webBrowserPrint = PrintUtils.getWebBrowserPrint();
+        let printSettings = PrintUtils.getPrintSettings();
 
-            // Evicts "about:blank" header
-            printSettings.docURL = " ";
+        // Evicts "about:blank" header
+        printSettings.docURL = " ";
 
-            // Start the printing, this is just what PrintUtils does, but we
-            // apply our own settings.
-            try {
-                webBrowserPrint.print(printSettings, closeOnComplete);
-                if (gPrintSettingsAreGlobal && gSavePrintSettings) {
-                    let PSSVC = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
-                                          .getService(Components.interfaces.nsIPrintSettingsService);
-                    PSSVC.savePrintSettingsToPrefs(printSettings, true,
-                                                        printSettings.kInitSaveAll);
-                    PSSVC.savePrintSettingsToPrefs(printSettings, false,
-                                                   printSettings.kInitSavePrinterName);
-                }
-            } catch (e) {
-                // Pressing cancel is expressed as an NS_ERROR_ABORT return value,
-                // causing an exception to be thrown which we catch here.
-                if (e.result != Components.results.NS_ERROR_ABORT) {
-                    throw e;
-                }
+        // Start the printing, this is just what PrintUtils does, but we
+        // apply our own settings.
+        try {
+            webBrowserPrint.print(printSettings, closeOnComplete);
+            if (gPrintSettingsAreGlobal && gSavePrintSettings) {
+                let PSSVC = Components.classes["@mozilla.org/gfx/printsettings-service;1"]
+                                      .getService(Components.interfaces.nsIPrintSettingsService);
+                PSSVC.savePrintSettingsToPrefs(printSettings, true,
+                                                    printSettings.kInitSaveAll);
+                PSSVC.savePrintSettingsToPrefs(printSettings, false,
+                                               printSettings.kInitSavePrinterName);
             }
-        });
+        } catch (e) {
+            // Pressing cancel is expressed as an NS_ERROR_ABORT return value,
+            // causing an exception to be thrown which we catch here.
+            if (e.result != Components.results.NS_ERROR_ABORT) {
+                throw e;
+            }
+        }
+    });
     return false; // leave open
 }
 
 /**
  * Called when once a date has been selected in the datepicker.
  */
 function onDatePick() {
     calRadioGroupSelectItem("view-field", "custom-range");
--- a/calendar/base/content/dialogs/calendar-subscriptions-dialog.js
+++ b/calendar/base/content/dialogs/calendar-subscriptions-dialog.js
@@ -101,17 +101,17 @@ function onSearch() {
     richListBox.clear();
 
     let registeredCals = {};
     for (let calendar of getCalendarManager().getCalendars({})) {
         registeredCals[calendar.id] = true;
     }
 
     let opListener = {
-        onResult: function search_onResult(op, result) {
+        onResult: function(op, result) {
             if (result) {
                 for (let calendar of result) {
                     richListBox.addCalendar(calendar, registeredCals[calendar.id]);
                 }
             }
             if (!op.isPending) {
                 let statusDeck = document.getElementById("status-deck");
                 if (richListBox.getRowCount() > 0) {
--- a/calendar/base/content/dialogs/calendar-summary-dialog.js
+++ b/calendar/base/content/dialogs/calendar-summary-dialog.js
@@ -23,23 +23,20 @@ function onLoad() {
 
     // the calling entity provides us with an object that is responsible
     // for recording details about the initiated modification. the 'finalize'-property
     // is our hook in order to receive a notification in case the operation needs
     // to be terminated prematurely. this function will be called if the calling
     // entity needs to immediately terminate the pending modification. in this
     // case we serialize the item and close the window.
     if (args.job) {
-        // keep this context...
-        let self = this;
-
         // store the 'finalize'-functor in the provided job-object.
-        args.job.finalize = function finalize() {
+        args.job.finalize = () => {
             // store any pending modifications...
-            self.onAccept();
+            this.onAccept();
 
             let calendarItem = window.calendarItem;
 
             // ...and close the window.
             window.close();
 
             return calendarItem;
         };
--- a/calendar/base/content/import-export.js
+++ b/calendar/base/content/import-export.js
@@ -107,17 +107,17 @@ function loadEventsFromFile(aCalendar) {
             return;
         } else if (calendars.length == 1) {
             // There's only one calendar, so it's silly to ask what calendar
             // the user wants to import into.
             putItemsIntoCal(calendars[0], items, filePath);
         } else {
             // Ask what calendar to import into
             let args = {};
-            args.onOk = function putItems(aCal) { putItemsIntoCal(aCal, items, filePath); };
+            args.onOk = (aCal) => { putItemsIntoCal(aCal, items, filePath); };
             args.calendars = calendars;
             args.promptText = calGetString("calendar", "importPrompt");
             openDialog("chrome://calendar/content/chooseCalendarDialog.xul",
                        "_blank", "chrome,titlebar,modal,resizable", args);
         }
     }
 }
 
--- a/calendar/base/content/preferences/alarms.js
+++ b/calendar/base/content/preferences/alarms.js
@@ -10,74 +10,74 @@ Components.utils.import("resource://gre/
 /**
  * Global Object to hold methods for the alarms pref pane
  */
 var gAlarmsPane = {
     /**
      * Initialize the alarms pref pane. Sets up dialog controls to match the
      * values set in prefs.
      */
-    init: function gAP_init() {
+    init: function() {
         // Enable/disable the alarm sound URL box and buttons
         this.alarmsPlaySoundPrefChanged();
 
         // Set the correct singular/plural for the time units
         updateMenuLabelsPlural("eventdefalarmlen", "eventdefalarmunit");
         updateMenuLabelsPlural("tododefalarmlen", "tododefalarmunit");
         updateUnitLabelPlural("defaultsnoozelength", "defaultsnoozelengthunit", "minutes");
     },
 
     /**
      * Converts the given file url to a nsILocalFile
      *
      * @param aFileURL    A string with a file:// url.
      * @return            The corresponding nsILocalFile.
      */
-    convertURLToLocalFile: function gAP_convertURLToLocalFile(aFileURL) {
+    convertURLToLocalFile: function(aFileURL) {
         // Convert the file url into a nsILocalFile
         if (aFileURL) {
             let fph = Services.io
                          .getProtocolHandler("file")
                          .QueryInterface(Components.interfaces.nsIFileProtocolHandler);
             return fph.getFileFromURLSpec(aFileURL);
         } else {
             return null;
         }
     },
 
     /**
      * Handler function to be called when the calendar.alarms.soundURL pref has
      * changed. Updates the label in the dialog.
      */
-    readSoundLocation: function gAP_readSoundLocation() {
+    readSoundLocation: function() {
         let soundUrl = document.getElementById("alarmSoundFileField");
         soundUrl.value = document.getElementById("calendar.alarms.soundURL").value;
         if (soundUrl.value.startsWith("file://")) {
             soundUrl.label = this.convertURLToLocalFile(soundUrl.value).leafName;
         } else {
             soundUrl.label = soundUrl.value;
         }
         soundUrl.image = "moz-icon://" + soundUrl.label + "?size=16";
         return undefined;
     },
 
     /**
      * Causes the default sound to be selected in the dialog controls
      */
-    useDefaultSound: function gAP_useDefaultSound() {
+    useDefaultSound: function() {
         let defaultSoundUrl = "chrome://calendar/content/sound.wav";
         document.getElementById("calendar.alarms.soundURL").value = defaultSoundUrl;
         document.getElementById("alarmSoundCheckbox").checked = true;
         this.readSoundLocation();
     },
 
     /**
      * Opens a filepicker to open a local sound for the alarm.
      */
-    browseAlarm: function gAP_browseAlarm() {
+    browseAlarm: function() {
         const nsIFilePicker = Components.interfaces.nsIFilePicker;
         let fp = Components.classes["@mozilla.org/filepicker;1"]
                     .createInstance(nsIFilePicker);
 
         let bundlePreferences = document.getElementById("bundleCalendarPreferences");
         let title = bundlePreferences.getString("Open");
         let wildmat = "*.wav";
         let label = bundlePreferences.getFormattedString("filterWav", [wildmat], 1);
@@ -93,17 +93,17 @@ var gAlarmsPane = {
             document.getElementById("alarmSoundCheckbox").checked = true;
             this.readSoundLocation();
         }
     },
 
     /**
      * Plays the alarm sound currently selected.
      */
-    previewAlarm: function gAP_previewAlarm() {
+    previewAlarm: function() {
         let soundUrl = document.getElementById("alarmSoundFileField").value;
         let soundIfc = Components.classes["@mozilla.org/sound;1"]
                             .createInstance(Components.interfaces.nsISound);
         let url;
         try {
             soundIfc.init();
             if (soundUrl && soundUrl.length && soundUrl.length > 0) {
                 url = Services.io.newURI(soundUrl, null, null);
@@ -116,17 +116,17 @@ var gAlarmsPane = {
         }
     },
 
     /**
      * Handler function to call when the calendar.alarms.playsound preference
      * has been changed. Updates the disabled state of fields that depend on
      * playing a sound.
      */
-    alarmsPlaySoundPrefChanged: function gAP_alarmsPlaySoundPrefChanged() {
+    alarmsPlaySoundPrefChanged: function() {
         let alarmsPlaySoundPref =
             document.getElementById("calendar.alarms.playsound");
 
         let items = [document.getElementById("alarmSoundFileField"),
                      document.getElementById("calendar.prefs.alarm.sound.useDefault"),
                      document.getElementById("calendar.prefs.alarm.sound.browse"),
                      document.getElementById("calendar.prefs.alarm.sound.play")];
 
--- a/calendar/base/content/preferences/categories.js
+++ b/calendar/base/content/preferences/categories.js
@@ -15,17 +15,17 @@ var categoryPrefBranch = Services.prefs.
  * Global Object to hold methods for the categories pref pane
  */
 var gCategoriesPane = {
 
     /**
      * Initialize the categories pref pane. Sets up dialog controls to show the
      * categories saved in preferences.
      */
-    init: function gCP_init() {
+    init: function() {
         // On non-instant-apply platforms, once this pane has been loaded,
         // attach our "revert all changes" function to the parent prefwindow's
         // "ondialogcancel" event.
         let parentPrefWindow = document.documentElement;
         if (!parentPrefWindow.instantApply) {
             let existingOnDialogCancel = parentPrefWindow.getAttribute("ondialogcancel");
             parentPrefWindow.setAttribute("ondialogcancel",
                                           "gCategoriesPane.panelOnCancel(); " +
@@ -58,23 +58,23 @@ var gCategoriesPane = {
         this.updateCategoryList();
     },
 
     /**
      * Updates the listbox containing the categories from the categories saved
      * in preferences.
      */
 
-    updatePrefs: function gCP_updatePrefs() {
+    updatePrefs: function() {
         cal.sortArrayByLocaleCollator(gCategoryList);
         document.getElementById("calendar.categories.names").value =
             categoriesArrayToString(gCategoryList);
     },
 
-    updateCategoryList: function gCP_updateCategoryList() {
+    updateCategoryList: function() {
         this.updatePrefs();
         let listbox = document.getElementById("categorieslist");
 
         listbox.clearSelection();
         this.updateButtons();
 
 
         while (listbox.lastChild.id != "categoryColumns") {
@@ -101,34 +101,34 @@ var gCategoriesPane = {
             listbox.appendChild(newListItem);
         }
     },
 
     /**
      * Adds a category, opening the edit category dialog to prompt the user to
      * set up the category.
      */
-    addCategory: function gCP_addCategory() {
+    addCategory: function() {
         let listbox = document.getElementById("categorieslist");
         listbox.clearSelection();
         this.updateButtons();
         window.openDialog("chrome://calendar/content/preferences/editCategory.xul",
                           "addCategory",
                           // Workaround for Bug 1151440 - the HTML color picker won't work
                           // in linux when opened from modal dialog
                           AppConstants.platform == "linux"
                               ? "centerscreen,chrome,resizable=no"
                               : "modal,centerscreen,chrome,resizable=no",
                           "", null, addTitle);
     },
 
     /**
      * Edits the currently selected category using the edit category dialog.
      */
-    editCategory: function gCP_editCategory() {
+    editCategory: function() {
         let list = document.getElementById("categorieslist");
         let categoryNameFix = formatStringForCSSRule(gCategoryList[list.selectedIndex]);
         let currentColor = null;
         try {
             currentColor = categoryPrefBranch.getCharPref(categoryNameFix);
         } catch (ex) {
             // If the pref doesn't exist, don't bail out here.
         }
@@ -143,17 +143,17 @@ var gCategoriesPane = {
                                   : "modal,centerscreen,chrome,resizable=no",
                               gCategoryList[list.selectedIndex], currentColor, editTitle);
         }
     },
 
     /**
      * Removes the selected category.
      */
-    deleteCategory: function gCP_deleteCategory() {
+    deleteCategory: function() {
         let list = document.getElementById("categorieslist");
         if (list.selectedCount < 1) {
             return;
         }
 
         let categoryNameFix = formatStringForCSSRule(gCategoryList[list.selectedIndex]);
         this.backupData(categoryNameFix);
         try {
@@ -183,17 +183,17 @@ var gCategoriesPane = {
     },
 
     /**
      * Saves the given category to the preferences.
      *
      * @param categoryName      The name of the category.
      * @param categoryColor     The color of the category
      */
-    saveCategory: function gCP_saveCateogry(categoryName, categoryColor) {
+    saveCategory: function(categoryName, categoryColor) {
         let list = document.getElementById("categorieslist");
         // Check to make sure another category doesn't have the same name
         let toBeDeleted = -1;
         for (let i = 0; i < gCategoryList.length; i++) {
             if (i == list.selectedIndex) {
                 continue;
             }
 
@@ -247,29 +247,29 @@ var gCategoriesPane = {
         let updatedCategory = gCategoryList.indexOf(categoryName);
         list.ensureIndexIsVisible(updatedCategory);
         list.selectedIndex = updatedCategory;
     },
 
     /**
      * Enable the edit and delete category buttons.
      */
-    updateButtons: function gCP_updateButtons() {
+    updateButtons: function() {
         let categoriesList = document.getElementById("categorieslist");
         document.getElementById("deleteCButton").disabled = (categoriesList.selectedCount <= 0);
         document.getElementById("editCButton").disabled = (categoriesList.selectedCount != 1);
     },
 
     /**
      * Backs up the category name in case the dialog is canceled.
      *
      * @see formatStringForCSSRule
      * @param categoryNameFix     The formatted category name.
      */
-    backupData: function gCP_backupData(categoryNameFix) {
+    backupData: function(categoryNameFix) {
         let currentColor;
         try {
             currentColor = categoryPrefBranch.getCharPref(categoryNameFix);
         } catch (ex) {
             dump("Exception caught in 'backupData': " + ex + "\n");
             currentColor = "##NEW";
         }
 
@@ -282,27 +282,27 @@ var gCategoriesPane = {
             { name: categoryNameFix, color: currentColor };
     },
 
     /**
      * Event Handler function to be called on doubleclick of the categories
      * list. If the edit function is enabled and the user doubleclicked on a
      * list item, then edit the selected category.
      */
-    listOnDblClick: function gCP_listOnDblClick(event) {
+    listOnDblClick: function(event) {
         if (event.target.localName == "listitem" &&
             !document.getElementById("editCButton").disabled) {
             this.editCategory();
         }
     },
 
     /**
      * Reverts category preferences in case the cancel button is pressed.
      */
-    panelOnCancel: function gCP_panelOnCancel() {
+    panelOnCancel: function() {
         for (let i = 0; i < parent.backupPrefList.length; i++) {
             if (parent.backupPrefList[i].color == "##NEW") {
                 try {
                    categoryPrefBranch.clearUserPref(parent.backupPrefList[i].name);
                 } catch (ex) {
                     dump("Exception caught in 'panelOnCancel': " + ex + "\n");
                 }
             } else {
--- a/calendar/base/content/preferences/general.js
+++ b/calendar/base/content/preferences/general.js
@@ -9,17 +9,17 @@ Components.utils.import("resource://cale
 /**
  * Global Object to hold methods for the general pref pane
  */
 var gCalendarGeneralPane = {
     /**
      * Initialize the general pref pane. Sets up dialog controls to match the
      * values set in prefs.
      */
-    init: function gCGP_init() {
+    init: function() {
         let df = Components.classes["@mozilla.org/calendar/datetime-formatter;1"]
                     .getService(Components.interfaces.calIDateTimeFormatter);
 
         let dateFormattedLong = df.formatDateLong(now());
         let dateFormattedShort = df.formatDateShort(now());
 
         // menu items include examples of current date formats.
         document.getElementById("dateformat-long-menuitem")
@@ -59,17 +59,17 @@ var gCalendarGeneralPane = {
             prefValue = calendarDefaultTimezone().tzid;
         }
         tzMenuList.value = prefValue;
 
         // Set the soondays menulist preference
         this.initializeTodaypaneMenu();
     },
 
-    updateDefaultTodoDates: function gCGP_updateDefaultTodoDates() {
+    updateDefaultTodoDates: function() {
         let defaultDue = document.getElementById("default_task_due").value;
         let defaultStart = document.getElementById("default_task_start").value;
         let offsetValues = ["offsetcurrent", "offsetnexthour"];
 
         document.getElementById("default_task_due_offset")
                 .style.visibility = offsetValues.includes(defaultDue) ? "" : "hidden";
         document.getElementById("default_task_start_offset")
                 .style.visibility = offsetValues.includes(defaultStart) ? "" : "hidden";
@@ -79,17 +79,17 @@ var gCalendarGeneralPane = {
     },
 
     updateItemtypeDeck: function() {
         let panelId = document.getElementById("defaults-itemtype-menulist").value;
         let panel = document.getElementById(panelId);
         document.getElementById("defaults-itemtype-deck").selectedPanel = panel;
     },
 
-    initializeTodaypaneMenu: function gCGP_initializeTodaypaneMenu() {
+    initializeTodaypaneMenu: function() {
         // Assign the labels for the menuitem
         let soondaysMenu = document.getElementById("soondays-menulist");
         let items = soondaysMenu.getElementsByTagName("menuitem");
         for (let menuItem of items) {
             let menuitemValue = Number(menuItem.value);
             if (menuitemValue > 7) {
                 menuItem.label = unitPluralForm(menuitemValue / 7, "weeks");
             } else {
@@ -110,13 +110,13 @@ var gCalendarGeneralPane = {
         } else {
             soonpref = soonpref > 28 ? 28 : 1;
             Preferences.set(prefName, soonpref, "INT");
         }
 
         document.getElementById("soondays-menulist").value = soonpref;
     },
 
-    updateTodaypaneMenu: function gCGP_updateTodaypaneMenu() {
+    updateTodaypaneMenu: function() {
         let soonpref = Number(document.getElementById("soondays-menulist").value);
         Preferences.set("calendar.agendaListbox.soondays", soonpref);
     }
 };
--- a/calendar/base/content/preferences/views.js
+++ b/calendar/base/content/preferences/views.js
@@ -7,28 +7,28 @@
 /**
  * Global Object to hold methods for the views pref pane
  */
 var gViewsPane = {
     /**
      * Initialize the views pref pane. Sets up dialog controls to match the
      * values set in prefs.
      */
-    init: function gVP_init() {
+    init: function() {
         this.updateViewEndMenu(document.getElementById("daystarthour").value);
         this.updateViewStartMenu(document.getElementById("dayendhour").value);
         this.updateViewWorkDayCheckboxes(document.getElementById("weekstarts").value);
         this.initializeViewStartEndMenus();
     },
 
     /**
      * Initialize the strings for the  "day starts at" and "day ends at"
      * menulists. This is needed to respect locales that use AM/PM.
      */
-    initializeViewStartEndMenus: function gVP_initializeViewStartEndMenus() {
+    initializeViewStartEndMenus: function() {
         let labelIdStart;
         let labelIdEnd;
         let timeFormatter = Components.classes["@mozilla.org/intl/scriptabledateformat;1"]
                                       .getService(Components.interfaces.nsIScriptableDateFormat);
         // 1 to 23 instead of 0 to 24 to keep midnight & noon as the localized strings
         for (let theHour = 1; theHour <= 23; theHour++) {
             let time = timeFormatter.FormatTime("", Components.interfaces.nsIScriptableDateFormat
                                     .timeFormatNoSeconds, theHour, 0, 0);
@@ -48,17 +48,17 @@ var gViewsPane = {
 
 
     /**
      * Updates the view end menu to only display hours after the selected view
      * start.
      *
      * @param aStartValue       The value selected for view start.
      */
-    updateViewEndMenu: function gVP_updateViewEndMenu(aStartValue) {
+    updateViewEndMenu: function(aStartValue) {
         let endMenuKids = document.getElementById("dayendhourpopup")
                                   .childNodes;
         for (let i = 0; i < endMenuKids.length; i++) {
             if (Number(endMenuKids[i].value) <= Number(aStartValue)) {
                 endMenuKids[i].setAttribute("hidden", true);
             } else {
                 endMenuKids[i].removeAttribute("hidden");
             }
@@ -66,17 +66,17 @@ var gViewsPane = {
     },
 
     /**
      * Updates the view start menu to only display hours before the selected view
      * end.
      *
      * @param aEndValue         The value selected for view end.
      */
-    updateViewStartMenu: function gVP_updateViewStartMenu(aEndValue) {
+    updateViewStartMenu: function(aEndValue) {
         let startMenuKids = document.getElementById("daystarthourpopup")
                                   .childNodes;
         for (let i = 0; i < startMenuKids.length; i++) {
             if (Number(startMenuKids[i].value) >= Number(aEndValue)) {
                 startMenuKids[i].setAttribute("hidden", true);
             } else {
                 startMenuKids[i].removeAttribute("hidden");
             }
@@ -84,16 +84,16 @@ var gViewsPane = {
     },
 
     /**
      * Update the workday checkboxes based on the start of the week.
      *
      * @Param weekStart         The (0-based) index of the weekday the week
      *                            should start at.
      */
-    updateViewWorkDayCheckboxes: function gVP_updateViewWorkDayCheckboxes(weekStart) {
+    updateViewWorkDayCheckboxes: function(weekStart) {
         weekStart = Number(weekStart);
         for (let i = weekStart; i < weekStart + 7; i++) {
             let checkbox = document.getElementById("dayoff" + (i % 7));
             checkbox.parentNode.appendChild(checkbox);
         }
     }
 };
--- a/calendar/base/content/today-pane.js
+++ b/calendar/base/content/today-pane.js
@@ -19,17 +19,17 @@ var TodayPane = {
         startY: 0,
         distance: 0,
         session: false
     },
 
     /**
      * Load Handler, sets up the today pane controls.
      */
-    onLoad: function onLoad() {
+    onLoad: function() {
         TodayPane.paneViews = [cal.calGetString("calendar", "eventsandtasks"),
                                cal.calGetString("calendar", "tasksonly"),
                                cal.calGetString("calendar", "eventsonly")];
         agendaListbox.setupCalendar();
         TodayPane.initializeMiniday();
         TodayPane.setShortWeekdays();
 
         document.getElementById("modeBroadcaster").addEventListener("DOMAttrModified", TodayPane.onModeModified, false);
@@ -38,26 +38,26 @@ var TodayPane = {
         document.getElementById("today-splitter").addEventListener("command", onCalendarViewResize, false);
         TodayPane.updateSplitterState();
         TodayPane.previousMode = document.getElementById("modeBroadcaster").getAttribute("mode");
     },
 
     /**
      * Unload handler, cleans up the today pane on window unload.
      */
-    onUnload: function onUnload() {
+    onUnload: function() {
         document.getElementById("modeBroadcaster").removeEventListener("DOMAttrModified", TodayPane.onModeModified, false);
         document.getElementById("today-splitter").removeEventListener("command", onCalendarViewResize, false);
     },
 
     /**
      * Sets up the label for the switcher that allows switching between today pane
      * views. (event+task, task only, event only)
      */
-    setTodayHeader: function setTodayHeader() {
+    setTodayHeader: function() {
         let currentMode = document.getElementById("modeBroadcaster").getAttribute("mode");
         let agendaIsVisible = document.getElementById("agenda-panel").isVisible(currentMode);
         let todoIsVisible = document.getElementById("todo-tab-panel").isVisible(currentMode);
         let index = 2;
         if (agendaIsVisible && todoIsVisible) {
             index = 0;
         } else if (!agendaIsVisible && todoIsVisible) {
             index = 1;
@@ -86,17 +86,17 @@ var TodayPane = {
         }
 
         onCalendarViewResize();
     },
 
     /**
      * Sets up the miniday display in the today pane.
      */
-    initializeMiniday: function initializeMiniday() {
+    initializeMiniday: function() {
         // initialize the label denoting the current month, year and calendarweek
         // with numbers that are supposed to consume the largest width
         // in order to guarantee that the text will not be cropped when modified
         // during runtime
         const kYEARINIT = "5555";
         const kCALWEEKINIT = "55";
         let monthdisplaydeck = document.getElementById("monthNameContainer");
         let childNodes = monthdisplaydeck.childNodes;
@@ -113,17 +113,17 @@ var TodayPane = {
 
         agendaListbox.addListener(this);
         this.setDay(now);
     },
 
     /**
      * Go to month/week/day views when double-clicking a label inside miniday
      */
-    onDoubleClick: function md_onDoubleClick(aEvent) {
+    onDoubleClick: function(aEvent) {
         if (aEvent.button == 0) {
             if (aEvent.target.id == "datevalue-label") {
                 switchCalendarView("day", true);
             } else if (aEvent.target.parentNode.id == "weekdayNameContainer") {
                 switchCalendarView("day", true);
             } else if (aEvent.target.id == "currentWeek-label") {
                 switchCalendarView("week", true);
             } else if (aEvent.target.parentNode.id == "monthNameContainer") {
@@ -137,17 +137,17 @@ var TodayPane = {
             currentView().goToDay(agendaListbox.today.start);
         }
     },
 
     /**
      * Set conditions about start dragging on day-label or start switching
      * with time on navigation buttons.
      */
-    onMousedown: function md_onMousedown(aEvent, aDir) {
+    onMousedown: function(aEvent, aDir) {
         if (aEvent.button != 0) {
             return;
         }
         let element = aEvent.target;
         if (element.id == "previous-day-button" ||
              element.id == "next-day-button") {
             // Start switching days by pressing, without release, the navigation buttons
             element.addEventListener("mouseout", TodayPane.stopSwitching, false);
@@ -163,17 +163,17 @@ var TodayPane = {
     },
 
     /**
      * Figure out the mouse distance from the center of the day's label
      * to the current position.
      *
      * NOTE: This function is usually called without the correct this pointer.
      */
-    onMousemove: function md_onMousemove(aEvent) {
+    onMousemove: function(aEvent) {
         const MIN_DRAG_DISTANCE_SQ = 49;
         let x = aEvent.clientX - TodayPane.minidayDrag.startX;
         let y = aEvent.clientY - TodayPane.minidayDrag.startY;
         if (TodayPane.minidayDrag.session) {
             if (x * x + y * y >= MIN_DRAG_DISTANCE_SQ) {
                 let distance = Math.floor(Math.sqrt(x * x + y * y) - Math.sqrt(MIN_DRAG_DISTANCE_SQ));
                 // Dragging on the left/right side, the day date decrease/increase
                 TodayPane.minidayDrag.distance = (x > 0) ? distance : -distance;
@@ -195,17 +195,17 @@ var TodayPane = {
             TodayPane.updateAdvanceTimer();
         }
     },
 
     /**
      * Figure out the days switching speed according to the position (when
      * dragging) or time elapsed (when pressing buttons).
      */
-    updateAdvanceTimer: function md_updateAdvanceTimer(aEvent, aDir) {
+    updateAdvanceTimer: function(aEvent, aDir) {
         const INITIAL_TIME = 400;
         const REL_DISTANCE = 8;
         const MINIMUM_TIME = 100;
         const ACCELERATE_COUNT_LIMIT = 7;
         const SECOND_STEP_TIME = 200;
         if (TodayPane.minidayDrag.session) {
             // Dragging the day label: days switch with cursor distance and time.
             let dir = (TodayPane.minidayDrag.distance > 0) - (TodayPane.minidayDrag.distance < 0);
@@ -230,17 +230,17 @@ var TodayPane = {
     },
 
     /**
      * Stop automatic days switching when releasing the mouse button or the
      * position is outside the window.
      *
      * NOTE: This function is usually called without the correct this pointer.
      */
-    stopSwitching: function stopSwitching(aEvent) {
+    stopSwitching: function(aEvent) {
         let element = aEvent.target;
         if (TodayPane.minidayDrag.session &&
             aEvent.type == "mouseout" &&
              element.id != "messengerWindow") {
             return;
         }
         if (TodayPane.minidayTimer) {
             clearTimeout(TodayPane.minidayTimer);
@@ -270,32 +270,32 @@ var TodayPane = {
      * Helper function to set the month description on the today pane header.
      *
      * @param aMonthLabel       The XUL node to set the month label on.
      * @param aIndex            The month number, 0-based.
      * @param aYear             The year this month should be displayed with
      * @param aCalWeek          The calendar week that should be shown.
      * @return                  The value set on aMonthLabel.
      */
-    setMonthDescription: function setMonthDescription(aMonthLabel, aIndex, aYear, aCalWeek) {
+    setMonthDescription: function(aMonthLabel, aIndex, aYear, aCalWeek) {
         if (this.cwlabel == null) {
             this.cwlabel = cal.calGetString("calendar", "shortcalendarweek");
         }
         document.getElementById("currentWeek-label").value = this.cwlabel + " " + aCalWeek;
         aMonthLabel.value = cal.getDateFormatter().shortMonthName(aIndex) + " " + aYear;
         return aMonthLabel.value;
     },
 
     /**
      * Cycle the view shown in the today pane (event+task, event, task).
      *
      * @param aCycleForward     If true, the views are cycled in the forward
      *                            direction, otherwise in the opposite direction
      */
-    cyclePaneView: function cyclePaneView(aCycleForward) {
+    cyclePaneView: function(aCycleForward) {
         if (this.paneViews == null) {
             return;
         }
         let index = parseInt(document.getElementById("today-pane-header").getAttribute("index"), 10);
         index = index + aCycleForward;
         let nViewLen = this.paneViews.length;
         if (index >= nViewLen) {
             index = 0;
@@ -310,17 +310,17 @@ var TodayPane = {
         todoPanel.setVisible(isTodoPanelVisible);
         agendaPanel.setVisible(isAgendaPanelVisible);
         this.setTodayHeader();
     },
 
     /**
      * Shows short weekday names in the weekdayNameContainer
      */
-    setShortWeekdays: function setShortWeekdays() {
+    setShortWeekdays: function() {
         let weekdisplaydeck = document.getElementById("weekdayNameContainer");
         let childNodes = weekdisplaydeck.childNodes;
 
         // Workaround for bug 1070491. Show the correct weekday after
         // startup even if deck's selectedIndex is reset to 0.
         let weekday = cal.now().weekday + 1;
         childNodes[0].setAttribute("value", cal.calGetString("dateFormat", "day." + weekday + ".Mmm"));
 
@@ -329,30 +329,30 @@ var TodayPane = {
         }
     },
 
     /**
      * Sets the shown date from a JSDate.
      *
      * @param aNewDate      The date to show.
      */
-    setDaywithjsDate: function setDaywithjsDate(aNewDate) {
+    setDaywithjsDate: function(aNewDate) {
         let newdatetime = cal.jsDateToDateTime(aNewDate, cal.floating());
         newdatetime = newdatetime.getInTimezone(cal.calendarDefaultTimezone());
         this.setDay(newdatetime, true);
     },
 
     /**
      * Sets the first day shown in the today pane.
      *
      * @param aNewDate                  The calIDateTime to set.
      * @param aDontUpdateMinimonth      If true, the minimonth will not be
      *                                    updated to show the same date.
      */
-    setDay: function setDay(aNewDate, aDontUpdateMinimonth) {
+    setDay: function(aNewDate, aDontUpdateMinimonth) {
         this.start = aNewDate.clone();
 
         let daylabel = document.getElementById("datevalue-label");
         daylabel.value = this.start.day;
 
         let weekdaylabel = document.getElementById("weekdayNameContainer");
         weekdaylabel.selectedIndex = this.start.weekday + 1;
 
@@ -371,58 +371,58 @@ var TodayPane = {
     },
 
     /**
      * Advance by a given number of days in the today pane.
      *
      * @param aDir      The number of days to advance. Negative numbers advance
      *                    backwards in time.
      */
-    advance: function advance(aDir) {
+    advance: function(aDir) {
         if (aDir != 0) {
             this.start.day += aDir;
             this.setDay(this.start);
         }
     },
 
     /**
      * Checks if the today pane is showing today's date.
      */
-    showsToday: function showsToday() {
+    showsToday: function() {
         return cal.sameDay(cal.now(), this.start);
     },
 
     /**
      * Update the period headers in the agenda listbox using the today pane's
      * start date.
      */
-    updatePeriod: function updatePeriod() {
+    updatePeriod: function() {
         agendaListbox.refreshPeriodDates(this.start.clone());
         updateCalendarToDoUnifinder();
     },
 
     /**
      * Display a certain section in the minday/minimonth part of the todaypane.
      *
      * @param aSection      The section to display
      */
-    displayMiniSection: function displayMiniSection(aSection) {
+    displayMiniSection: function(aSection) {
         document.getElementById("today-minimonth-box").setVisible(aSection == "minimonth");
         document.getElementById("mini-day-box").setVisible(aSection == "miniday");
         document.getElementById("today-none-box").setVisible(aSection == "none");
         setBooleanAttribute(document.getElementById("today-Minimonth"), "freebusy", aSection == "minimonth");
     },
 
     /**
      * Handler function for the DOMAttrModified event used to observe the
      * todaypane-splitter.
      *
      * @param aEvent        The DOM event occurring on attribute modification.
      */
-    onModeModified: function onModeModified(aEvent) {
+    onModeModified: function(aEvent) {
         if (aEvent.attrName == "mode") {
             let todaypane = document.getElementById("today-pane-panel");
             // Store the previous mode panel's width.
             todaypane.setModeAttribute("modewidths", todaypane.width, TodayPane.previousMode);
 
             TodayPane.setTodayHeader();
             TodayPane.updateSplitterState();
             todaypane.width = todaypane.getModeAttribute("modewidths", "width");
@@ -430,40 +430,40 @@ var TodayPane = {
         }
     },
 
     /**
      * Toggle the today-pane and update its visual appearance.
      *
      * @param aEvent        The DOM event occurring on activated command.
      */
-    toggleVisibility: function toggleVisbility(aEvent) {
+    toggleVisibility: function(aEvent) {
         document.getElementById("today-pane-panel").togglePane(aEvent);
         TodayPane.setTodayHeader();
         TodayPane.updateSplitterState();
     },
 
     /**
      * Update the today-splitter state and today-pane width with saved
      * mode-dependent values.
      */
-    updateSplitterState: function updateSplitterState() {
+    updateSplitterState: function() {
         let splitter = document.getElementById("today-splitter");
         let todaypaneVisible = document.getElementById("today-pane-panel").isVisible();
         setElementValue(splitter, !todaypaneVisible && "true", "hidden");
         if (todaypaneVisible) {
             splitter.setAttribute("state", "open");
         }
     },
 
     /**
      * Generates the todaypane toggle command when the today-splitter
      * is being collapsed or uncollapsed.
      */
-    onCommandTodaySplitter: function onCommandTodaySplitter() {
+    onCommandTodaySplitter: function() {
         let todaypane = document.getElementById("today-pane-panel");
         let splitterState = document.getElementById("today-splitter").getAttribute("state");
         if (splitterState == "collapsed" && todaypane.isVisible() ||
             splitterState != "collapsed" && !todaypane.isVisible()) {
               document.getElementById("calendar_toggle_todaypane_command").doCommand();
         }
     }
 };
--- a/calendar/base/content/widgets/calendar-list-tree.xml
+++ b/calendar/base/content/widgets/calendar-list-tree.xml
@@ -65,91 +65,87 @@
       </property>
 
       <field name="calMgrObserver"><![CDATA[
       ({
         listTree: this,
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calICalendarManagerObserver]),
 
         // calICalendarManagerObserver
-        onCalendarRegistered: function cMO_onCalendarRegistered(aCalendar) {
+        onCalendarRegistered: function(aCalendar) {
             this.listTree.addCalendar(aCalendar);
             let composite = this.listTree.compositeCalendar;
             let inComposite = aCalendar.getProperty(composite.prefPrefix +
                                                     "-in-composite");
             if ((inComposite === null) || inComposite) {
                 composite.addCalendar(aCalendar);
             }
         },
 
-        onCalendarUnregistering: function cMO_onCalendarUnregistering(aCalendar) {
+        onCalendarUnregistering: function(aCalendar) {
             this.listTree.removeCalendar(aCalendar);
         },
 
-        onCalendarDeleting: function cMO_onCalendarDeleting(aCalendar) {
+        onCalendarDeleting: function(aCalendar) {
             // Now that the calendar is unregistered, update the commands to
             // make sure that New Event/Task commands are correctly
             // enabled/disabled.
             document.commandDispatcher.updateCommands("calendar_commands");
         }
       })
       ]]></field>
       <field name="compositeObserver"><![CDATA[
       ({
         listTree: this,
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calICompositeObserver,
                                                Components.interfaces.calIObserver]),
 
         // calICompositeObserver
-        onCalendarAdded: function onCalendarAdded(aCalendar) {
+        onCalendarAdded: function(aCalendar) {
             // Make sure the checkbox state is updated
             this.listTree.updateCalendar(aCalendar);
         },
 
-        onCalendarRemoved: function onCalendarRemoved(aCalendar) {
+        onCalendarRemoved: function(aCalendar) {
             // Make sure the checkbox state is updated
             this.listTree.updateCalendar(aCalendar);
         },
 
-        onDefaultCalendarChanged: function cMO_onDefaultCalendarChanged(aCalendar) {
+        onDefaultCalendarChanged: function(aCalendar) {
         },
 
         // calIObserver
-        onStartBatch: function cO_onStartBatch() { },
-        onEndBatch: function cO_onEndBatch() { },
-        onLoad: function cO_onLoad() { },
+        onStartBatch: function() { },
+        onEndBatch: function() { },
+        onLoad: function() { },
 
-        onAddItem: function cO_onAddItem(aItem) {
+        onAddItem: function(aItem) {
             if (aItem.calendar.type != "caldav") {
                 this.listTree.ensureCalendarVisible(aItem.calendar);
             }
         },
-        onModifyItem: function cO_onModifyItem(aNewItem, aOldItem) {
+        onModifyItem: function(aNewItem, aOldItem) {
             if (aNewItem.calendar.type != "caldav") {
                 this.listTree.ensureCalendarVisible(aNewItem.calendar);
             }
         },
-        onDeleteItem: function cO_onDeleteItem(aDeletedItem) { },
-        onError: function cO_onError(aCalendar, aErrNo, aMessage) { },
+        onDeleteItem: function(aDeletedItem) { },
+        onError: function(aCalendar, aErrNo, aMessage) { },
 
-        onPropertyChanged: function cO_onPropertyChanged(aCalendar,
-                                                         aName,
-                                                         aValue,
-                                                         aOldValue) {
+        onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {
             switch (aName) {
                 case "disabled":
                 case "readOnly":
                     calendarUpdateNewItemsCommand();
                     document.commandDispatcher.updateCommands("calendar_commands");
                     break;
             }
         },
 
-        onPropertyDeleting: function cO_onPropertyDeleting(aCalendar,
-                                                            aName) {
+        onPropertyDeleting: function(aCalendar, aName) {
         }
       })
       ]]></field>
     </implementation>
     <handlers>
       <handler event="dblclick"><![CDATA[
         let col = {};
         let calendar = this.getCalendarFromEvent(event, col);
@@ -253,29 +249,26 @@
       ]]></destructor>
 
       <field name="calObserver"><![CDATA[
       ({
         listTree: this,
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIObserver]),
 
         // calIObserver. Note that each registered calendar uses this observer
-        onStartBatch: function cMO_onStartBatch() { },
-        onEndBatch: function cMO_onEndBatch() { },
-        onLoad: function cMO_onLoad() { },
+        onStartBatch: function() { },
+        onEndBatch: function() { },
+        onLoad: function() { },
 
-        onAddItem: function cMO_onAddItem(aItem) { },
-        onModifyItem: function cMO_onModifyItem(aNewItem, aOldItem) { },
-        onDeleteItem: function cMO_onDeleteItem(aDeletedItem) { },
-        onError: function cMO_onError(aCalendar, aErrNo, aMessage) { },
+        onAddItem: function(aItem) { },
+        onModifyItem: function(aNewItem, aOldItem) { },
+        onDeleteItem: function(aDeletedItem) { },
+        onError: function(aCalendar, aErrNo, aMessage) { },
 
-        onPropertyChanged: function cMO_onPropertyChanged(aCalendar,
-                                                          aName,
-                                                          aValue,
-                                                          aOldValue) {
+        onPropertyChanged: function(aCalendar, aName, aValue, aOldValue) {
             switch (aName) {
                 case "color":
                     // TODO See other TODO in this file about updateStyleSheetForViews
                     if ("updateStyleSheetForViews" in window) {
                         updateStyleSheetForViews(aCalendar);
                     }
                     this.listTree.updateCalendarColor(aCalendar);
                     // Fall through, update item in any case
@@ -283,43 +276,42 @@
                 case "currentStatus":
                 case "readOnly":
                 case "disabled":
                     this.listTree.updateCalendar(aCalendar);
                     // Fall through, update commands in any cases.
             }
         },
 
-        onPropertyDeleting: function cMO_onPropertyDeleting(aCalendar,
-                                                            aName) {
+        onPropertyDeleting: function(aCalendar, aName) {
             // Since the old value is not used directly in onPropertyChanged,
             // but should not be the same as the value, set it to a different
             // value.
             this.onPropertyChanged(aCalendar, aName, null, null);
         }
       })
       ]]></field>
 
       <field name="compositeObserver"><![CDATA[
       ({
         listTree: this,
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calICompositeObserver]),
 
         // calICompositeObserver
-        onCalendarAdded: function onCalendarAdded(aCalendar) {
+        onCalendarAdded: function(aCalendar) {
             // Make sure the checkbox state is updated
             this.listTree.updateCalendar(aCalendar);
         },
 
-        onCalendarRemoved: function onCalendarRemoved(aCalendar) {
+        onCalendarRemoved: function(aCalendar) {
             // Make sure the checkbox state is updated
             this.listTree.updateCalendar(aCalendar);
         },
 
-        onDefaultCalendarChanged: function cMO_onDefaultCalendarChanged(aCalendar) {
+        onDefaultCalendarChanged: function(aCalendar) {
         }
       })
       ]]></field>
 
       <property name="treechildren"
                 readonly="true"
                 onget="return document.getAnonymousElementByAttribute(this, 'anonid', 'treechildren')"/>
       <property name="tree"
--- a/calendar/base/modules/calAlarmUtils.jsm
+++ b/calendar/base/modules/calAlarmUtils.jsm
@@ -9,17 +9,17 @@ this.EXPORTED_SYMBOLS = ["cal"]; // even
 cal.alarms = {
     /**
      * Read default alarm settings from user preferences and apply them to the
      * event/todo passed in. The item's calendar should be set to ensure the
      * correct alarm type is set.
      *
      * @param aItem     The item to apply the default alarm values to.
      */
-    setDefaultValues: function cal_alarm_setDefaultValues(aItem) {
+    setDefaultValues: function(aItem) {
         let type = cal.isEvent(aItem) ? "event" : "todo";
         if (Preferences.get("calendar.alarms.onfor" + type + "s", 0) == 1) {
             let alarmOffset = cal.createDuration();
             let alarm = cal.createAlarm();
             let units = Preferences.get("calendar.alarms." + type + "alarmunit", "minutes");
 
             // Make sure the alarm pref is valid, default to minutes otherwise
             if (!["weeks", "days", "hours", "minutes", "seconds"].includes(units)) {
@@ -49,17 +49,17 @@ cal.alarms = {
 
     /**
      * Calculate the alarm date for a calIAlarm.
      *
      * @param aItem     The item used to calculate the alarm date.
      * @param aAlarm    The alarm to calculate the date for.
      * @return          The alarm date.
      */
-    calculateAlarmDate: function cal_alarm_calculateAlarmDate(aItem, aAlarm) {
+    calculateAlarmDate: function(aItem, aAlarm) {
         if (aAlarm.related == aAlarm.ALARM_RELATED_ABSOLUTE) {
             return aAlarm.alarmDate;
         } else {
             let returnDate;
             if (aAlarm.related == aAlarm.ALARM_RELATED_START) {
                 returnDate = aItem[cal.calGetStartDateProp(aItem)];
             } else if (aAlarm.related == aAlarm.ALARM_RELATED_END) {
                 returnDate = aItem[cal.calGetEndDateProp(aItem)];
@@ -92,17 +92,17 @@ cal.alarms = {
      * parameter.
      *
      * @param aItem     The item to calculate the offset for.
      * @param aAlarm    The alarm to calculate the offset for.
      * @param aRelated  (optional) A relation constant from calIAlarm. If not
      *                    passed, ALARM_RELATED_START will be assumed.
      * @return          The alarm offset.
      */
-    calculateAlarmOffset: function cal_alarms_calculateAlarmOffset(aItem, aAlarm, aRelated) {
+    calculateAlarmOffset: function(aItem, aAlarm, aRelated) {
         let offset = aAlarm.offset;
         if (aAlarm.related == aAlarm.ALARM_RELATED_ABSOLUTE) {
             let returnDate;
             if (aRelated === undefined || aRelated == aAlarm.ALARM_RELATED_START) {
                 returnDate = aItem[cal.calGetStartDateProp(aItem)];
             } else if (aRelated == aAlarm.ALARM_RELATED_END) {
                 returnDate = aItem[cal.calGetEndDateProp(aItem)];
             }
@@ -116,17 +116,17 @@ cal.alarms = {
 
     /**
      * Adds reminder images to a given node, making sure only one icon per alarm
      * action is added.
      *
      * @param aElement    The element to add the images to.
      * @param aReminders  The set of reminders to add images for.
      */
-    addReminderImages: function cal_alarms_addReminderImages(aElement, aReminders) {
+    addReminderImages: function(aElement, aReminders) {
         function createOwnedXULNode(el) {
             const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
             return aElement.ownerDocument.createElementNS(XUL_NS, el);
         }
 
         function setupActionImage(node, reminder) {
             let image = node || createOwnedXULNode("image");
             image.setAttribute("class", "reminder-icon");
--- a/calendar/base/modules/calAuthUtils.jsm
+++ b/calendar/base/modules/calAuthUtils.jsm
@@ -10,39 +10,35 @@ Components.utils.import("resource://gre/
  * Authentication helper code
  */
 
 this.EXPORTED_SYMBOLS = ["cal"]; // even though it's defined in calUtils.jsm, import needs this
 cal.auth = {
     /**
      * Auth prompt implementation - Uses password manager if at all possible.
      */
-    Prompt: function calPrompt() {
+    Prompt: function() {
         this.mWindow = cal.getCalendarWindow();
         this.mReturnedLogins = {};
     },
 
     /**
      * Tries to get the username/password combination of a specific calendar name
      * from the password manager or asks the user.
      *
      * @param   in aTitle           The dialog title.
      * @param   in aCalendarName    The calendar name or url to look up. Can be null.
      * @param   inout aUsername     The username that belongs to the calendar.
      * @param   inout aPassword     The password that belongs to the calendar.
      * @param   inout aSavePassword Should the password be saved?
      * @param   in aFixedUsername   Whether the user name is fixed or editable
      * @return  Could a password be retrieved?
      */
-    getCredentials: function calGetCredentials(aTitle,
-                                               aCalendarName,
-                                               aUsername,
-                                               aPassword,
-                                               aSavePassword,
-                                               aFixedUsername) {
+    getCredentials: function(aTitle, aCalendarName, aUsername, aPassword,
+                             aSavePassword, aFixedUsername) {
         if (typeof aUsername != "object" ||
             typeof aPassword != "object" ||
             typeof aSavePassword != "object") {
             throw new Components.Exception("", Components.results.NS_ERROR_XPC_NEED_OUT_OBJECT);
         }
 
         let prompter = Services.ww.getNewPrompter(null);
 
@@ -74,17 +70,17 @@ cal.auth = {
     /**
      * Helper to insert/update an entry to the password manager.
      *
      * @param aUserName     The username
      * @param aPassword     The corresponding password
      * @param aHostName     The corresponding hostname
      * @param aRealm        The password realm (unused on branch)
      */
-    passwordManagerSave: function calPasswordManagerSave(aUsername, aPassword, aHostName, aRealm) {
+    passwordManagerSave: function(aUsername, aPassword, aHostName, aRealm) {
         cal.ASSERT(aUsername);
         cal.ASSERT(aPassword);
 
         try {
             let logins = Services.logins.findLogins({}, aHostName, null, aRealm);
 
             let newLoginInfo = Components.classes["@mozilla.org/login-manager/loginInfo;1"]
                                          .createInstance(Components.interfaces.nsILoginInfo);
@@ -105,17 +101,17 @@ cal.auth = {
      * Helper to retrieve an entry from the password manager.
      *
      * @param in  aUsername     The username to search
      * @param out aPassword     The corresponding password
      * @param aHostName         The corresponding hostname
      * @param aRealm            The password realm (unused on branch)
      * @return                  Does an entry exist in the password manager
      */
-    passwordManagerGet: function calPasswordManagerGet(aUsername, aPassword, aHostName, aRealm) {
+    passwordManagerGet: function(aUsername, aPassword, aHostName, aRealm) {
         cal.ASSERT(aUsername);
 
         if (typeof aPassword != "object") {
             throw new Components.Exception("", Components.results.NS_ERROR_XPC_NEED_OUT_OBJECT);
         }
 
         try {
             if (!Services.logins.getLoginSavingEnabled(aUsername)) {
@@ -138,17 +134,17 @@ cal.auth = {
     /**
      * Helper to remove an entry from the password manager
      *
      * @param aUsername     The username to remove.
      * @param aHostName     The corresponding hostname
      * @param aRealm        The password realm (unused on branch)
      * @return              Could the user be removed?
      */
-    passwordManagerRemove: function calPasswordManagerRemove(aUsername, aHostName, aRealm) {
+    passwordManagerRemove: function(aUsername, aHostName, aRealm) {
         cal.ASSERT(aUsername);
 
         try {
             let logins = Services.logins.findLogins({}, aHostName, null, aRealm);
             for (let loginInfo of logins) {
                 if (loginInfo.username == aUsername) {
                     Services.logins.removeLogin(loginInfo);
                     return true;
@@ -169,17 +165,17 @@ cal.auth = {
  * This implementation guarantees there are no request loops when an invalid
  * password is stored in the login-manager.
  *
  * There is one instance of that object per calendar provider.
  */
 cal.auth.Prompt.prototype = {
     mProvider: null,
 
-    getPasswordInfo: function capGPI(aPasswordRealm) {
+    getPasswordInfo: function(aPasswordRealm) {
         let username;
         let password;
         let found = false;
 
         let logins = Services.logins.findLogins({}, aPasswordRealm.prePath, null, aPasswordRealm.realm);
         if (logins.length) {
             username = logins[0].username;
             password = logins[0].password;
@@ -228,17 +224,17 @@ cal.auth.Prompt.prototype = {
      *         object.
      * @retval false
      *         Authentication should be cancelled, usually because the user did
      *         not provide username/password.
      *
      * @note   Exceptions thrown from this function will be treated like a
      *         return value of false.
      */
-    promptAuth: function capPA(aChannel, aLevel, aAuthInfo) {
+    promptAuth: function(aChannel, aLevel, aAuthInfo) {
         let hostRealm = {};
         hostRealm.prePath = aChannel.URI.prePath;
         hostRealm.realm = aAuthInfo.realm;
         let port = aChannel.URI.port;
         if (port == -1) {
             let handler = Services.io.getProtocolHandler(aChannel.URI.scheme)
                                      .QueryInterface(Components.interfaces.nsIProtocolHandler);
             port = handler.defaultPort;
@@ -270,22 +266,21 @@ cal.auth.Prompt.prototype = {
      * Calling nsICancelable::cancel on the returned object SHOULD close the
      * dialog and MUST call nsIAuthPromptCallback::onAuthCancelled on the provided
      * callback.
      *
      * @throw NS_ERROR_NOT_IMPLEMENTED
      *        Asynchronous authentication prompts are not supported;
      *        the caller should fall back to promptUsernameAndPassword().
      */
-    asyncPromptAuth: function capAPA(aChannel,   // nsIChannel
-                                     aCallback,  // nsIAuthPromptCallback
-                                     aContext,   // nsISupports
-                                     aLevel,     // PRUint32
-                                     aAuthInfo   // nsIAuthInformation
-                                ) {
+    asyncPromptAuth: function(aChannel,     // nsIChannel
+                              aCallback,    // nsIAuthPromptCallback
+                              aContext,     // nsISupports
+                              aLevel,       // PRUint32
+                              aAuthInfo) {  // nsIAuthInformation
         let self = this;
         let promptlistener = {
             onPromptStart: function() {
                 res = self.promptAuth(aChannel, aLevel, aAuthInfo);
 
                 if (res) {
                     gAuthCache.setAuthInfo(hostKey, aAuthInfo);
                     this.onPromptAuthAvailable();
--- a/calendar/base/modules/calExtract.jsm
+++ b/calendar/base/modules/calExtract.jsm
@@ -53,17 +53,17 @@ function Extractor(fallbackLocale, daySt
     }
 }
 
 Extractor.prototype = {
     /**
     * Removes confusing data like urls, timezones and phone numbers from email
     * Also removes standard signatures and quoted content from previous emails
     */
-    cleanup: function cleanup() {
+    cleanup: function() {
         // XXX remove earlier correspondence
         // ideally this should be considered with lower certainty to fill in
         // missing information
 
         // remove last line preceeding quoted message and first line of the quote
         this.email = this.email.replace(/\r?\n[^>].*\r?\n>+.*$/m, "");
         // remove the rest of quoted content
         this.email = this.email.replace(/^>+.*$/gm, "");
@@ -78,46 +78,46 @@ Extractor.prototype = {
 
         // remove standard signature
         this.email = this.email.replace(/\r?\n-- \r?\n[\S\s]+$/, "");
 
         // XXX remove timezone info, for now
         this.email = this.email.replace(/gmt[+-]\d{2}:\d{2}/gi, "");
     },
 
-    checkBundle: function checkBundle(locale) {
+    checkBundle: function(locale) {
         let path = this.bundleUrl.replace(/LOCALE/g, locale);
         let bundle = Services.strings.createBundle(path);
 
         try {
             bundle.GetStringFromName("from.today");
             return true;
         } catch (ex) {
             return false;
         }
     },
 
-    avgNonAsciiCharCode: function avgNonAsciiCharCode() {
+    avgNonAsciiCharCode: function() {
         let sum = 0;
         let cnt = 0;
 
         for (let i = 0; i < this.email.length; i++) {
             let ch = this.email.charCodeAt(i);
             if (ch > 128) {
                 sum += ch;
                 cnt++;
             }
         }
 
         let nonAscii = sum / cnt || 0;
         cal.LOG("[calExtract] Average non-ascii charcode: " + nonAscii);
         return nonAscii;
     },
 
-    setLanguage: function setLanguage() {
+    setLanguage: function() {
         let path;
 
         if (this.fixedLang == true) {
             if (this.checkBundle(this.fallbackLocale)) {
                 cal.LOG("[calExtract] Fixed locale was used to choose " +
                         this.fallbackLocale + " patterns.");
             } else {
                 cal.LOG("[calExtract] " + this.fallbackLocale +
@@ -252,17 +252,17 @@ Extractor.prototype = {
     * @param body  email body
     * @param now   reference time against which relative times are interpreted,
     *                  when null current time is used
     * @param sel   selection object of email content, when defined times
     *                  outside selection are disgarded
     * @param title email title
     * @return      sorted list of extracted datetime objects
     */
-    extract: function extract(title, body, now, sel) {
+    extract: function(title, body, now, sel) {
         let initial = {};
         this.collected = [];
         this.email = title + "\r\n" + body;
         if (now != null) {
             this.now = now;
         }
 
         initial.year = now.getFullYear();
@@ -355,17 +355,17 @@ Extractor.prototype = {
             this.markSelected(sel, title);
         }
         this.markContained();
         this.collected = this.collected.sort(this.sort);
 
         return this.collected;
     },
 
-    extractDayMonthYear: function extractDayMonthYear(pattern, relation) {
+    extractDayMonthYear: function(pattern, relation) {
         let alts = this.getRepPatterns(pattern, ["(\\d{1,2})", "(\\d{1,2})",
                                                  "(\\d{2,4})"]);
         let res;
         for (let alt in alts) {
             let positions = alts[alt].positions;
             let re = new RegExp(alts[alt].pattern, "ig");
 
             while ((res = re.exec(this.email)) != null) {
@@ -380,17 +380,17 @@ Extractor.prototype = {
                         this.guess(year, month, day, null, null,
                                    rev.start, rev.end, rev.pattern, rev.relation, pattern);
                     }
                 }
             }
         }
     },
 
-    extractDayMonthNameYear: function extractDayMonthNameYear(pattern, relation) {
+    extractDayMonthNameYear: function(pattern, relation) {
         let alts = this.getRepPatterns(pattern, ["(\\d{1,2})",
                                                  "(" + this.allMonths + ")",
                                                  "(\\d{2,4})"]);
         let res;
         for (let alt in alts) {
             let exp = alts[alt].pattern.split(this.marker).join("|");
             let positions = alts[alt].positions;
             let re = new RegExp(exp, "ig");
@@ -411,31 +411,31 @@ Extractor.prototype = {
                             }
                         }
                     }
                 }
             }
         }
     },
 
-    extractRelativeDay: function extractRelativeDay(pattern, relation, offset) {
+    extractRelativeDay: function(pattern, relation, offset) {
         let re = new RegExp(this.getPatterns(pattern), "ig");
         let res;
         if ((res = re.exec(this.email)) != null) {
             if (!this.limitChars(res, this.email)) {
                 let item = new Date(this.now.getTime() + 60 * 60 * 24 * 1000 * offset);
                 let rev = this.prefixSuffixStartEnd(res, relation, this.email);
                 this.guess(item.getFullYear(), item.getMonth() + 1, item.getDate(),
                            null, null,
                            rev.start, rev.end, rev.pattern, rev.relation, pattern);
             }
         }
     },
 
-    extractDayMonthName: function extractDayMonthName(pattern, relation) {
+    extractDayMonthName: function(pattern, relation) {
         let alts = this.getRepPatterns(pattern,
                                        ["(\\d{1,2}" + this.marker + this.dailyNumbers + ")",
                                        "(" + this.allMonths + ")"]);
         let res;
         for (let alt in alts) {
             let exp = alts[alt].pattern.split(this.marker).join("|");
             let positions = alts[alt].positions;
             let re = new RegExp(exp, "ig");
@@ -470,17 +470,17 @@ Extractor.prototype = {
                             }
                         }
                     }
                 }
             }
         }
     },
 
-    extractDayMonth: function extractDayMonth(pattern, relation) {
+    extractDayMonth: function(pattern, relation) {
         let alts = this.getRepPatterns(pattern, ["(\\d{1,2})", "(\\d{1,2})"]);
         let res;
         for (let alt in alts) {
             let re = new RegExp(alts[alt].pattern, "ig");
             let positions = alts[alt].positions;
 
             while ((res = re.exec(this.email)) != null) {
                 if (!this.limitNums(res, this.email) && !this.limitChars(res, this.email)) {
@@ -507,17 +507,17 @@ Extractor.prototype = {
                         this.guess(date.year, date.month, date.day, null, null,
                                    rev.start, rev.end, rev.pattern, rev.relation, pattern);
                     }
                 }
             }
         }
     },
 
-    extractDate: function extractDate(pattern, relation) {
+    extractDate: function(pattern, relation) {
         let alts = this.getRepPatterns(pattern,
                                        ["(\\d{1,2}" + this.marker + this.dailyNumbers + ")"]);
         let res;
         for (let alt in alts) {
             let exp = alts[alt].pattern.split(this.marker).join("|");
             let re = new RegExp(exp, "ig");
 
             while ((res = re.exec(this.email)) != null) {
@@ -541,17 +541,17 @@ Extractor.prototype = {
                                    rev.start, rev.end,
                                    rev.pattern, rev.relation, pattern, true);
                     }
                 }
             }
         }
     },
 
-    extractWeekDay: function extractWeekDay(pattern, relation) {
+    extractWeekDay: function(pattern, relation) {
         let days = [];
         for (let i = 0; i < 7; i++) {
             days[i] = this.getPatterns(pattern + i);
             let re = new RegExp(days[i], "ig");
             let res = re.exec(this.email);
             if (res) {
                 if (!this.limitChars(res, this.email)) {
                     let date = new Date();
@@ -567,17 +567,17 @@ Extractor.prototype = {
                                null, null,
                                rev.start, rev.end,
                                rev.pattern, rev.relation, pattern + i, true);
                 }
             }
         }
     },
 
-    extractHour: function extractHour(pattern, relation, meridiem) {
+    extractHour: function(pattern, relation, meridiem) {
         let alts = this.getRepPatterns(pattern,
                                        ["(\\d{1,2}" + this.marker + this.hourlyNumbers + ")"]);
         let res;
         for (let alt in alts) {
             let exp = alts[alt].pattern.split(this.marker).join("|");
             let re = new RegExp(exp, "ig");
 
             while ((res = re.exec(this.email)) != null) {
@@ -597,17 +597,17 @@ Extractor.prototype = {
                         this.guess(null, null, null, hour, 0,
                                    rev.start, rev.end, rev.pattern, rev.relation, pattern, true);
                     }
                 }
             }
         }
     },
 
-    extractHalfHour: function extractHalfHour(pattern, relation, direction) {
+    extractHalfHour: function(pattern, relation, direction) {
         let alts = this.getRepPatterns(pattern,
                                        ["(\\d{1,2}" + this.marker + this.hourlyNumbers + ")"]);
         let res;
         for (let alt in alts) {
             let exp = alts[alt].pattern.split(this.marker).join("|");
             let re = new RegExp(exp, "ig");
 
             while ((res = re.exec(this.email)) != null) {
@@ -628,17 +628,17 @@ Extractor.prototype = {
                         this.guess(null, null, null, hour, 30,
                                    rev.start, rev.end, rev.pattern, rev.relation, pattern, true);
                     }
                 }
             }
         }
     },
 
-    extractHourMinutes: function extractHourMinutes(pattern, relation, meridiem) {
+    extractHourMinutes: function(pattern, relation, meridiem) {
         let alts = this.getRepPatterns(pattern, ["(\\d{1,2})", "(\\d{2})"]);
         let res;
         for (let alt in alts) {
             let positions = alts[alt].positions;
             let re = new RegExp(alts[alt].pattern, "ig");
 
             while ((res = re.exec(this.email)) != null) {
                 if (!this.limitNums(res, this.email) && !this.limitChars(res, this.email)) {
@@ -658,29 +658,29 @@ Extractor.prototype = {
                         this.guess(null, null, null, hour, minute,
                                    rev.start, rev.end, rev.pattern, rev.relation, pattern);
                     }
                 }
             }
         }
     },
 
-    extractTime: function extractTime(pattern, relation, hour, minute) {
+    extractTime: function(pattern, relation, hour, minute) {
         let re = new RegExp(this.getPatterns(pattern), "ig");
         let res;
         if ((res = re.exec(this.email)) != null) {
             if (!this.limitChars(res, this.email)) {
                 let rev = this.prefixSuffixStartEnd(res, relation, this.email);
                 this.guess(null, null, null, hour, minute,
                            rev.start, rev.end, rev.pattern, rev.relation, pattern);
             }
         }
     },
 
-    extractDuration: function extractDuration(pattern, unit) {
+    extractDuration: function(pattern, unit) {
         let alts = this.getRepPatterns(pattern,
                                        ["(\\d{1,2}" + this.marker + this.dailyNumbers + ")"]);
         let res;
         for (let alt in alts) {
             let exp = alts[alt].pattern.split(this.marker).join("|");
             let re = new RegExp(exp, "ig");
 
             while ((res = re.exec(this.email)) != null) {
@@ -695,17 +695,17 @@ Extractor.prototype = {
                     guess.relation = rev.relation;
                     guess.pattern = pattern;
                     this.collected.push(guess);
                 }
             }
         }
     },
 
-    markContained: function markContained() {
+    markContained: function() {
         for (let outer = 0; outer < this.collected.length; outer++) {
             for (let inner = 0; inner < this.collected.length; inner++) {
                 // included but not exactly the same
                 if (outer != inner &&
                     this.collected[outer].start && this.collected[outer].end &&
                     this.collected[inner].start && this.collected[inner].end &&
                     this.collected[inner].start >= this.collected[outer].start &&
                     this.collected[inner].end <= this.collected[outer].end &&
@@ -713,17 +713,17 @@ Extractor.prototype = {
                         this.collected[inner].end == this.collected[outer].end)) {
                         cal.LOG("[calExtract] " + this.collected[outer].str + " found as well, disgarding " + this.collected[inner].str);
                         this.collected[inner].relation = "notadatetime";
                 }
             }
         }
     },
 
-    markSelected: function markSelected(sel, title) {
+    markSelected: function(sel, title) {
         if (sel.rangeCount > 0) {
             // mark the ones to not use
             for (let i = 0; i < sel.rangeCount; i++) {
                 cal.LOG("[calExtract] Selection " + i + " is " + sel);
                 for (let j = 0; j < this.collected.length; j++) {
                     let selection = sel.getRangeAt(i).toString();
 
                     if (!selection.includes(this.collected[j].str) &&
@@ -732,17 +732,17 @@ Extractor.prototype = {
                         cal.LOG("[calExtract] Marking " + JSON.stringify(this.collected[j]) + " as notadatetime");
                         this.collected[j].relation = "notadatetime";
                     }
                 }
             }
         }
     },
 
-    sort: function sort(one, two) {
+    sort: function(one, two) {
         let rc;
         // sort the guess from email date as the last one
         if (one.start == null && two.start != null) {
             return 1;
         } else if (one.start != null && two.start == null) {
             return -1;
         } else if (one.start == null && two.start == null) {
             return 0;
@@ -776,17 +776,17 @@ Extractor.prototype = {
     },
 
     /**
     * Guesses start time from list of guessed datetimes
     *
     * @param isTask    whether start time should be guessed for task or event
     * @return          datetime object for start time
     */
-    guessStart: function guessStart(isTask) {
+    guessStart: function(isTask) {
         let startTimes = this.collected.filter(val => val.relation == "start");
         if (startTimes.length == 0) {
             return {};
         }
 
         for (let val in startTimes) {
             cal.LOG("[calExtract] Start: " + JSON.stringify(startTimes[val]));
         }
@@ -851,17 +851,17 @@ Extractor.prototype = {
 
     /**
     * Guesses end time from list of guessed datetimes relative to start time
     *
     * @param start     start time to consider when guessing
     * @param isTask    whether start time should be guessed for task or event
     * @return          datetime object for end time
     */
-    guessEnd: function guessEnd(start, isTask) {
+    guessEnd: function(start, isTask) {
         let guess = {};
         let endTimes = this.collected.filter(val => val.relation == "end");
         let durations = this.collected.filter(val => val.relation == "duration");
         if (endTimes.length == 0 && durations.length == 0) {
             return {};
         } else {
             for (let val in endTimes) {
                 cal.LOG("[calExtract] End: " + JSON.stringify(endTimes[val]));
@@ -975,17 +975,17 @@ Extractor.prototype = {
                 guess.minute = 0;
             }
 
             cal.LOG("[calExtract] End picked: " + JSON.stringify(guess));
             return guess;
         }
     },
 
-    getPatterns: function getPatterns(name) {
+    getPatterns: function(name) {
         let value;
         try {
             value = this.bundle.GetStringFromName(name);
             if (value.trim() == "") {
                 cal.LOG("[calExtract] Pattern not found: " + name);
                 return this.defPattern;
             }
 
@@ -1026,17 +1026,17 @@ Extractor.prototype = {
         } catch (ex) {
             cal.LOG("[calExtract] Pattern not found: " + name);
 
             // fake a value to avoid empty regexes creating endless loops
             return this.defPattern;
         }
     },
 
-    getRepPatterns: function getRepPatterns(name, replaceables) {
+    getRepPatterns: function(name, replaceables) {
         let alts = [];
         let patterns = [];
 
         try {
             let value = this.bundle.GetStringFromName(name);
             if (value.trim() == "") {
                 cal.LOG("[calExtract] Pattern empty: " + name);
                 return alts;
@@ -1093,17 +1093,17 @@ Extractor.prototype = {
                 alts[val] = { pattern: patterns[val], positions: positions };
             }
         } catch (ex) {
             cal.LOG("[calExtract] Pattern not found: " + name);
         }
         return alts;
     },
 
-    getPositionsFor: function getPositionsFor(s, name, count) {
+    getPositionsFor: function(s, name, count) {
         let positions = [];
         let re = /#(\d)/g;
         let match;
         let i = 0;
         while ((match = re.exec(s))) {
             i++;
             positions[parseInt(match[1], 10)] = i;
         }
@@ -1113,95 +1113,95 @@ Extractor.prototype = {
             if (positions[i] === undefined) {
                 Components.utils.reportError("[calExtract] Faulty extraction pattern " + name +
                                              ", missing parameter #" + i);
             }
         }
         return positions;
     },
 
-    cleanPatterns: function cleanPatterns(pattern) {
+    cleanPatterns: function(pattern) {
         // remove whitespace around | if present
         let value = pattern.replace(/\s*\|\s*/g, "|");
         // allow matching for patterns with missing or excessive whitespace
         return this.sanitize(value).replace(/\s+/g, "\\s*");
     },
 
-    isValidYear: function isValidYear(year) {
+    isValidYear: function(year) {
         return (year >= 2000 && year <= 2050);
     },
 
-    isValidMonth: function isValidMonth(month) {
+    isValidMonth: function(month) {
         return (month >= 1 && month <= 12);
     },
 
-    isValidDay: function isValidDay(day) {
+    isValidDay: function(day) {
         return (day >= 1 && day <= 31);
     },
 
-    isValidHour: function isValidHour(hour) {
+    isValidHour: function(hour) {
         return (hour >= 0 && hour <= 23);
     },
 
-    isValidMinute: function isValidMinute(minute) {
+    isValidMinute: function(minute) {
         return (minute >= 0 && minute <= 59);
     },
 
-    isPastDate: function isPastDate(date, referenceDate) {
+    isPastDate: function(date, referenceDate) {
         // avoid changing original refDate
         let refDate = new Date(referenceDate.getTime());
         refDate.setHours(0);
         refDate.setMinutes(0);
         refDate.setSeconds(0);
         refDate.setMilliseconds(0);
         let jsDate;
         if (date.day != null) {
             jsDate = new Date(date.year, date.month - 1, date.day);
         }
         return jsDate < refDate;
     },
 
-    normalizeHour: function normalizeHour(hour) {
+    normalizeHour: function(hour) {
         if (hour < this.dayStart && hour <= 11) {
             return hour + 12;
         }
         return hour;
     },
 
-    normalizeYear: function normalizeYear(year) {
+    normalizeYear: function(year) {
         return (year.length == 2) ? "20" + year : year;
     },
 
-    limitNums: function limitNums(res, email) {
+    limitNums: function(res, email) {
         let pattern = email.substring(res.index, res.index + res[0].length);
         let before = email.charAt(res.index - 1);
         let after = email.charAt(res.index + res[0].length);
         let result = (/\d/.exec(before) && /\d/.exec(pattern.charAt(0))) ||
                      (/\d/.exec(pattern.charAt(pattern.length - 1)) && /\d/.exec(after));
         return result != null;
     },
 
-    limitChars: function limitChars(res, email) {
+    limitChars: function(res, email) {
         let alphabet = this.getPatterns("alphabet");
         // for languages without regular alphabet surrounding characters are ignored
         if (alphabet == this.defPattern) {
             return false;
         }
 
         let pattern = email.substring(res.index, res.index + res[0].length);
         let before = email.charAt(res.index - 1);
         let after = email.charAt(res.index + res[0].length);
 
         let w = new RegExp("[" + alphabet + "]");
         let result = (w.exec(before) && w.exec(pattern.charAt(0))) ||
                      (w.exec(pattern.charAt(pattern.length - 1)) && w.exec(after));
         return result != null;
     },
 
-    prefixSuffixStartEnd: function prefixSuffixStart(res, relation, email) {
+    prefixSuffixStartEnd: function(res, relation, email) {
         let pattern = email.substring(res.index, res.index + res[0].length);
         let prev = email.substring(0, res.index);
         let next = email.substring(res.index + res[0].length);
         let prefixSuffix = { start: res.index, end: res.index + res[0].length,
                              pattern: pattern, relation: relation };
         let ch = "\\s*";
         let psres;
 
@@ -1242,17 +1242,17 @@ Extractor.prototype = {
         re = new RegExp("^" + ch + "(" + this.getPatterns("no.datetime.suffix") + ")", "ig");
         if ((psres = re.exec(next)) != null) {
             prefixSuffix.relation = "notadatetime";
         }
 
         return prefixSuffix;
     },
 
-    parseNumber: function parseNumber(number, numbers) {
+    parseNumber: function(number, numbers) {
         let r = parseInt(number, 10);
         // number comes in as plain text, numbers are already adjusted for usage
         // in regular expression
         number = this.cleanPatterns(number);
         if (isNaN(r)) {
             for (let i = 0; i <= 31; i++) {
                 let ns = numbers[i].split("|");
                 if (ns.includes(number.toLowerCase())) {
@@ -1260,18 +1260,18 @@ Extractor.prototype = {
                 }
             }
             return -1;
         } else {
             return r;
         }
     },
 
-    guess: function guess(year, month, day, hour, minute, start, end, str,
-                          relation, pattern, ambiguous) {
+    guess: function(year, month, day, hour, minute, start, end, str,
+                    relation, pattern, ambiguous) {
         let dateGuess = {
             year: year, month: month, day: day, hour: hour, minute: minute,
             start: start, end: end, str: str, relation: relation,
             pattern: pattern, ambiguous: ambiguous
         };
         // past dates are kept for containment checks
         if (this.isPastDate(dateGuess, this.now)) {
             guess.relation = "notadatetime";
--- a/calendar/base/modules/calHashedArray.jsm
+++ b/calendar/base/modules/calHashedArray.jsm
@@ -11,17 +11,17 @@ var EXPORTED_SYMBOLS = ["cal"]; // even 
  * retrieve the item by its hash id.
  *
  * Performance Considerations:
  *  - Accessing items is fast
  *  - Adding items is fast (they are added to the end)
  *  - Deleting items is O(n)
  *  - Modifying items is fast.
  */
-cal.HashedArray = function HashedArray() {
+cal.HashedArray = function() {
     this.clear();
 };
 
 cal.HashedArray.prototype = {
     mArray: null,
     mHash: null,
 
     mBatch: 0,
@@ -47,106 +47,106 @@ cal.HashedArray.prototype = {
     },
 
     /**
      * Returns the item, given its index in the array
      *
      * @param index         The index of the item to retrieve.
      * @return              The retrieved item.
      */
-    itemByIndex: function itemByIndex(index) {
+    itemByIndex: function(index) {
         return this.mArray[index];
     },
 
     /**
      * Returns the item, given its hashId
      *
      * @param id            The hashId of the item to retrieve.
      * @return              The retrieved item.
      */
-    itemById: function itemById(id) {
+    itemById: function(id) {
         if (this.mBatch > 0) {
             throw "Accessing Array by ID not supported in batch mode ";
         }
         return (id in this.mHash ? this.mArray[this.mHash[id]] : null);
     },
 
     /**
      * Returns the index of the given item. This function is cheap performance
      * wise, since it uses the hash
      *
      * @param item          The item to search for.
      * @return              The index of the item.
      */
-    indexOf: function indexOf(item) {
+    indexOf: function(item) {
         if (this.mBatch > 0) {
             throw "Accessing Array Indexes not supported in batch mode";
         }
         let hashId = this.hashAccessor(item);
         return (hashId in this.mHash ? this.mHash[hashId] : -1);
     },
 
     /**
      * Remove the item with the given hashId.
      *
      * @param id            The id of the item to be removed
      */
-    removeById: function removeById(id) {
+    removeById: function(id) {
         if (this.mBatch > 0) {
             throw "Remvoing by ID in batch mode is not supported"; /* TODO */
         }
         let index = this.mHash[id];
         delete this.mHash[id];
         this.mArray.splice(index, 1);
         this.reindex(index);
     },
 
     /**
      * Remove the item at the given index.
      *
      * @param index         The index of the item to remove.
      */
-    removeByIndex: function removeByIndex(index) {
+    removeByIndex: function(index) {
         delete this.mHash[this.hashAccessor(this.mArray[index])];
         this.mArray.splice(index, 1);
         this.reindex(index);
     },
 
     /**
      * Clear the whole array, removing all items. This also resets batch mode.
      */
-     clear: function clear() {
+     clear: function() {
         this.mHash = {};
         this.mArray = [];
         this.mFirstDirty = -1;
         this.mBatch = 0;
      },
 
     /**
      * Add the item to the array
      *
      * @param item          The item to add.
      * @return              The index of the added item.
      */
-    addItem: function addItem(item) {
+    addItem: function(item) {
         let index = this.mArray.length;
         this.mArray.push(item);
         this.reindex(index);
         return index;
     },
 
     /**
      * Modifies the item in the array. If the item is already in the array, then
      * it is replaced by the passed item. Otherwise, the item is added to the
      * array.
      *
      * @param item          The item to modify.
      * @return              The (new) index.
      */
-    modifyItem: function modifyItem(item) {
+    modifyItem: function(item) {
         let hashId = this.hashAccessor(item);
         if (hashId in this.mHash) {
             let index = this.mHash[this.hashAccessor(item)];
             this.mArray[index] = item;
             return index;
         } else {
             return this.addItem(item);
         }
@@ -157,17 +157,17 @@ cal.HashedArray.prototype = {
      * internally. All parameters are inclusive. The ranges are automatically
      * swapped if from > to.
      *
      * @param from      (optional) The index to start indexing from. If left
      *                    out, defaults to 0.
      * @param to        (optional) The index to end indexing on. If left out,
      *                    defaults to the array length.
      */
-    reindex: function reindex(from, to) {
+    reindex: function(from, to) {
         if (this.mArray.length == 0) {
             return;
         }
 
         from = (from === undefined ? 0 : from);
         to = (to === undefined ? this.mArray.length - 1 : to);
 
         from = Math.min(this.mArray.length - 1, Math.max(0, from));
@@ -185,65 +185,65 @@ cal.HashedArray.prototype = {
             return;
         }
 
         for (let idx = from; idx <= to; idx++) {
             this.mHash[this.hashAccessor(this.mArray[idx])] = idx;
         }
     },
 
-    startBatch: function startBatch() {
+    startBatch: function() {
         this.mBatch++;
     },
 
-    endBatch: function endBatch() {
+    endBatch: function() {
         this.mBatch = Math.max(0, this.mBatch - 1);
 
         if (this.mBatch == 0 && this.mFirstDirty > -1) {
             this.reindex(this.mFirstDirty);
             this.mFirstDirty = -1;
         }
     },
 
     /**
      * Iterator to allow iterating the hashed array object.
      */
-    [Symbol.iterator]: function* iterator() {
+    [Symbol.iterator]: function* () {
         yield* this.mArray;
     }
 };
 
 /**
  * Sorted hashed array. The array always stays sorted.
  *
  * Performance Considerations:
  *  - Accessing items is fast
  *  - Adding and deleting items is O(n)
  *  - Modifying items is fast.
  */
-cal.SortedHashedArray = function SortedHashedArray(comparator) {
+cal.SortedHashedArray = function(comparator) {
     cal.HashedArray.apply(this, arguments);
     if (!comparator) {
         throw "Sorted Hashed Array needs a comparator";
     }
     this.mCompFunc = comparator;
 };
 
 cal.SortedHashedArray.prototype = {
     __proto__: cal.HashedArray.prototype,
 
     mCompFunc: null,
 
-    addItem: function addItem(item) {
+    addItem: function(item) {
         let newIndex = cal.binaryInsert(this.mArray, item, this.mCompFunc, false);
         this.reindex(newIndex);
         return newIndex;
     },
 
-    modifyItem: function modifyItem(item) {
+    modifyItem: function(item) {
         let hashId = this.hashAccessor(item);
         if (hashId in this.mHash) {
             let cmp = this.mCompFunc(item, this.mArray[this.mHash[hashId]]);
             if (cmp == 0) {
                 // The item will be at the same index, we just need to replace it
                 this.mArray[this.mHash[hashId]] = item;
                 return this.mHash[hashId];
             } else {
--- a/calendar/base/modules/calItemUtils.jsm
+++ b/calendar/base/modules/calItemUtils.jsm
@@ -39,64 +39,64 @@ itemDiff.prototype = {
     mDeletedItems: null,
 
     /**
      * Expect the difference engine to be in the given state.
      *
      * @param aState    The state to be in
      * @param aMethod   The method name expecting the state
      */
-    _expectState: function _expectState(aState, aMethod) {
+    _expectState: function(aState, aMethod) {
         if ((this.state & aState) == 0) {
             throw new Error("itemDiff method " + aMethod +
                             " called while in unexpected state " + this.state);
         }
     },
 
     /**
      * Load the difference engine with one item, see load.
      *
      * @param item      The item to load
      */
-    load1: function load1(item) {
+    load1: function(item) {
         this.load([item]);
     },
 
     /**
      * Loads an array of items. This step cannot be executed
      * after calling the difference methods.
      *
      * @param items     The array of items to load
      */
-    load: function load(items) {
+    load: function(items) {
         this._expectState(this.STATE_INITIAL | this.STATE_LOADING, "load");
 
         for (let item of items) {
             this.mInitialItems[item.hashId] = item;
         }
 
         this.state = this.STATE_LOADING;
     },
 
     /**
      * Calculates the difference for the passed item, see difference.
      *
      * @param item      The item to calculate difference with
      */
-    difference1: function difference1(item) {
+    difference1: function(item) {
         this.difference([item]);
     },
 
     /**
      * Calculate the difference for the array of items. This method should be
      * called after all load methods and before the complete method.
      *
      * @param items     The array of items to calculate difference with
      */
-    difference: function difference(items) {
+    difference: function(items) {
         this._expectState(this.STATE_INITIAL | this.STATE_LOADING | this.STATE_DIFFERING, "difference");
 
         this.mModifiedOldItems.startBatch();
         this.mModifiedItems.startBatch();
         this.mAddedItems.startBatch();
 
         for (let item of items) {
             if (item.hashId in this.mInitialItems) {
@@ -115,17 +115,17 @@ itemDiff.prototype = {
 
         this.state = this.STATE_DIFFERING;
     },
 
     /**
      * Tell the engine that all load and difference calls have been made, this
      * makes sure that all item states are correctly returned.
      */
-    complete: function complete() {
+    complete: function() {
         this._expectState(this.STATE_INITIAL | this.STATE_LOADING | this.STATE_DIFFERING, "complete");
 
         this.mDeletedItems.startBatch();
 
         for (let hashId in this.mInitialItems) {
             let item = this.mInitialItems[hashId];
             this.mDeletedItems.addItem(item);
         }
@@ -163,17 +163,17 @@ itemDiff.prototype = {
     /** @return the number of loaded items */
     get count() {
         return Object.keys(this.mInitialItems).length;
     },
 
     /**
      * Resets the difference engine to its initial state.
      */
-    reset: function reset() {
+    reset: function() {
         this.mInitialItems = {};
         this.mModifiedItems = new cal.HashedArray();
         this.mModifiedOldItems = new cal.HashedArray();
         this.mAddedItems = new cal.HashedArray();
         this.mDeletedItems = new cal.HashedArray();
         this.state = this.STATE_INITIAL;
     }
 };
--- a/calendar/base/modules/calIteratorUtils.jsm
+++ b/calendar/base/modules/calIteratorUtils.jsm
@@ -9,17 +9,17 @@ Components.utils.import("resource://gre/
 this.EXPORTED_SYMBOLS = ["cal"]; // even though it's defined in calUtils.jsm, import needs this
 
 /**
  * Iterates an array of items, i.e. the passed item including all
  * overridden instances of a recurring series.
  *
  * @param items array of items
  */
-cal.itemIterator = function* cal_itemIterator(items) {
+cal.itemIterator = function* (items) {
     for (let item of items) {
         yield item;
         let rec = item.recurrenceInfo;
         if (rec) {
             for (let exid of rec.getExceptionIds({})) {
                 yield rec.getExceptionFor(exid);
             }
         }
@@ -40,31 +40,31 @@ cal.itemIterator = function* cal_itemIte
  * for each loop, use the optional completed() function.
  *
  * @param iter          The Iterator or the plain Object to go through in this
  *                      loop.
  * @param body          The function called for each iteration. Its parameter is
  *                          the single item from the iterator.
  * @param completed     [optional] The function called after the loop completes.
  */
-cal.forEach = function cal_forEach(iterable, body, completed) {
+cal.forEach = function(iterable, body, completed) {
     // This should be a const one day, lets keep it a pref for now though until we
     // find a sane value.
     let LATENCY = Preferences.get("calendar.threading.latency", 250);
 
     if (typeof iterable == "object" && !iterable[Symbol.iterator]) {
         iterable = Object.entries(iterable);
     }
 
     let ourIter = iterable[Symbol.iterator]();
     let currentThread = Services.tm.currentThread;
 
     // This is our dispatcher, it will be used for the iterations
     let dispatcher = {
-        run: function run() {
+        run: function() {
             let startTime = (new Date()).getTime();
             while (((new Date()).getTime() - startTime) < LATENCY) {
                 let next = ourIter.next();
                 let done = next.done;
 
                 if (!done) {
                     let rc = body(next.value);
                     if (rc == cal.forEach.BREAK) {
@@ -106,17 +106,17 @@ cal.ical = {
      *
      * This iterator can only be used in a for..of block:
      *   for (let component of cal.ical.calendarComponentIterator(aComp)) { ... }
      *
      *  @param aComponent       The component to iterate given the above rules.
      *  @param aCompType        The type of item to iterate.
      *  @return                 The iterator that yields all items.
      */
-    calendarComponentIterator: function* cal_ical_calendarComponentIterator(aComponent, aCompType) {
+    calendarComponentIterator: function* (aComponent, aCompType) {
         let compType = (aCompType || "ANY");
         if (aComponent && aComponent.componentType == "VCALENDAR") {
             yield* cal.ical.subcomponentIterator(aComponent, compType);
         } else if (aComponent && aComponent.componentType == "XROOT") {
             for (let calComp of cal.ical.subcomponentIterator(aComponent, "VCALENDAR")) {
                 yield* cal.ical.subcomponentIterator(calComp, compType);
             }
         } else if (aComponent && (compType == "ANY" || compType == aComponent.componentType)) {
@@ -131,17 +131,17 @@ cal.ical = {
      * This iterator can only be used in a for() block:
      *   for (let component in cal.ical.subcomponentIterator(aComp)) { ... }
      *
      * @param aComponent        The component who's subcomponents to iterate.
      * @param aSubcomp          (optional) the specific subcomponent to
      *                            enumerate. If not given, "ANY" will be used.
      * @return                  An iterator object to iterate the properties.
      */
-    subcomponentIterator: function* cal_ical_subcomponentIterator(aComponent, aSubcomp) {
+    subcomponentIterator: function* (aComponent, aSubcomp) {
         let subcompName = (aSubcomp || "ANY");
         for (let subcomp = aComponent.getFirstSubcomponent(subcompName);
              subcomp;
              subcomp = aComponent.getNextSubcomponent(subcompName)) {
             yield subcomp;
         }
     },
 
@@ -150,17 +150,17 @@ cal.ical = {
      * This iterator can only be used in a for() block:
      *   for (let property in cal.ical.propertyIterator(aComp)) { ... }
      *
      * @param aComponent        The component to iterate.
      * @param aProperty         (optional) the specific property to enumerate.
      *                            If not given, "ANY" will be used.
      * @return                  An iterator object to iterate the properties.
      */
-    propertyIterator: function* cal_ical_propertyIterator(aComponent, aProperty) {
+    propertyIterator: function* (aComponent, aProperty) {
         let propertyName = (aProperty || "ANY");
         for (let prop = aComponent.getFirstProperty(propertyName);
              prop;
              prop = aComponent.getNextProperty(propertyName)) {
             yield prop;
         }
     },
 
@@ -169,17 +169,17 @@ cal.ical = {
      * This iterator behaves similar to the object iterator. Possible uses:
      *   for (let paramName in cal.ical.paramIterator(prop)) { ... }
      * or:
      *   for (let [paramName, paramValue] of cal.ical.paramIterator(prop)) { ... }
      *
      * @param aProperty         The property to iterate.
      * @return                  An iterator object to iterate the properties.
      */
-    paramIterator: function* cal_ical_paramIterator(aProperty) {
+    paramIterator: function* (aProperty) {
         let paramSet = new Set();
         for (let paramName = aProperty.getFirstParameterName();
              paramName;
              paramName = aProperty.getNextParameterName()) {
             // Workaround to avoid infinite loop when the property
             // contains duplicate parameters (bug 875739 for libical)
             if (!paramSet.has(paramName)) {
                 yield [paramName, aProperty.getParameter(paramName)];
--- a/calendar/base/modules/calItipUtils.jsm
+++ b/calendar/base/modules/calItipUtils.jsm
@@ -14,17 +14,17 @@ Components.utils.import("resource://gre/
  */
 this.EXPORTED_SYMBOLS = ["cal"]; // even though it's defined in calUtils.jsm, import needs this
 cal.itip = {
     /**
      * Gets the sequence/revision number, either of the passed item or
      * the last received one of an attendee; see
      * <http://tools.ietf.org/html/draft-desruisseaux-caldav-sched-04#section-7.1>.
      */
-     getSequence: function cal_itip_getSequence(item) {
+     getSequence: function(item) {
         let seq = null;
 
         let wrappedItem = cal.wrapInstance(item, Components.interfaces.calIAttendee);
         if (wrappedItem) {
             seq = wrappedItem.getProperty("RECEIVED-SEQUENCE");
         } else if (item) {
             // Unless the below is standardized, we store the last original
             // REQUEST/PUBLISH SEQUENCE in X-MOZ-RECEIVED-SEQUENCE to test against it
@@ -49,17 +49,17 @@ cal.itip = {
         }
     },
 
     /**
      * Gets the stamp date-time, either of the passed item or
      * the last received one of an attendee; see
      * <http://tools.ietf.org/html/draft-desruisseaux-caldav-sched-04#section-7.2>.
      */
-    getStamp: function cal_itip_getStamp(item) {
+    getStamp: function(item) {
         let dtstamp = null;
 
         let wrappedItem = cal.wrapInstance(item, Components.interfaces.calIAttendee);
         if (wrappedItem) {
             let st = wrappedItem.getProperty("RECEIVED-DTSTAMP");
             if (st) {
                 dtstamp = cal.createDateTime(st);
             }
@@ -77,17 +77,17 @@ cal.itip = {
         }
 
         return dtstamp;
     },
 
     /**
      * Compares sequences and/or stamps of two parties; returns -1, 0, +1.
      */
-    compare: function cal_itip_compare(item1, item2) {
+    compare: function(item1, item2) {
         let seq1 = cal.itip.getSequence(item1);
         let seq2 = cal.itip.getSequence(item2);
         if (seq1 > seq2) {
             return 1;
         } else if (seq1 < seq2) {
             return -1;
         } else {
             let st1 = cal.itip.getStamp(item1);
@@ -106,32 +106,32 @@ cal.itip = {
 
     /**
      * Checks if the given calendar is a scheduling calendar. This means it
      * needs an organizer id and an itip transport. It should also be writable.
      *
      * @param calendar    The calendar to check
      * @return            True, if its a scheduling calendar.
      */
-    isSchedulingCalendar: function isSchedulingCalendar(calendar) {
+    isSchedulingCalendar: function(calendar) {
         return cal.isCalendarWritable(calendar) &&
                calendar.getProperty("organizerId") &&
                calendar.getProperty("itip.transport");
     },
 
     /**
      * Scope: iTIP message receiver
      *
      * Given an nsIMsgDBHdr and an imipMethod, set up the given itip item.
      *
      * @param itipItem    The item to set up
      * @param imipMethod  The received imip method
      * @param aMsgHdr     Information about the received email
      */
-    initItemFromMsgData: function initItemFromMsgData(itipItem, imipMethod, aMsgHdr) {
+    initItemFromMsgData: function(itipItem, imipMethod, aMsgHdr) {
         // Get the recipient identity and save it with the itip item.
         itipItem.identity = cal.itip.getMessageRecipient(aMsgHdr);
 
         // We are only called upon receipt of an invite, so ensure that isSend
         // is false.
         itipItem.isSend = false;
 
         // XXX Get these from preferences
@@ -165,17 +165,17 @@ cal.itip = {
      *
      * Gets the suggested text to be shown when an imip item has been processed.
      * This text is ready localized and can be displayed to the user.
      *
      * @param aStatus         The status of the processing (i.e NS_OK, an error code)
      * @param aOperationType  An operation type from calIOperationListener
      * @return                The suggested text.
      */
-    getCompleteText: function getCompleteText(aStatus, aOperationType) {
+    getCompleteText: function(aStatus, aOperationType) {
         function _gs(strName, param) {
             return cal.calGetString("lightning", strName, param, "lightning");
         }
 
         let text = "";
         const cIOL = Components.interfaces.calIOperationListener;
         if (Components.isSuccessCode(aStatus)) {
             switch (aOperationType) {
@@ -193,17 +193,17 @@ cal.itip = {
      * Scope: iTIP message receiver
      *
      * Gets a text describing the given itip method. The text is of the form
      * "This Message contains a ... ".
      *
      * @param method      The method to describe.
      * @return            The localized text about the method.
      */
-    getMethodText: function getMethodtext(method) {
+    getMethodText: function(method) {
         function _gs(strName) {
             return cal.calGetString("lightning", strName, null, "lightning");
         }
 
         switch (method) {
             case "REFRESH": return _gs("imipBarRefreshText");
             case "REQUEST": return _gs("imipBarRequestText");
             case "PUBLISH": return _gs("imipBarPublishText");
@@ -227,17 +227,17 @@ cal.itip = {
      *    hideMenuItem: ["imipXXXButton_Option", ...]
      * }
      *
      * @see processItipItem   This takes the same parameters as its optionFunc.
      * @param itipItem        The itipItem to query.
      * @param rc              The result of retrieving the item
      * @param actionFunc      The action function.
      */
-    getOptionsText: function getOptionsText(itipItem, rc, actionFunc, foundItems) {
+    getOptionsText: function(itipItem, rc, actionFunc, foundItems) {
         function _gs(strName) {
             return cal.calGetString("lightning", strName, null, "lightning");
         }
         let imipLabel = null;
         if (itipItem.receivedMethod) {
             imipLabel = cal.itip.getMethodText(itipItem.receivedMethod);
         }
         let data = { label: imipLabel, buttons: [], hideMenuItems: [] };
@@ -333,17 +333,17 @@ cal.itip = {
     /**
      * Scope: iTIP message receiver
      *
      * Retrieves the intended recipient for this message.
      *
      * @param aMsgHdr     The message to check.
      * @return            The email of the intended recipient.
      */
-    getMessageRecipient: function getMessageRecipient(aMsgHdr) {
+    getMessageRecipient: function(aMsgHdr) {
         if (!aMsgHdr) {
             return null;
         }
 
         let identities;
         let actMgr = MailServices.accounts;
         if (aMsgHdr.accountKey) {
             // First, check if the message has an account key. If so, we can use the
@@ -409,17 +409,17 @@ cal.itip = {
      * calendar will be set on the passed itip item.
      *
      * @param aMethod       The method to check.
      * @param aItipItem     The itip item to set the target calendar on.
      * @param aWindow       The window to open the dialog on.
      * @return              True, if a calendar was selected or no selection is
      *                        needed.
      */
-    promptCalendar: function promptCalendar(aMethod, aItipItem, aWindow) {
+    promptCalendar: function(aMethod, aItipItem, aWindow) {
         let needsCalendar = false;
         let targetCalendar = null;
         switch (aMethod) {
             // methods that don't require the calendar chooser:
             case "REFRESH":
             case "REQUEST:UPDATE":
             case "REQUEST:UPDATE-MINOR":
             case "PUBLISH:UPDATE":
@@ -455,17 +455,17 @@ cal.itip = {
             } else if (calendars.length == 1) {
                 // There's only one calendar, so it's silly to ask what calendar
                 // the user wants to import into.
                 targetCalendar = calendars[0];
             } else {
                 // Ask what calendar to import into
                 let args = {};
                 args.calendars = calendars;
-                args.onOk = function selectCalendar(aCal) { targetCalendar = aCal; };
+                args.onOk = (aCal) => { targetCalendar = aCal; };
                 args.promptText = cal.calGetString("calendar", "importPrompt");
                 aWindow.openDialog("chrome://calendar/content/chooseCalendarDialog.xul",
                                    "_blank", "chrome,titlebar,modal,resizable", args);
             }
 
             if (targetCalendar) {
                 aItipItem.targetCalendar = targetCalendar;
             }
@@ -476,17 +476,17 @@ cal.itip = {
 
     /**
      * Clean up after the given iTIP item. This needs to be called once for each
      * time processItipItem is called. May be called with a null itipItem in
      * which case it will do nothing.
      *
      * @param itipItem      The iTIP item to clean up for.
      */
-    cleanupItipItem: function cleanupItipItem(itipItem) {
+    cleanupItipItem: function(itipItem) {
         if (itipItem) {
             let itemList = itipItem.getItemList({});
             if (itemList.length > 0) {
                 // Again, we can assume the id is the same over all items per spec
                 ItipItemFinderFactory.cleanup(itemList[0].id);
             }
         }
     },
@@ -504,17 +504,17 @@ cal.itip = {
      *                    * PUBLISH -- initial publish, no reply (sent by organizer)
      *                    * PUBLISH:UPDATE -- update of a published item (sent by organizer)
      *                    * REQUEST -- initial invitation (sent by organizer)
      *                    * REQUEST:UPDATE -- rescheduling invitation, has major change (sent by organizer)
      *                    * REQUEST:UPDATE-MINOR -- update of invitation, minor change (sent by organizer)
      *                    * REPLY -- invitation reply (sent by attendee(s))
      *                    * CANCEL -- invitation cancel (sent by organizer)
      */
-    processItipItem: function cal_itip_processItipItem(itipItem, optionsFunc) {
+    processItipItem: function(itipItem, optionsFunc) {
         switch (itipItem.receivedMethod.toUpperCase()) {
             case "REFRESH":
             case "PUBLISH":
             case "REQUEST":
             case "CANCEL":
             case "REPLY": {
                 // Per iTIP spec (new Draft 4), multiple items in an iTIP message MUST have
                 // same ID, this simplifies our searching, we can just look for Item[0].id
@@ -538,17 +538,17 @@ cal.itip = {
     },
 
     /**
      * Scope: iTIP message sender
      *
      * Checks to see if e.g. attendees were added/removed or an item has been
      * deleted and sends out appropriate iTIP messages.
      */
-    checkAndSend: function cal_itip_checkAndSend(aOpType, aItem, aOriginalItem) {
+    checkAndSend: function(aOpType, aItem, aOriginalItem) {
         // balance out parts of the modification vs delete confusion, deletion of occurrences
         // are notified as parent modifications and modifications of occurrences are notified
         // as mixed new-occurrence, old-parent (IIRC).
         if (aOriginalItem && aItem.recurrenceInfo) {
             if (aOriginalItem.recurrenceId && !aItem.recurrenceId) {
                 // sanity check: assure aItem doesn't refer to the master
                 aItem = aItem.recurrenceInfo.getOccurrenceFor(aOriginalItem.recurrenceId);
                 cal.ASSERT(aItem, "unexpected!");
@@ -773,17 +773,17 @@ cal.itip = {
                 sendMessage(cancelItem, "CANCEL", canceledAttendees, autoResponse);
             }
         }
     },
 
     /**
      * Bumps the SEQUENCE in case of a major change; XXX todo may need more fine-tuning.
      */
-    prepareSequence: function cal_itip_prepareSequence(newItem, oldItem) {
+    prepareSequence: function(newItem, oldItem) {
         if (cal.isInvitation(newItem)) {
             return newItem; // invitation copies don't bump the SEQUENCE
         }
 
         if (newItem.recurrenceId && !oldItem.recurrenceId && oldItem.recurrenceInfo) {
             // XXX todo: there's still the bug that modifyItem is called with mixed occurrence/parent,
             //           find original occurrence
             oldItem = oldItem.recurrenceInfo.getOccurrenceFor(newItem.recurrenceId);
@@ -834,17 +834,17 @@ cal.itip = {
     /**
      * Returns a copy of an itipItem with modified properties and items build from scratch
      * Use itipItem.clone() instead if only a simple copy is required
      *
      * @param aItipItem     ItipItem to derive a new one from
      * @param aItems        List of items to be contained in the new itipItem
      * @param aProps        List of properties to be different in the new itipItem
      */
-    getModifiedItipItem: function cal_getModifiedItipItem(aItipItem, aItems=[], aProps={}) {
+    getModifiedItipItem: function(aItipItem, aItems=[], aProps={}) {
         let itipItem = Components.classes["@mozilla.org/calendar/itip-item;1"]
                                  .createInstance(Components.interfaces.calIItipItem);
         let serializedItems = "";
         for (let item of aItems) {
             serializedItems += cal.getSerializedItem(item);
         }
         itipItem.init(serializedItems);
 
@@ -1073,39 +1073,30 @@ function sendMessage(aItem, aMethod, aRe
  * @param oldItem the previous item before modification (if any)
  */
 function ItipOpListener(opListener, oldItem) {
     this.mOpListener = opListener;
     this.mOldItem = oldItem;
 }
 ItipOpListener.prototype = {
     QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-    onOperationComplete: function ItipOpListener_onOperationComplete(aCalendar,
-                                                                     aStatus,
-                                                                     aOperationType,
-                                                                     aId,
-                                                                     aDetail) {
+    onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDetail) {
         cal.ASSERT(Components.isSuccessCode(aStatus), "error on iTIP processing");
         if (Components.isSuccessCode(aStatus)) {
             cal.itip.checkAndSend(aOperationType, aDetail, this.mOldItem);
         }
         if (this.mOpListener) {
             this.mOpListener.onOperationComplete(aCalendar,
                                                  aStatus,
                                                  aOperationType,
                                                  aId,
                                                  aDetail);
         }
     },
-    onGetResult: function ItipOpListener_onGetResult(aCalendar,
-                                                     aStatus,
-                                                     aItemType,
-                                                     aDetail,
-                                                     aCount,
-                                                     aItems) {
+    onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
     }
 };
 
 /** local to this module file
  * Add a parameter SCHEDULE-AGENT=CLIENT to the item before it is
  * created or updated so that the providers knows scheduling will
  * be handled by the client.
  *
@@ -1127,30 +1118,30 @@ var ItipItemFinderFactory = {
     /**
      * Create an item finder and track its progress. Be sure to clean up the
      * finder for this id at some point.
      *
      * @param aId           The item id to search for
      * @param aItipItem     The iTIP item used for processing
      * @param aOptionsFunc  The options function used for processing the found item
      */
-    findItem: function findItem(aId, aItipItem, aOptionsFunc) {
+    findItem: function(aId, aItipItem, aOptionsFunc) {
         this.cleanup(aId);
         let finder = new ItipItemFinder(aId, aItipItem, aOptionsFunc);
         this._findMap[aId] = finder;
         finder.findItem();
     },
 
     /**
      * Clean up tracking for the given id. This needs to be called once for
      * every time findItem is called.
      *
      * @param aId           The item id to clean up for
      */
-    cleanup: function cleanup(aId) {
+    cleanup: function(aId) {
         if (aId in this._findMap) {
             let finder = this._findMap[aId];
             finder.destroy();
             delete this._findMap[aId];
         }
     }
 };
 
@@ -1173,49 +1164,49 @@ ItipItemFinder.prototype = {
         Components.interfaces.calIOperationListener
     ]),
 
     mSearchId: null,
     mItipItem: null,
     mOptionsFunc: null,
     mFoundItems: null,
 
-    findItem: function findItem() {
+    findItem: function() {
         this.mFoundItems = [];
         this._unobserveChanges();
         this.mItipItem.targetCalendar.getItem(this.mSearchId, this);
     },
 
-    _observeChanges: function _observeChanges(aCalendar) {
+    _observeChanges: function(aCalendar) {
         this._unobserveChanges();
         this.mObservedCalendar = aCalendar;
 
         if (this.mObservedCalendar) {
             this.mObservedCalendar.addObserver(this);
         }
     },
-    _unobserveChanges: function _unobserveChanges() {
+    _unobserveChanges: function() {
         if (this.mObservedCalendar) {
             this.mObservedCalendar.removeObserver(this);
             this.mObservedCalendar = null;
         }
     },
 
     onStartBatch: function() {},
     onEndBatch: function() {},
     onError: function() {},
     onPropertyChanged: function() {},
     onPropertyDeleting: function() {},
-    onLoad: function onLoad(aCalendar) {
+    onLoad: function(aCalendar) {
         // Its possible that the item was updated. We need to re-retrieve the
         // items now.
         this.findItem();
     },
 
-    onModifyItem: function onModifyItem(aNewItem, aOldItem) {
+    onModifyItem: function(aNewItem, aOldItem) {
         let refItem = aOldItem || aNewItem;
         if (refItem.id == this.mSearchId) {
             // Check existing found items to see if it already exists
             let found = false;
             for (let [idx, item] in Iterator(this.mFoundItems)) {
                 if (item.id == refItem.id && item.calendar.id == refItem.calendar.id) {
                     if (aNewItem) {
                         this.mFoundItems.splice(idx, 1, aNewItem);
@@ -1230,39 +1221,35 @@ ItipItemFinder.prototype = {
             // If it hasn't been found and there isto add a item, add it to the end
             if (!found && aNewItem) {
                 this.mFoundItems.push(aNewItem);
             }
             this.processFoundItems();
         }
     },
 
-    onAddItem: function onAddItem(aItem) {
+    onAddItem: function(aItem) {
         // onModifyItem is set up to also handle additions
         this.onModifyItem(aItem, null);
     },
 
-    onDeleteItem: function onDeleteItem(aItem) {
+    onDeleteItem: function(aItem) {
         // onModifyItem is set up to also handle deletions
         this.onModifyItem(null, aItem);
     },
 
-    onOperationComplete: function onOperationComplete(aCalendar,
-                                                      aStatus,
-                                                      aOperationType,
-                                                      aId,
-                                                      aDetail) {
+    onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDetail) {
         this.processFoundItems();
     },
 
-    destroy: function destroy() {
+    destroy: function() {
         this._unobserveChanges();
     },
 
-    processFoundItems: function processFoundItems() {
+    processFoundItems: function() {
         let rc = Components.results.NS_OK;
         const method = this.mItipItem.receivedMethod.toUpperCase();
         let actionMethod = method;
         let operations = [];
 
         if (this.mFoundItems.length > 0) {
             // Save the target calendar on the itip item
             this.mItipItem.targetCalendar = this.mFoundItems[0].calendar;
@@ -1517,34 +1504,29 @@ ItipItemFinder.prototype = {
                         break;
                 }
             }
         }
 
         cal.LOG("iTIP operations: " + operations.length);
         let actionFunc = null;
         if (operations.length > 0) {
-            actionFunc = function execOperations(opListener, partStat) {
+            actionFunc = function(opListener, partStat) {
                 for (let op of operations) {
                     try {
                         op(opListener, partStat);
                     } catch (exc) {
                         cal.ERROR(exc);
                     }
                 }
             };
             actionFunc.method = actionMethod;
         }
 
         this.mOptionsFunc(this.mItipItem, rc, actionFunc, this.mFoundItems);
     },
 
-    onGetResult: function onGetResult(aCalendar,
-                                      aStatus,
-                                      aItemType,
-                                      aDetail,
-                                      aCount,
-                                      aItems) {
+    onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
         if (Components.isSuccessCode(aStatus)) {
             this.mFoundItems = this.mFoundItems.concat(aItems);
         }
     }
 };
--- a/calendar/base/modules/calPrintUtils.jsm
+++ b/calendar/base/modules/calPrintUtils.jsm
@@ -10,30 +10,30 @@ this.EXPORTED_SYMBOLS = ["cal"]; // even
 cal.print = {
     /**
      * Returns a simple key in the format YYYY-MM-DD for use in the table of
      * dates to day boxes
      *
      * @param dt    The date to translate
      * @return      YYYY-MM-DD
      */
-    getDateKey: function getDateKey(dt) {
+    getDateKey: function(dt) {
         return dt.year + "-" + dt.month + "-" + dt.day;
     },
 
     /**
      * Add category styles to the document's "sheet" element. This is needed
      * since the HTML created is serialized, so we can't dynamically set the
      * styles and can be changed if the print formatter decides to return a
      * DOM document instead.
      *
      * @param document      The document that contains <style id="sheet"/>.
      * @param categories    Array of categories to insert rules for.
      */
-    insertCategoryRules: function insertCategoryRules(document, categories) {
+    insertCategoryRules: function(document, categories) {
         let sheet = document.getElementById("sheet");
         sheet.insertedCategoryRules = sheet.insertedCategoryRules || {};
 
         for (let category of categories) {
             let prefName = cal.formatStringForCSSRule(category);
             let color = Preferences.get("calendar.category.color." + prefName) || "transparent";
             if (!(prefName in sheet.insertedCategoryRules)) {
                 sheet.insertedCategoryRules[prefName] = true;
@@ -48,17 +48,17 @@ cal.print = {
      * Add calendar styles to the document's "sheet" element. This is needed
      * since the HTML created is serialized, so we can't dynamically set the
      * styles and can be changed if the print formatter decides to return a
      * DOM document instead.
      *
      * @param document      The document that contains <style id="sheet"/>.
      * @param categories    The calendar to insert a rule for.
      */
-    insertCalendarRules: function insertCalendarRules(document, calendar) {
+    insertCalendarRules: function(document, calendar) {
         let sheet = document.getElementById("sheet");
         let color = calendar.getProperty("color") || "#A8C2E1";
         sheet.insertedCalendarRules = sheet.insertedCalendarRules || {};
 
         if (!(calendar.id in sheet.insertedCalendarRules)) {
             sheet.insertedCalendarRules[calendar.id] = true;
             let formattedId = cal.formatStringForCSSRule(calendar.id);
             let ruleAdd = ' .calendar-color-box[calendar-id="' + formattedId + '"] { ' +
@@ -78,17 +78,17 @@ cal.print = {
      *   - .item-title gets the item title
      *   - .category-color-box gets a 2px solid border in category color
      *   - .calendar-color-box gets background color of the calendar
      *
      * @param document          The DOM Document to set things on
      * @param item              The item to serialize
      * @param dayContainer      The DOM Node to insert the container in
      */
-    addItemToDaybox: function addItemToDaybox(document, item, boxDate, dayContainer) {
+    addItemToDaybox: function(document, item, boxDate, dayContainer) {
         // Clone our template
         let itemNode = document.getElementById("item-template").cloneNode(true);
         itemNode.removeAttribute("id");
         itemNode.item = item;
 
         // Fill in details of the item
         let itemInterval = cal.print.getItemIntervalString(item, boxDate);
         itemNode.querySelector(".item-interval").textContent = itemInterval;
@@ -123,17 +123,17 @@ cal.print = {
      * - #task-list-box will have the "hidden" attribute removed.
      * - #task-template will be cloned and filled, and modified:
      *   - .task-checkbox gets the "checked" attribute set, if completed
      *   - .task-title gets the item title.
      *
      * @param document          The DOM Document to set things on
      * @param item              The item to serialize
      */
-    addItemToDayboxNodate: function addItemToDayboxNodate(document, item) {
+    addItemToDayboxNodate: function(document, item) {
         let taskContainer = document.getElementById("task-container");
         let taskNode = document.getElementById("task-template").cloneNode(true);
         taskNode.removeAttribute("id");
         taskNode.item = item;
 
         let taskListBox = document.getElementById("tasks-list-box");
         if (taskListBox.hasAttribute("hidden")) {
             let tasksTitle = document.getElementById("tasks-title");
@@ -153,17 +153,17 @@ cal.print = {
     },
 
     /**
      * Get time interval string for the given item. Returns an empty string for all-day items.
      *
      * @param aItem     The item providing the interval
      * @return          The string describing the interval
      */
-    getItemIntervalString: function getItemIntervalString(aItem, aBoxDate) {
+    getItemIntervalString: function(aItem, aBoxDate) {
         // omit time label for all-day items
         let startDate = aItem[cal.calGetStartDateProp(aItem)];
         let endDate = aItem[cal.calGetEndDateProp(aItem)];
         if ((startDate && startDate.isDate) || (endDate && endDate.isDate)) {
             return "";
         }
 
         // check for tasks without start and/or due date
--- a/calendar/base/modules/calProviderUtils.jsm
+++ b/calendar/base/modules/calProviderUtils.jsm
@@ -24,17 +24,17 @@ this.EXPORTED_SYMBOLS = ["cal"]; // even
  * @param aUploadData                Data to be uploaded, if any. This may be a
  *                                     nsIInputStream or string data. In the
  *                                     latter case the string will be converted
  *                                     to an input stream.
  * @param aContentType               Value for Content-Type header, if any
  * @param aNotificationCallbacks     Calendar using channel
  * @param aExisting                  An existing channel to modify (optional)
  */
-cal.prepHttpChannel = function calPrepHttpChannel(aUri, aUploadData, aContentType, aNotificationCallbacks, aExisting) {
+cal.prepHttpChannel = function(aUri, aUploadData, aContentType, aNotificationCallbacks, aExisting) {
     let channel = aExisting || Services.io.newChannelFromURI2(aUri,
                                                               null,
                                                               Services.scriptSecurityManager.getSystemPrincipal(),
                                                               null,
                                                               Components.interfaces.nsILoadInfo.SEC_NORMAL,
                                                               Components.interfaces.nsIContentPolicy.TYPE_OTHER);
     let httpchannel = channel.QueryInterface(Components.interfaces.nsIHttpChannel);
 
@@ -66,27 +66,27 @@ cal.prepHttpChannel = function calPrepHt
 
 /**
  * calSendHttpRequest; send prepared HTTP request
  *
  * @param aStreamLoader     streamLoader for request
  * @param aChannel          channel for request
  * @param aListener         listener for method completion
  */
-cal.sendHttpRequest = function calSendHttpRequest(aStreamLoader, aChannel, aListener) {
+cal.sendHttpRequest = function(aStreamLoader, aChannel, aListener) {
     aStreamLoader.init(aListener);
     aChannel.asyncOpen(aStreamLoader, aChannel);
 };
 
-cal.createStreamLoader = function calCreateStreamLoader() {
+cal.createStreamLoader = function() {
     return Components.classes["@mozilla.org/network/stream-loader;1"]
                      .createInstance(Components.interfaces.nsIStreamLoader);
 };
 
-cal.convertByteArray = function calConvertByteArray(aResult, aResultLength, aCharset, aThrow) {
+cal.convertByteArray = function(aResult, aResultLength, aCharset, aThrow) {
     try {
         let resultConverter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"]
                                         .createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
         resultConverter.charset = aCharset || "UTF-8";
         return resultConverter.convertFromByteArray(aResult, aResultLength);
     } catch (e) {
         if (aThrow) {
             throw e;
@@ -108,17 +108,17 @@ cal.convertByteArray = function calConve
  *
  * NOTE: If the server only provides one realm for all calendars, be sure that
  * the |this| object implements calICalendar. In this case the calendar name
  * will be appended to the realm. If you need that feature disabled, see the
  * capabilities section of calICalendar.idl
  *
  * @param aIID      The interface ID to return
  */
-cal.InterfaceRequestor_getInterface = function calInterfaceRequestor_getInterface(aIID) {
+cal.InterfaceRequestor_getInterface = function(aIID) {
     try {
         // Try to query the this object for the requested interface but don't
         // throw if it fails since that borks the network code.
         return this.QueryInterface(aIID);
     } catch (e) {
         // Support Auth Prompt Interfaces
         if (aIID.equals(Components.interfaces.nsIAuthPrompt2)) {
             if (!this.calAuthPrompt) {
@@ -139,23 +139,23 @@ cal.InterfaceRequestor_getInterface = fu
     }
     return null;
 };
 
 /**
  * Bad Certificate Handler for Network Requests. Shows the Network Exception
  * Dialog if a certificate Problem occurs.
  */
-cal.BadCertHandler = function calBadCertHandler(thisProvider) {
+cal.BadCertHandler = function(thisProvider) {
     this.thisProvider = thisProvider;
 };
 cal.BadCertHandler.prototype = {
     QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIBadCertListener2]),
 
-    notifyCertProblem: function cBCL_notifyCertProblem(socketInfo, status, targetSite) {
+    notifyCertProblem: function(socketInfo, status, targetSite) {
         // Unfortunately we can't pass js objects using the window watcher, so
         // we'll just take the first available calendar window. We also need to
         // do this on a timer so that the modal window doesn't block the
         // network request.
         let calWindow = cal.getCalendarWindow();
 
         let timerCallback = {
             thisProvider: this.thisProvider,
@@ -191,17 +191,17 @@ cal.BadCertHandler.prototype = {
  * Freebusy interval implementation. All parameters are optional.
  *
  * @param aCalId         The calendar id to set up with.
  * @param aFreeBusyType  The type from calIFreeBusyInterval.
  * @param aStart         The start of the interval.
  * @param aEnd           The end of the interval.
  * @return               The fresh calIFreeBusyInterval.
  */
-cal.FreeBusyInterval = function calFreeBusyInterval(aCalId, aFreeBusyType, aStart, aEnd) {
+cal.FreeBusyInterval = function(aCalId, aFreeBusyType, aStart, aEnd) {
     this.calId = aCalId;
     this.interval = Components.classes["@mozilla.org/calendar/period;1"]
                               .createInstance(Components.interfaces.calIPeriod);
     this.interval.start = aStart;
     this.interval.end = aEnd;
 
     this.freeBusyType = aFreeBusyType || Components.interfaces.calIFreeBusyInterval.UNKNOWN;
 };
@@ -210,32 +210,32 @@ cal.FreeBusyInterval.prototype = {
     calId: null,
     interval: null,
     freeBusyType: Components.interfaces.calIFreeBusyInterval.UNKNOWN
 };
 
 /**
  * Gets the iTIP/iMIP transport if the passed calendar has configured email.
  */
-cal.getImipTransport = function calGetImipTransport(aCalendar) {
+cal.getImipTransport = function(aCalendar) {
     // assure an identity is configured for the calendar
     return (aCalendar.getProperty("imip.identity")
             ? Components.classes["@mozilla.org/calendar/itip-transport;1?type=email"]
                         .getService(Components.interfaces.calIItipTransport)
             : null);
 };
 
 /**
  * Gets the configured identity and account of a particular calendar instance, or null.
  *
  * @param aCalendar     Calendar instance
  * @param outAccount    Optional out value for account
  * @return              The configured identity
  */
-cal.getEmailIdentityOfCalendar = function calGetEmailIdentityOfCalendar(aCalendar, outAccount) {
+cal.getEmailIdentityOfCalendar = function(aCalendar, outAccount) {
     cal.ASSERT(aCalendar, "no calendar!", Components.results.NS_ERROR_INVALID_ARG);
     let key = aCalendar.getProperty("imip.identity.key");
     if (key !== null) {
         if (key.length == 0) { // i.e. "None"
             return null;
         }
         let identity = null;
         cal.calIterateEmailIdentities(
@@ -299,17 +299,17 @@ cal.getEmailIdentityOfCalendar = functio
 /**
  * fromRFC3339
  * Convert a RFC3339 compliant Date string to a calIDateTime.
  *
  * @param aStr          The RFC3339 compliant Date String
  * @param aTimezone     The timezone this date string is most likely in
  * @return              A calIDateTime object
  */
-cal.fromRFC3339 = function fromRFC3339(aStr, aTimezone) {
+cal.fromRFC3339 = function(aStr, aTimezone) {
     // XXX I have not covered leapseconds (matches[8]), this might need to
     // be done. The only reference to leap seconds I found is bug 227329.
     //
 
     // Create a DateTime instance (calUtils.js)
     let dateTime = cal.createDateTime();
 
     // Killer regex to parse RFC3339 dates
@@ -384,17 +384,17 @@ cal.fromRFC3339 = function fromRFC3339(a
 
 /**
  * toRFC3339
  * Convert a calIDateTime to a RFC3339 compliant Date string
  *
  * @param aDateTime     The calIDateTime object
  * @return              The RFC3339 compliant date string
  */
-cal.toRFC3339 = function toRFC3339(aDateTime) {
+cal.toRFC3339 = function(aDateTime) {
     if (!aDateTime) {
         return "";
     }
 
     let full_tzoffset = aDateTime.timezoneOffset;
     let tzoffset_hr = Math.floor(Math.abs(full_tzoffset) / 3600);
 
     let tzoffset_mn = ((Math.abs(full_tzoffset) / 3600).toFixed(2) -
@@ -420,69 +420,69 @@ cal.toRFC3339 = function toRFC3339(aDate
         } else {
             // ZULU Time, according to ISO8601's timezone-offset
             str += "Z";
         }
     }
     return str;
 };
 
-cal.promptOverwrite = function cal_promptOverwrite(aMode, aItem) {
+cal.promptOverwrite = function(aMode, aItem) {
     let window = cal.getCalendarWindow();
     let args = { item: aItem,
                  mode: aMode,
                  overwrite: false };
 
     window.openDialog("chrome://calendar/content/calendar-conflicts-dialog.xul",
                       "calendarConflictsDialog",
                       "chrome,titlebar,modal",
                       args);
 
     return args.overwrite;
 };
 
 /**
  * Observer bag implementation taking care to replay open batch notifications.
  */
-cal.ObserverBag = function calObserverBag(iid) {
+cal.ObserverBag = function(iid) {
     this.init(iid);
 };
 cal.ObserverBag.prototype = {
     __proto__: cal.calListenerBag.prototype,
 
     mBatchCount: 0,
-    notify: function calObserverBag_notify(func, args) {
+    notify: function(func, args) {
         switch (func) {
             case "onStartBatch":
                  ++this.mBatchCount;
                  break;
             case "onEndBatch":
                  --this.mBatchCount;
                  break;
         }
         return this.__proto__.__proto__.notify.apply(this, arguments);
     },
 
-    add: function calObserverBag_add(iface) {
+    add: function(iface) {
         if (this.__proto__.__proto__.add.apply(this, arguments) && (this.mBatchCount > 0)) {
             // Replay batch notifications, because the onEndBatch notifications are yet to come.
             // We may think about doing the reverse on remove, though I currently see no need:
             for (let i = this.mBatchCount; i--;) {
                 iface.onStartBatch();
             }
         }
     }
 };
 
 /**
  * Base prototype to be used implementing a provider.
  *
  * @see e.g. providers/gdata
  */
-cal.ProviderBase = function calProviderBase() {
+cal.ProviderBase = function() {
     cal.ASSERT("This prototype should only be inherited!");
 };
 cal.ProviderBase.mTransientProperties = {
     "cache.uncachedCalendar": true,
     "currentStatus": true,
     "itip.transport": true,
     "imip.identity": true,
     "imip.account": true,
@@ -497,17 +497,17 @@ cal.ProviderBase.prototype = {
     ]),
 
     mID: null,
     mUri: null,
     mACLEntry: null,
     mObservers: null,
     mProperties: null,
 
-    initProviderBase: function cPB_initProviderBase() {
+    initProviderBase: function() {
         this.wrappedJSObject = this;
         this.mObservers = new cal.ObserverBag(Components.interfaces.calIObserver);
         this.mProperties = {};
         this.mProperties.currentStatus = Components.results.NS_OK;
     },
 
     get observers() {
         return this.mObservers;
@@ -605,52 +605,43 @@ cal.ProviderBase.prototype = {
 
     // readonly attribute boolean canRefresh;
     get canRefresh() {
         return false;
     },
 
     // void startBatch();
     mBatchCount: 0,
-    startBatch: function cPB_startBatch() {
+    startBatch: function() {
         if (this.mBatchCount++ == 0) {
             this.mObservers.notify("onStartBatch");
         }
     },
 
-    endBatch: function cPB_endBatch() {
+    endBatch: function() {
         if (this.mBatchCount > 0) {
             if (--this.mBatchCount == 0) {
                 this.mObservers.notify("onEndBatch");
             }
         } else {
             cal.ASSERT(this.mBatchCount > 0, "unexepcted endBatch!");
         }
     },
 
-    notifyPureOperationComplete: function cPB_notifyPureOperationComplete(aListener,
-                                                                          aStatus,
-                                                                          aOperationType,
-                                                                          aId,
-                                                                          aDetail) {
+    notifyPureOperationComplete: function(aListener, aStatus, aOperationType, aId, aDetail) {
         if (aListener) {
             try {
                 aListener.onOperationComplete(this.superCalendar, aStatus, aOperationType, aId, aDetail);
             } catch (exc) {
                 cal.ERROR(exc);
             }
         }
     },
 
-    notifyOperationComplete: function cPB_notifyOperationComplete(aListener,
-                                                                  aStatus,
-                                                                  aOperationType,
-                                                                  aId,
-                                                                  aDetail,
-                                                                  aExtraMessage) {
+    notifyOperationComplete: function(aListener, aStatus, aOperationType, aId, aDetail, aExtraMessage) {
         this.notifyPureOperationComplete(aListener, aStatus, aOperationType, aId, aDetail);
 
         if (aStatus == Components.interfaces.calIErrors.OPERATION_CANCELLED) {
             return; // cancellation doesn't change current status, no notification
         }
         if (Components.isSuccessCode(aStatus)) {
             this.setProperty("currentStatus", aStatus);
         } else {
@@ -662,17 +653,17 @@ cal.ProviderBase.prototype = {
             this.notifyError(aOperationType == Components.interfaces.calIOperationListener.GET
                              ? Components.interfaces.calIErrors.READ_FAILED
                              : Components.interfaces.calIErrors.MODIFICATION_FAILED,
                              aExtraMessage || "");
         }
     },
 
     // for convenience also callable with just an exception
-    notifyError: function cPB_notifyError(aErrNo, aMessage) {
+    notifyError: function(aErrNo, aMessage) {
         if (aErrNo == Components.interfaces.calIErrors.OPERATION_CANCELLED) {
             return; // cancellation doesn't change current status, no notification
         }
         if (aErrNo instanceof Components.interfaces.nsIException) {
             if (!aMessage) {
                 aMessage = aErrNo.message;
             }
             aErrNo = aErrNo.result;
@@ -685,17 +676,17 @@ cal.ProviderBase.prototype = {
     get transientProperties() {
         return this.mTransientPropertiesMode;
     },
     set transientProperties(value) {
         return (this.mTransientPropertiesMode = value);
     },
 
     // nsIVariant getProperty(in AUTF8String aName);
-    getProperty: function cPB_getProperty(aName) {
+    getProperty: function(aName) {
         switch (aName) {
             case "itip.transport": // iTIP/iMIP default:
                 return cal.getImipTransport(this);
             case "itip.notify-replies": // iTIP/iMIP default:
                  return Preferences.get("calendar.itip.notify-replies", false);
             // temporary hack to get the uncached calendar instance:
             case "cache.uncachedCalendar":
                 return this;
@@ -749,17 +740,17 @@ cal.ProviderBase.prototype = {
             }
             this.mProperties[aName] = ret;
         }
 //         cal.LOG("getProperty(\"" + aName + "\"): " + ret);
         return ret;
     },
 
     // void setProperty(in AUTF8String aName, in nsIVariant aValue);
-    setProperty: function cPB_setProperty(aName, aValue) {
+    setProperty: function(aName, aValue) {
         let oldValue = this.getProperty(aName);
         if (oldValue != aValue) {
             this.mProperties[aName] = aValue;
             switch (aName) {
                 case "imip.identity.key": // invalidate identity and account object if key is set:
                     delete this.mProperties["imip.identity"];
                     delete this.mProperties["imip.account"];
                     delete this.mProperties.organizerId;
@@ -773,39 +764,39 @@ cal.ProviderBase.prototype = {
             }
             this.mObservers.notify("onPropertyChanged",
                                    [this.superCalendar, aName, aValue, oldValue]);
         }
         return aValue;
     },
 
     // void deleteProperty(in AUTF8String aName);
-    deleteProperty: function cPB_deleteProperty(aName) {
+    deleteProperty: function(aName) {
         this.mObservers.notify("onPropertyDeleting", [this.superCalendar, aName]);
         delete this.mProperties[aName];
         cal.getCalendarManager().deleteCalendarPref_(this, aName);
     },
 
     // calIOperation refresh
-    refresh: function cPB_refresh() {
+    refresh: function() {
         return null;
     },
 
     // void addObserver( in calIObserver observer );
-    addObserver: function cPB_addObserver(aObserver) {
+    addObserver: function(aObserver) {
         this.mObservers.add(aObserver);
     },
 
     // void removeObserver( in calIObserver observer );
-    removeObserver: function cPB_removeObserver(aObserver) {
+    removeObserver: function(aObserver) {
         this.mObservers.remove(aObserver);
     },
 
     // calISchedulingSupport: Implementation corresponding to our iTIP/iMIP support
-    isInvitation: function cPB_isInvitation(aItem) {
+    isInvitation: function(aItem) {
         if (!this.mACLEntry || !this.mACLEntry.hasAccessControl) {
             // No ACL support - fallback to the old method
             let id = this.getProperty("organizerId");
             if (id) {
                 let org = aItem.organizer;
                 if (!org || !org.id || (org.id.toLowerCase() == id.toLowerCase())) {
                     return false;
                 }
@@ -842,17 +833,17 @@ cal.ProviderBase.prototype = {
             if (aItem.getAttendeeById(identity) != null) {
                 return true;
             }
         }
 
         return false;
     },
 
-    getInvitedAttendee: function cPB_getInvitedAttendee(aItem) {
+    getInvitedAttendee: function(aItem) {
         let id = this.getProperty("organizerId");
         let attendee = (id ? aItem.getAttendeeById(id) : null);
 
         if (!attendee && this.mACLEntry && this.mACLEntry.hasAccessControl) {
             let ownerIdentities = this.mACLEntry.getOwnerIdentities({});
             if (ownerIdentities.length > 0) {
                 let identity;
                 for (let i = 0; !attendee && i < ownerIdentities.length; i++) {
@@ -860,12 +851,12 @@ cal.ProviderBase.prototype = {
                     attendee = aItem.getAttendeeById(identity);
                 }
             }
         }
 
         return attendee;
     },
 
-    canNotify: function cPB_canNotify(aMethod, aItem) {
+    canNotify: function(aMethod, aItem) {
         return false; // use outbound iTIP for all
     }
 };
--- a/calendar/base/modules/calUtils.jsm
+++ b/calendar/base/modules/calUtils.jsm
@@ -26,17 +26,17 @@ var cal = {
 
     /**
      * Loads an array of calendar scripts into the passed scope.
      *
      * @param scriptNames an array of calendar script names
      * @param scope       scope to load into
      * @param baseDir     base dir; defaults to calendar-js/
      */
-    loadScripts: function cal_loadScripts(scriptNames, scope, baseDir) {
+    loadScripts: function(scriptNames, scope, baseDir) {
         if (!baseDir) {
             baseDir = __LOCATION__.parent.parent.clone();
             baseDir.append("calendar-js");
         }
 
         for (let script of scriptNames) {
             if (!script) {
                 // If the array element is null, then just skip this script.
@@ -49,33 +49,33 @@ var cal = {
                 Services.scriptloader.loadSubScript(scriptUrlSpec, scope);
             } catch (exc) {
                 Components.utils.reportError(exc + " (" + scriptUrlSpec + ")");
             }
         }
     },
 
     loadingNSGetFactory: function(scriptNames, components, scope) {
-        return function NSGetFactory(cid) {
+        return function(cid) {
             if (!this.inner) {
                 let global = Components.utils.getGlobalForObject(scope);
                 cal.loadScripts(scriptNames, global);
                 if (typeof components == "function") {
                     components = components.call(global);
                 }
                 this.inner = XPCOMUtils.generateNSGetFactory(components);
             }
             return this.inner(cid);
         };
     },
 
     /**
      * Schedules execution of the passed function to the current thread's queue.
      */
-    postPone: function cal_postPone(func) {
+    postPone: function(func) {
         if (this.threadingEnabled) {
             Services.tm.currentThread.dispatch({ run: func },
                                                Components.interfaces.nsIEventTarget.DISPATCH_NORMAL);
         } else {
             func();
         }
     },
 
@@ -90,17 +90,17 @@ var cal = {
      *                    clean adapter.
      *
      * Currently supported interfaces are:
      *  - calIObserver
      *  - calICalendarManagerObserver
      *  - calIOperationListener
      *  - calICompositeObserver
      */
-    createAdapter: function createAdapter(iface, template) {
+    createAdapter: function(iface, template) {
         let methods;
         let adapter = template || {};
         switch (iface.name || iface) {
             case "calIObserver":
                 methods = ["onStartBatch", "onEndBatch", "onLoad", "onAddItem",
                            "onModifyItem", "onDeleteItem", "onError",
                            "onPropertyChanged", "onPropertyDeleting"];
                 break;
@@ -137,43 +137,43 @@ var cal = {
         return gCalThreadingEnabled;
     },
 
     /*
      * Checks whether a calendar supports events
      *
      * @param aCalendar
      */
-    isEventCalendar: function cal_isEventCalendar(aCalendar) {
+    isEventCalendar: function(aCalendar) {
         return (aCalendar.getProperty("capabilities.events.supported") !== false);
     },
 
     /*
      * Checks whether a calendar supports tasks
      *
      * @param aCalendar
      */
-    isTaskCalendar: function cal_isTaskCalendar(aCalendar) {
+    isTaskCalendar: function(aCalendar) {
         return (aCalendar.getProperty("capabilities.tasks.supported") !== false);
     },
 
     /**
      * Checks whether a timezone lacks a definition.
      */
-    isPhantomTimezone: function cal_isPhantomTimezone(tz) {
+    isPhantomTimezone: function(tz) {
         return (!tz.icalComponent && !tz.isUTC && !tz.isFloating);
     },
 
     /**
      * Shifts an item by the given timely offset.
      *
      * @param item an item
      * @param offset an offset (calIDuration)
      */
-    shiftItem: function cal_shiftItem(item, offset) {
+    shiftItem: function(item, offset) {
         // When modifying dates explicitly using the setters is important
         // since those may triggers e.g. calIRecurrenceInfo::onStartDateChange
         // or invalidate other properties. Moreover don't modify the date-time objects
         // without cloning, because changes cannot be calculated if doing so.
         if (cal.isEvent(item)) {
             let date = item.startDate.clone();
             date.addDuration(offset);
             item.startDate = date;
@@ -221,27 +221,27 @@ var cal = {
             item = item.makeImmutable();
         }
         return item;
     },
 
     /**
      * Shortcut function to serialize an item (including all overridden items).
      */
-    getSerializedItem: function cal_getSerializedItem(aItem) {
+    getSerializedItem: function(aItem) {
         let serializer = Components.classes["@mozilla.org/calendar/ics-serializer;1"]
                                    .createInstance(Components.interfaces.calIIcsSerializer);
         serializer.addItems([aItem], 1);
         return serializer.serializeToString();
     },
 
     /**
      * Shortcut function to check whether an item is an invitation copy.
      */
-    isInvitation: function cal_isInvitation(aItem) {
+    isInvitation: function(aItem) {
         let isInvitation = false;
         let calendar = cal.wrapInstance(aItem.calendar, Components.interfaces.calISchedulingSupport);
         if (calendar) {
             isInvitation = calendar.isInvitation(aItem);
         }
         return isInvitation;
     },
 
@@ -301,17 +301,17 @@ var cal = {
     },
 
     /**
      * Shortcut function to check whether an item is an invitation copy and
      * has a participation status of either NEEDS-ACTION or TENTATIVE.
      *
      * @param aItem either calIAttendee or calIItemBase
      */
-    isOpenInvitation: function cal_isOpenInvitation(aItem) {
+    isOpenInvitation: function(aItem) {
         let wrappedItem = cal.wrapInstance(aItem, Components.interfaces.calIAttendee);
         if (!wrappedItem) {
             aItem = cal.getInvitedAttendee(aItem);
         }
         if (aItem) {
             switch (aItem.participationStatus) {
                 case "NEEDS-ACTION":
                 case "TENTATIVE":
@@ -377,17 +377,17 @@ var cal = {
             delegatees: delegatees.join(", "),
             delegators: delegators.join(", ")
         };
     },
 
     /**
      * Shortcut function to get the invited attendee of an item.
      */
-    getInvitedAttendee: function cal_getInvitedAttendee(aItem, aCalendar) {
+    getInvitedAttendee: function(aItem, aCalendar) {
         if (!aCalendar) {
             aCalendar = aItem.calendar;
         }
         let invitedAttendee = null;
         let calendar = cal.wrapInstance(aCalendar, Components.interfaces.calISchedulingSupport);
         if (calendar) {
             invitedAttendee = calendar.getInvitedAttendee(aItem);
         }
@@ -458,116 +458,116 @@ var cal = {
                      : "OPAQUE";
         }
         return transp;
     },
 
     // The below functions will move to some different place once the
     // unifinder tress are consolidated.
 
-    compareNativeTime: function cal_compareNativeTime(a, b) {
+    compareNativeTime: function(a, b) {
       if (a < b) {
         return -1;
       } else if (a > b) {
         return 1;
       } else {
         return 0;
       }
     },
 
-    compareNativeTimeFilledAsc: function cal_compareNativeTimeFilledAsc(a, b) {
+    compareNativeTimeFilledAsc: function(a, b) {
       if (a == b) {
         return 0;
       }
 
       // In this filter, a zero time (not set) is always at the end.
       if (a == -62168601600000000) { // value for (0000/00/00 00:00:00)
         return 1;
       }
       if (b == -62168601600000000) { // value for (0000/00/00 00:00:00)
         return -1;
       }
 
       return (a < b ? -1 : 1);
     },
 
-    compareNativeTimeFilledDesc: function cal_compareNativeTimeFilledDesc(a, b) {
+    compareNativeTimeFilledDesc: function(a, b) {
       if (a == b) {
         return 0;
       }
 
       // In this filter, a zero time (not set) is always at the end.
       if (a == -62168601600000000) { // value for (0000/00/00 00:00:00)
         return 1;
       }
       if (b == -62168601600000000) { // value for (0000/00/00 00:00:00)
         return -1;
       }
 
       return (a < b ? 1 : -1);
     },
 
-    compareNumber: function cal_compareNumber(a, b) {
+    compareNumber: function(a, b) {
       a = Number(a);
       b = Number(b);
       if (a < b) {
         return -1;
       } else if (a > b) {
         return 1;
       } else {
         return 0;
       }
     },
 
-    sortEntryComparer: function cal_sortEntryComparer(sortType, modifier) {
+    sortEntryComparer: function(sortType, modifier) {
       switch (sortType) {
         case "number":
-          return function compareNumbers(sortEntryA, sortEntryB) {
+          return function(sortEntryA, sortEntryB) {
             let nsA = cal.sortEntryKey(sortEntryA);
             let nsB = cal.sortEntryKey(sortEntryB);
             return cal.compareNumber(nsA, nsB) * modifier;
           };
         case "date":
-          return function compareTimes(sortEntryA, sortEntryB) {
+          return function(sortEntryA, sortEntryB) {
             let nsA = cal.sortEntryKey(sortEntryA);
             let nsB = cal.sortEntryKey(sortEntryB);
             return cal.compareNativeTime(nsA, nsB) * modifier;
           };
         case "date_filled":
-          return function compareTimesFilled(sortEntryA, sortEntryB) {
+          return function(sortEntryA, sortEntryB) {
             let nsA = cal.sortEntryKey(sortEntryA);
             let nsB = cal.sortEntryKey(sortEntryB);
             if (modifier == 1) {
               return cal.compareNativeTimeFilledAsc(nsA, nsB);
             } else {
               return cal.compareNativeTimeFilledDesc(nsA, nsB);
             }
           };
         case "string":
-          return function compareStrings(sortEntryA, sortEntryB) {
+          return function(sortEntryA, sortEntryB) {
             let sA = cal.sortEntryKey(sortEntryA);
             let sB = cal.sortEntryKey(sortEntryB);
             if (sA.length == 0 || sB.length == 0) {
               // sort empty values to end (so when users first sort by a
               // column, they can see and find the desired values in that
               // column without scrolling past all the empty values).
               return -(sA.length - sB.length) * modifier;
             }
             let collator = cal.createLocaleCollator();
             let comparison = collator.compareString(0, sA, sB);
             return comparison * modifier;
           };
         default:
-          return function compareOther(sortEntryA, sortEntryB) {
+          return function(sortEntryA, sortEntryB) {
             return 0;
           };
       }
     },
 
-    getItemSortKey: function cal_getItemSortKey(aItem, aKey, aStartTime) {
+    getItemSortKey: function(aItem, aKey, aStartTime) {
       switch (aKey) {
         case "priority":
           return aItem.priority || 5;
 
         case "title":
           return aItem.title || "";
 
         case "entryDate":
@@ -603,17 +603,17 @@ var cal = {
         case "calendar":
           return aItem.calendar.name || "";
 
         default:
           return null;
       }
     },
 
-    getSortTypeForSortKey: function cal_getSortTypeForSortKey(aSortKey) {
+    getSortTypeForSortKey: function(aSortKey) {
       switch (aSortKey) {
         case "title":
         case "categories":
         case "location":
         case "calendar":
           return "string";
 
         // All dates use "date_filled"
@@ -628,30 +628,30 @@ var cal = {
         case "percentComplete":
         case "status":
           return "number";
         default:
           return "unknown";
       }
     },
 
-    nativeTimeOrNow: function cal_nativeTimeOrNow(calDateTime, sortStartedTime) {
+    nativeTimeOrNow: function(calDateTime, sortStartedTime) {
         // Treat null/0 as 'now' when sort started, so incomplete tasks stay current.
         // Time is computed once per sort (just before sort) so sort is stable.
         if (calDateTime == null) {
             return sortStartedTime.nativeTime;
         }
         let ns = calDateTime.nativeTime;
         if (ns == -62168601600000000) { // ns value for (0000/00/00 00:00:00)
             return sortStartedTime;
         }
         return ns;
     },
 
-    nativeTime: function cal_nativeTime(calDateTime) {
+    nativeTime: function(calDateTime) {
         if (calDateTime == null) {
             return -62168601600000000; // ns value for (0000/00/00 00:00:00)
         }
         return calDateTime.nativeTime;
     },
 
     /**
      * Returns a calIDateTime corresponding to a javascript Date.
@@ -660,17 +660,17 @@ var cal = {
      * @param aTimezone (optional) a timezone that should be enforced
      * @returns         a calIDateTime
      *
      * @warning  Use of this function is strongly discouraged.  calIDateTime should
      *           be used directly whenever possible.
      *           If you pass a timezone, then the passed jsDate's timezone will be ignored,
      *           but only its local time portions are be taken.
      */
-    jsDateToDateTime: function jsDateToDateTime(aDate, aTimezone) {
+    jsDateToDateTime: function(aDate, aTimezone) {
         let newDate = cal.createDateTime();
         if (aTimezone) {
             newDate.resetTo(aDate.getFullYear(),
                             aDate.getMonth(),
                             aDate.getDate(),
                             aDate.getHours(),
                             aDate.getMinutes(),
                             aDate.getSeconds(),
@@ -692,54 +692,54 @@ var cal = {
         if (cdt.timezone.isFloating) {
             return new Date(cdt.year, cdt.month, cdt.day,
                             cdt.hour, cdt.minute, cdt.second);
         } else {
             return new Date(cdt.nativeTime / 1000);
         }
     },
 
-    sortEntry: function cal_sortEntry(aItem) {
+    sortEntry: function(aItem) {
         let key = cal.getItemSortKey(aItem, this.mSortKey, this.mSortStartedDate);
         return { mSortKey: key, mItem: aItem };
     },
 
-    sortEntryItem: function cal_sortEntryItem(sortEntry) {
+    sortEntryItem: function(sortEntry) {
         return sortEntry.mItem;
     },
 
-    sortEntryKey: function cal_sortEntryKey(sortEntry) {
+    sortEntryKey: function(sortEntry) {
         return sortEntry.mSortKey;
     },
 
-    createLocaleCollator: function cal_createLocaleCollator() {
+    createLocaleCollator: function() {
         return Components.classes["@mozilla.org/intl/collation-factory;1"]
                          .getService(Components.interfaces.nsICollationFactory)
                          .CreateCollation(Services.locale.getApplicationLocale());
      },
 
     /**
      * Sort an array of strings according to the current locale.
      * Modifies aStringArray, returning it sorted.
      */
-    sortArrayByLocaleCollator: function cal_sortArrayByLocaleCollator(aStringArray) {
+    sortArrayByLocaleCollator: function(aStringArray) {
         let localeCollator = cal.createLocaleCollator();
         function compare(a, b) { return localeCollator.compareString(0, a, b); }
         aStringArray.sort(compare);
         return aStringArray;
     },
 
     /**
      * Gets the month name string in the right form depending on a base string.
      *
      * @param aMonthNum     The month numer to get, 1-based.
      * @param aBundleName   The Bundle to get the string from
      * @param aStringBase   The base string name, .monthFormat will be appended
      */
-    formatMonth: function formatMonth(aMonthNum, aBundleName, aStringBase) {
+    formatMonth: function(aMonthNum, aBundleName, aStringBase) {
         let monthForm = cal.calGetString(aBundleName, aStringBase + ".monthFormat") || "nominative";
 
         if (monthForm == "nominative") {
             // Fall back to the default name format
             monthForm = "name";
         }
 
         return cal.calGetString("dateFormat", "month." + aMonthNum + "." + monthForm);
@@ -747,17 +747,17 @@ var cal = {
 
     /**
      * moves an item to another startDate
      *
      * @param aOldItem             The Item to be modified
      * @param aNewDate             The date at which the new item is going to start
      * @return                     The modified item
      */
-    moveItem: function cal_moveItem(aOldItem, aNewDate) {
+    moveItem: function(aOldItem, aNewDate) {
         let newItem = aOldItem.clone();
         let start = (aOldItem[calGetStartDateProp(aOldItem)] ||
                      aOldItem[calGetEndDateProp(aOldItem)]).clone();
         let isDate = start.isDate;
         start.resetTo(aNewDate.year, aNewDate.month, aNewDate.day,
                       start.hour, start.minute, start.second,
                       start.timezone);
         start.isDate = isDate;
@@ -779,17 +779,17 @@ var cal = {
 
     /**
      * sets the 'isDate' property of an item
      *
      * @param aItem         The Item to be modified
      * @param aIsDate       True or false indicating the new value of 'isDate'
      * @return              The modified item
      */
-    setItemToAllDay: function cal_setItemToAllDay(aItem, aIsDate) {
+    setItemToAllDay: function(aItem, aIsDate) {
         let start = aItem[calGetStartDateProp(aItem)];
         let end = aItem[calGetEndDateProp(aItem)];
         if (start || end) {
             let item = aItem.clone();
             if (start && (start.isDate != aIsDate)) {
                start = start.clone();
                start.isDate = aIsDate;
                item[calGetStartDateProp(item)] = start;
@@ -808,17 +808,17 @@ var cal = {
     /**
      * checks if the mousepointer of an event resides over a XULBox during an event
      *
      * @param aMouseEvent   The event eg. a 'mouseout' or 'mousedown' event
      * @param aXULBox       The xul element
      * @return              true or false depending on whether the mouse pointer
      *                      resides over the xulelement
      */
-    isMouseOverBox: function cal_isMouseOverBox(aMouseEvent, aXULElement) {
+    isMouseOverBox: function(aMouseEvent, aXULElement) {
         let boxObject = aXULElement.boxObject;
         let boxWidth = boxObject.width;
         let boxHeight = boxObject.height;
         let boxScreenX = boxObject.screenX;
         let boxScreenY = boxObject.screenY;
         let mouseX = aMouseEvent.screenX;
         let mouseY = aMouseEvent.screenY;
         let xIsWithin = (mouseX >= boxScreenX) &&
@@ -830,17 +830,17 @@ var cal = {
 
     /**
      * removes those childnodes from a node that contain a specified attribute
      * and where the value of this attribute matches a passed value
      * @param aParentNode   The parent node that contains the child nodes in question
      * @param aAttribute    The name of the attribute
      * @param aAttribute    The value of the attribute
      */
-    removeChildElementsByAttribute: function removeChildElementsByAttribute(aParentNode, aAttribute, aValue) {
+    removeChildElementsByAttribute: function(aParentNode, aAttribute, aValue) {
         let childNode = aParentNode.lastChild;
         while (childNode) {
             let prevChildNode = childNode.previousSibling;
             if (!aAttribute || aAttribute === undefined) {
                 childNode.remove();
              } else if (!aValue || aValue === undefined) {
                 childNode.remove();
             } else if (childNode && childNode.hasAttribute(aAttribute) &&
@@ -849,31 +849,31 @@ var cal = {
             }
             childNode = prevChildNode;
         }
     },
 
     /**
      * Returns the most recent calendar window in an application independent way
      */
-    getCalendarWindow: function cal_getCalendarWindow() {
+    getCalendarWindow: function() {
         return Services.wm.getMostRecentWindow("calendarMainWindow") ||
                Services.wm.getMostRecentWindow("mail:3pane");
     },
 
     /**
      * Adds an observer listening for the topic.
      *
      * @param func function to execute on topic
      * @param topic topic to listen for
      * @param oneTime whether to listen only once
      */
-    addObserver: function cal_addObserver(func, topic, oneTime) {
+    addObserver: function(func, topic, oneTime) {
         let observer = { // nsIObserver:
-            observe: function cal_addObserver_observe(subject, topic_, data) {
+            observe: function(subject, topic_, data) {
                 if (topic == topic_) {
                     if (oneTime) {
                         Services.obs.removeObserver(this, topic);
                     }
                     func(subject, topic, data);
                 }
             }
         };
@@ -895,34 +895,34 @@ var cal = {
      * }
      * // GOOD USAGE:
      * foo = cal.wrapInstance(foo, Ci.nsIBar);
      * if (foo) {
      *   foo.barMethod();
      *   }
      *
      */
-    wrapInstance: function wrapInstance(aObj, aInterface) {
+    wrapInstance: function(aObj, aInterface) {
         if (!aObj) {
             return null;
         }
 
         try {
             return aObj.QueryInterface(aInterface);
         } catch (e) {
             return null;
         }
     },
 
     /**
      * Adds an xpcom shutdown observer.
      *
      * @param func function to execute
      */
-    addShutdownObserver: function cal_addShutdownObserver(func) {
+    addShutdownObserver: function(func) {
         cal.addObserver(func, "xpcom-shutdown", true /* one time */);
     },
 
     /**
      * Due to wrapped js objects, some objects may have cyclic references.
      * You can register properties of objects to be cleaned up on xpcom-shutdown.
      *
      * @param obj    object
@@ -950,16 +950,17 @@ function shutdownCleanup(obj, prop) {
             });
     }
     shutdownCleanup.mEntries.push({ mObj: obj, mProp: prop });
 }
 
 // local to this module;
 // will be used to generate service accessor functions
 function generateServiceAccessor(id, iface) {
+    // eslint-disable-next-line func-names
     return function this_() {
         if (!("mService" in this_)) {
             this_.mService = Components.classes[id].getService(iface);
             shutdownCleanup(this_, "mService");
         }
         return this_.mService;
     };
 }
--- a/calendar/base/modules/calXMLUtils.jsm
+++ b/calendar/base/modules/calXMLUtils.jsm
@@ -18,17 +18,17 @@ cal.xml = {} || cal.xml;
  * - an array of strings or DOM elements
  *
  * @param aNode     The context node to search from
  * @param aExpr     The XPath expression to search for
  * @param aResolver (optional) The namespace resolver to use for the expression
  * @param aType     (optional) Force a result type, must be an XPathResult constant
  * @return          The result, see above for details.
  */
-cal.xml.evalXPath = function evaluateXPath(aNode, aExpr, aResolver, aType) {
+cal.xml.evalXPath = function(aNode, aExpr, aResolver, aType) {
     const XPR = Components.interfaces.nsIDOMXPathResult;
     let doc = (aNode.ownerDocument ? aNode.ownerDocument : aNode);
     let resolver = aResolver || doc.createNSResolver(doc.documentElement);
     let resultType = aType || XPR.ANY_TYPE;
 
     let result = doc.evaluate(aExpr, aNode, resolver, resultType, null);
     let returnResult, next;
     switch (result.resultType) {
@@ -93,17 +93,17 @@ cal.xml.evalXPath = function evaluateXPa
  * - A string, number, boolean or DOM Element value
  *
  * @param aNode     The context node to search from
  * @param aExpr     The XPath expression to search for
  * @param aResolver (optional) The namespace resolver to use for the expression
  * @param aType     (optional) Force a result type, must be an XPathResult constant
  * @return          The result, see above for details.
  */
-cal.xml.evalXPathFirst = function evalXPathFirst(aNode, aExpr, aResolver, aType) {
+cal.xml.evalXPathFirst = function(aNode, aExpr, aResolver, aType) {
     let result = cal.xml.evalXPath(aNode, aExpr, aResolver, aType);
 
     if (Array.isArray(result)) {
         return result[0];
     } else {
         return result;
     }
 };
@@ -155,17 +155,17 @@ cal.xml.serializeDOM = function(doc) {
 
 /**
  * Escape a string for use in XML
  *
  * @param str           The string to escape
  * @param isAttribute   If true, " and ' are also escaped
  * @return              The escaped string
  */
-cal.xml.escapeString = function escapeString(str, isAttribute) {
+cal.xml.escapeString = function(str, isAttribute) {
     return str.replace(/[&<>'"]/g, function(chr) {
         switch (chr) {
             case "&": return "&amp;";
             case "<": return "&lt;";
             case ">": return "&gt;";
             case '"': return (isAttribute ? "&quot;" : chr);
             case "'": return (isAttribute ? "&apos;" : chr);
             default: return chr;
--- a/calendar/base/src/calAlarm.js
+++ b/calendar/base/src/calAlarm.js
@@ -45,27 +45,27 @@ calAlarm.prototype = {
         classDescription: "Describes a VALARM",
         interfaces: calAlarmInterfaces
     }),
 
     /**
      * calIAlarm
      */
 
-    ensureMutable: function cA_ensureMutable() {
+    ensureMutable: function() {
         if (this.mImmutable) {
             throw Components.results.NS_ERROR_OBJECT_IS_IMMUTABLE;
         }
     },
 
     get isMutable() {
         return !this.mImmutable;
     },
 
-    makeImmutable: function cA_makeImmutable() {
+    makeImmutable: function() {
         if (this.mImmutable) {
             return;
         }
 
         const objectMembers = ["mAbsoluteDate",
                                "mOffset",
                                "mDuration",
                                "mLastAck"];
@@ -85,17 +85,17 @@ calAlarm.prototype = {
                     prop.value.makeImmutable();
                 }
             }
         }
 
         this.mImmutable = true;
     },
 
-    clone: function cA_clone() {
+    clone: function() {
         let m = new calAlarm();
 
         m.mImmutable = false;
 
         const simpleMembers = ["mAction",
                                "mSummary",
                                "mDescription",
                                "mRelated",
@@ -274,93 +274,93 @@ calAlarm.prototype = {
         let alarmDate = this.mAbsoluteDate.clone();
 
         // All Day events are handled as 00:00:00
         alarmDate.isDate = false;
         alarmDate.addDuration(this.mDuration);
         return alarmDate;
     },
 
-    getAttendees: function getAttendees(aCount) {
+    getAttendees: function(aCount) {
         let attendees;
         if (this.action == "AUDIO" || this.action == "DISPLAY") {
             attendees = [];
         } else {
             attendees = this.mAttendees.concat([]);
         }
         aCount.value = attendees.length;
         return attendees;
     },
 
-    addAttendee: function addAttendee(aAttendee) {
+    addAttendee: function(aAttendee) {
         // Make sure its not duplicate
         this.deleteAttendee(aAttendee);
 
         // Now check if its valid
         if (this.action == "AUDIO" || this.action == "DISPLAY") {
             throw new Error("Alarm type AUDIO/DISPLAY may not have attendees");
         }
 
         // And add it (again)
         this.mAttendees.push(aAttendee);
     },
 
-    deleteAttendee: function deleteAttendee(aAttendee) {
+    deleteAttendee: function(aAttendee) {
         let deleteId = aAttendee.id;
         for (let i = 0; i < this.mAttendees.length; i++) {
             if (this.mAttendees[i].id == deleteId) {
                 this.mAttendees.splice(i, 1);
                 break;
             }
         }
     },
 
-    clearAttendees: function clearAttendees() {
+    clearAttendees: function() {
         this.mAttendees = [];
     },
 
-    getAttachments: function getAttachments(aCount) {
+    getAttachments: function(aCount) {
         let attachments;
         if (this.action == "AUDIO") {
             attachments = (this.mAttachments.length ? [this.mAttachments[0]] : []);
         } else if (this.action == "DISPLAY") {
             attachments = [];
         } else {
             attachments = this.mAttachments.concat([]);
         }
         aCount.value = attachments.length;
         return attachments;
     },
 
-    addAttachment: function addAttachment(aAttachment) {
+    addAttachment: function(aAttachment) {
         // Make sure its not duplicate
         this.deleteAttachment(aAttachment);
 
         // Now check if its valid
         if (this.action == "AUDIO" && this.mAttachments.length) {
             throw new Error("Alarm type AUDIO may only have one attachment");
         } else if (this.action == "DISPLAY") {
             throw new Error("Alarm type DISPLAY may not have attachments");
         }
 
         // And add it (again)
         this.mAttachments.push(aAttachment);
     },
 
-    deleteAttachment: function deleteAttachment(aAttachment) {
+    deleteAttachment: function(aAttachment) {
         let deleteHash = aAttachment.hashId;
         for (let i = 0; i < this.mAttachments.length; i++) {
             if (this.mAttachments[i].hashId == deleteHash) {
                 this.mAttachments.splice(i, 1);
                 break;
             }
         }
     },
 
-    clearAttachments: function clearAttachments() {
+    clearAttachments: function() {
         this.mAttachments = [];
     },
 
     get icalString() {
         let comp = this.icalComponent;
         return (comp ? comp.serializeToICS() : "");
     },
     set icalString(val) {
@@ -577,55 +577,55 @@ calAlarm.prototype = {
                     }
                     this.mPropertyParams[prop.propertyName][paramName] = param;
                 }
             }
         }
         return aComp;
     },
 
-    hasProperty: function cA_hasProperty(aName) {
+    hasProperty: function(aName) {
         return (this.getProperty(aName.toUpperCase()) != null);
     },
 
-    getProperty: function cA_getProperty(aName) {
+    getProperty: function(aName) {
         let name = aName.toUpperCase();
         if (name in this.promotedProps) {
             return this[this.promotedProps[name]];
         } else {
             return this.mProperties.getProperty(name);
         }
     },
 
-    setProperty: function cA_setProperty(aName, aValue) {
+    setProperty: function(aName, aValue) {
         this.ensureMutable();
         let name = aName.toUpperCase();
         if (name in this.promotedProps) {
             this[this.promotedProps[name]] = aValue;
         } else {
             this.mProperties.setProperty(name, aValue);
         }
         return aValue;
     },
 
-    deleteProperty: function cA_deleteProperty(aName) {
+    deleteProperty: function(aName) {
         this.ensureMutable();
         let name = aName.toUpperCase();
         if (name in this.promotedProps) {
             this[this.promotedProps[name]] = null;
         } else {
             this.mProperties.deleteProperty(name);
         }
     },
 
     get propertyEnumerator() {
         return this.mProperties.enumerator;
     },
 
-    toString: function cA_toString(aItem) {
+    toString: function(aItem) {
         function getItemBundleStringName(aPrefix) {
             if (!aItem || isEvent(aItem)) {
                 return aPrefix + "Event";
             } else if (isToDo(aItem)) {
                 return aPrefix + "Task";
             } else {
                 return aPrefix;
             }
--- a/calendar/base/src/calAlarmMonitor.js
+++ b/calendar/base/src/calAlarmMonitor.js
@@ -48,33 +48,33 @@ calAlarmMonitor.prototype = {
         classID: calAlarmMonitorClassID,
         interfaces: calAlarmMonitorInterfaces,
         flags: Components.interfaces.nsIClassInfo.SINGLETON
     }),
 
     /**
      * nsIObserver
      */
-    observe: function cAM_observe(aSubject, aTopic, aData) {
+    observe: function(aSubject, aTopic, aData) {
         let alarmService = Components.classes["@mozilla.org/calendar/alarm-service;1"]
                                      .getService(Components.interfaces.calIAlarmService);
         switch (aTopic) {
             case "alarm-service-startup":
                 alarmService.addObserver(this);
                 break;
             case "alarm-service-shutdown":
                 alarmService.removeObserver(this);
                 break;
         }
     },
 
     /**
      * calIAlarmServiceObserver
      */
-    onAlarm: function cAM_onAlarm(aItem, aAlarm) {
+    onAlarm: function(aItem, aAlarm) {
         if (aAlarm.action != "DISPLAY") {
             // This monitor only looks for DISPLAY alarms.
             return;
         }
 
         this.mAlarms.push([aItem, aAlarm]);
 
         if (Preferences.get("calendar.alarms.playsound", true)) {
@@ -127,55 +127,55 @@ calAlarmMonitor.prototype = {
                 "chrome,dialog=yes,all,resizable",
                 this);
         }
         if (!this.mWindowOpening) {
             calAlarmWindow.addWidgetFor(aItem, aAlarm);
         }
     },
 
-    window_onLoad: function cAM_window_onLoad() {
+    window_onLoad: function() {
         let calAlarmWindow = this.mWindowOpening;
         this.mWindowOpening = null;
         if (this.mAlarms.length > 0) {
             for (let [item, alarm] of this.mAlarms) {
                 calAlarmWindow.addWidgetFor(item, alarm);
             }
         } else {
             // Uh oh, it seems the alarms were removed even before the window
             // finished loading. Looks like we can close it again
             calAlarmWindow.closeIfEmpty();
         }
     },
 
-    onRemoveAlarmsByItem: function cAM_onRemoveAlarmsByItem(aItem) {
+    onRemoveAlarmsByItem: function(aItem) {
         let calAlarmWindow = peekAlarmWindow();
         this.mAlarms = this.mAlarms.filter(function(itemAlarm) {
             let [thisItem, alarm] = itemAlarm;
             let ret = (aItem.hashId != thisItem.hashId);
             if (!ret && calAlarmWindow) { // window is open
                 calAlarmWindow.removeWidgetFor(thisItem, alarm);
             }
             return ret;
         });
     },
 
-    onRemoveAlarmsByCalendar: function cAM_onRemoveAlarmsByCalendar(calendar) {
+    onRemoveAlarmsByCalendar: function(calendar) {
         let calAlarmWindow = peekAlarmWindow();
         this.mAlarms = this.mAlarms.filter(function(itemAlarm) {
             let [thisItem, alarm] = itemAlarm;
             let ret = (calendar.id != thisItem.calendar.id);
 
             if (!ret && calAlarmWindow) { // window is open
                 calAlarmWindow.removeWidgetFor(thisItem, alarm);
             }
             return ret;
         });
     },
 
-    onAlarmsLoaded: function cAM_onAlarmsLoaded(aCalendar) {
+    onAlarmsLoaded: function(aCalendar) {
         // the alarm dialog won't close while alarms are loading, check again now
         let calAlarmWindow = peekAlarmWindow();
         if (calAlarmWindow && this.mAlarms.length == 0) {
             calAlarmWindow.closeIfEmpty();
         }
     }
 };
--- a/calendar/base/src/calAlarmService.js
+++ b/calendar/base/src/calAlarmService.js
@@ -36,17 +36,17 @@ function calAlarmService() {
     this.calendarObserver = {
         alarmService: this,
 
         QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIObserver]),
 
         // calIObserver:
         onStartBatch: function() { },
         onEndBatch: function() { },
-        onLoad: function co_onLoad(calendar) {
+        onLoad: function(calendar) {
             // ignore any onLoad events until initial getItems() call of startup has finished:
             if (calendar && this.alarmService.mLoadedCalendars[calendar.id]) {
                 // a refreshed calendar signals that it has been reloaded
                 // (and cannot notify detailed changes), thus reget all alarms of it:
                 this.alarmService.initAlarms([calendar]);
             }
         },
 
@@ -121,17 +121,17 @@ calAlarmService.prototype = {
         classDescription: "Calendar Alarm Service",
         interfaces: calAlarmServiceInterfaces,
         flags: Components.interfaces.nsIClassInfo.SINGLETON
     }),
 
     /**
      * nsIObserver
      */
-    observe: function cAS_observe(aSubject, aTopic, aData) {
+    observe: function(aSubject, aTopic, aData) {
         // This will also be called on app-startup, but nothing is done yet, to
         // prevent unwanted dialogs etc. See bug 325476 and 413296
         if (aTopic == "profile-after-change" || aTopic == "wake_notification") {
             this.shutdown();
             this.startup();
         }
         if (aTopic == "xpcom-shutdown") {
             this.shutdown();
@@ -146,17 +146,17 @@ calAlarmService.prototype = {
         // different than the default timezone?
         return this.mTimezone || calendarDefaultTimezone();
     },
 
     set timezone(aTimezone) {
         return (this.mTimezone = aTimezone);
     },
 
-    snoozeAlarm: function cAS_snoozeAlarm(aItem, aAlarm, aDuration) {
+    snoozeAlarm: function(aItem, aAlarm, aDuration) {
         // Right now we only support snoozing all alarms for the given item for
         // aDuration.
 
         // Make sure we're working with the parent, otherwise we'll accidentally
         // create an exception
         let newEvent = aItem.parentItem.clone();
         let alarmTime = nowUTC();
 
@@ -176,42 +176,42 @@ calAlarmService.prototype = {
         } else {
             newEvent.setProperty("X-MOZ-SNOOZE-TIME", alarmTime.icalString);
         }
         // calling modifyItem will cause us to get the right callback
         // and update the alarm properly
         return newEvent.calendar.modifyItem(newEvent, aItem.parentItem, null);
     },
 
-    dismissAlarm: function cAS_dismissAlarm(aItem, aAlarm) {
+    dismissAlarm: function(aItem, aAlarm) {
         let now = nowUTC();
         // We want the parent item, otherwise we're going to accidentally create an
         // exception.  We've relnoted (for 0.1) the slightly odd behavior this can
         // cause if you move an event after dismissing an alarm
         let oldParent = aItem.parentItem;
         let newParent = oldParent.clone();
         newParent.alarmLastAck = now;
         // Make sure to clear out any snoozes that were here.
         if (aItem.recurrenceId) {
             newParent.deleteProperty("X-MOZ-SNOOZE-TIME-" + aItem.recurrenceId.nativeTime);
         } else {
             newParent.deleteProperty("X-MOZ-SNOOZE-TIME");
         }
         return newParent.calendar.modifyItem(newParent, oldParent, null);
     },
 
-    addObserver: function cAS_addObserver(aObserver) {
+    addObserver: function(aObserver) {
         this.mObservers.add(aObserver);
     },
 
-    removeObserver: function cAS_removeObserver(aObserver) {
+    removeObserver: function(aObserver) {
         this.mObservers.remove(aObserver);
     },
 
-    startup: function cAS_startup() {
+    startup: function() {
         if (this.mStarted) {
             return;
         }
 
         Services.obs.addObserver(this, "profile-after-change", false);
         Services.obs.addObserver(this, "xpcom-shutdown", false);
         Services.obs.addObserver(this, "wake_notification", false);
 
@@ -225,17 +225,17 @@ calAlarmService.prototype = {
 
         for (let calendar of getCalendarManager().getCalendars({})) {
             this.observeCalendar(calendar);
         }
 
         /* set up a timer to update alarms every N hours */
         let timerCallback = {
             alarmService: this,
-            notify: function timer_notify() {
+            notify: function() {
                 let now = nowUTC();
                 let start;
                 if (!this.alarmService.mRangeEnd) {
                     // This is our first search for alarms.  We're going to look for
                     // alarms +/- 1 month from now.  If someone sets an alarm more than
                     // a month ahead of an event, or doesn't start Lightning
                     // for a month, they'll miss some, but that's a slim chance
                     start = now.clone();
@@ -259,17 +259,17 @@ calAlarmService.prototype = {
         };
         timerCallback.notify();
 
         this.mUpdateTimer = newTimerWithCallback(timerCallback, kHoursBetweenUpdates * 3600000, true);
 
         this.mStarted = true;
     },
 
-    shutdown: function cAS_shutdown() {
+    shutdown: function() {
         if (!this.mStarted) {
             return;
         }
 
         /* tell people that we're no longer running */
         let notifier = Components.classes["@mozilla.org/embedcomp/appstartup-notifier;1"]
                                  .getService(Components.interfaces.nsIObserver);
         notifier.observe(null, "alarm-service-shutdown", null);
@@ -291,27 +291,27 @@ calAlarmService.prototype = {
 
         Services.obs.removeObserver(this, "profile-after-change");
         Services.obs.removeObserver(this, "xpcom-shutdown");
         Services.obs.removeObserver(this, "wake_notification");
 
         this.mStarted = false;
     },
 
-    observeCalendar: function cAS_observeCalendar(calendar) {
+    observeCalendar: function(calendar) {
         calendar.addObserver(this.calendarObserver);
     },
 
-    unobserveCalendar: function cAS_unobserveCalendar(calendar) {
+    unobserveCalendar: function(calendar) {
         calendar.removeObserver(this.calendarObserver);
         this.disposeCalendarTimers([calendar]);
         this.mObservers.notify("onRemoveAlarmsByCalendar", [calendar]);
     },
 
-    addAlarmsForItem: function cAS_addAlarmsForItem(aItem) {
+    addAlarmsForItem: function(aItem) {
         if (cal.isToDo(aItem) && aItem.isCompleted) {
             // If this is a task and it is completed, don't add the alarm.
             return;
         }
 
         let showMissed = Preferences.get("calendar.alarms.showmissed", true);
 
         let alarms = aItem.getAlarms({});
@@ -379,70 +379,70 @@ calAlarmService.prototype = {
                 } else {
                     // The alarm was not snoozed or dismissed, fire it now.
                     this.alarmFired(aItem, alarm);
                 }
             }
         }
     },
 
-    removeAlarmsForItem: function cAS_removeAlarmsForItem(aItem) {
+    removeAlarmsForItem: function(aItem) {
         // make sure already fired alarms are purged out of the alarm window:
         this.mObservers.notify("onRemoveAlarmsByItem", [aItem]);
         // Purge alarms specifically for this item (i.e exception)
         for (let alarm of aItem.getAlarms({})) {
             this.removeTimer(aItem, alarm);
         }
     },
 
-    getOccurrencesInRange: function cAS_getOccurrencesInRange(aItem) {
+    getOccurrencesInRange: function(aItem) {
         // We search 1 month in each direction for alarms.  Therefore,
         // we need occurrences between initial start date and 1 month from now
         let until = nowUTC();
         until.month += 1;
 
         if (aItem && aItem.recurrenceInfo) {
             return aItem.recurrenceInfo.getOccurrences(this.mRangeStart, until, 0, {});
         } else {
             return cal.checkIfInRange(aItem, this.mRangeStart, until) ? [aItem] : [];
         }
     },
 
-    addAlarmsForOccurrences: function cAS_addAlarmsForOccurrences(aParentItem) {
+    addAlarmsForOccurrences: function(aParentItem) {
         let occs = this.getOccurrencesInRange(aParentItem);
 
         // Add an alarm for each occurrence
         occs.forEach(this.addAlarmsForItem, this);
     },
 
-    removeAlarmsForOccurrences: function cAS_removeAlarmsForOccurrences(aParentItem) {
+    removeAlarmsForOccurrences: function(aParentItem) {
         let occs = this.getOccurrencesInRange(aParentItem);
 
         // Remove alarm for each occurrence
         occs.forEach(this.removeAlarmsForItem, this);
     },
 
-    addTimer: function cAS_addTimer(aItem, aAlarm, aTimeout) {
+    addTimer: function(aItem, aAlarm, aTimeout) {
         this.mTimerMap[aItem.calendar.id] =
             this.mTimerMap[aItem.calendar.id] || {};
         this.mTimerMap[aItem.calendar.id][aItem.hashId] =
             this.mTimerMap[aItem.calendar.id][aItem.hashId] || {};
 
         let self = this;
         let alarmTimerCallback = {
-            notify: function aTC_notify() {
+            notify: function() {
                 self.alarmFired(aItem, aAlarm);
             }
         };
 
         let timer = newTimerWithCallback(alarmTimerCallback, aTimeout, false);
         this.mTimerMap[aItem.calendar.id][aItem.hashId][aAlarm.icalString] = timer;
     },
 
-    removeTimer: function cAS_removeTimers(aItem, aAlarm) {
+    removeTimer: function(aItem, aAlarm) {
             /* Is the calendar in the timer map */
         if (aItem.calendar.id in this.mTimerMap &&
             /* ...and is the item in the calendar map */
             aItem.hashId in this.mTimerMap[aItem.calendar.id] &&
             /* ...and is the alarm in the item map ? */
             aAlarm.icalString in this.mTimerMap[aItem.calendar.id][aItem.hashId]) {
             // First cancel the existing timer
             let timer = this.mTimerMap[aItem.calendar.id][aItem.hashId][aAlarm.icalString];
@@ -458,43 +458,39 @@ calAlarmService.prototype = {
 
             // If the calendar map is empty, remove it from the timer map
             if (this.mTimerMap[aItem.calendar.id].toSource() == "({})") {
                 delete this.mTimerMap[aItem.calendar.id];
             }
         }
     },
 
-    disposeCalendarTimers: function cAS_removeCalendarTimers(aCalendars) {
+    disposeCalendarTimers: function(aCalendars) {
         for (let calendar of aCalendars) {
             if (calendar.id in this.mTimerMap) {
                 for (let hashId in this.mTimerMap[calendar.id]) {
                     let itemTimerMap = this.mTimerMap[calendar.id][hashId];
                     for (let icalString in itemTimerMap) {
                         let timer = itemTimerMap[icalString];
                         timer.cancel();
                     }
                 }
                 delete this.mTimerMap[calendar.id];
             }
         }
     },
 
-    findAlarms: function cAS_findAlarms(aCalendars, aStart, aUntil) {
+    findAlarms: function(aCalendars, aStart, aUntil) {
         let getListener = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
             alarmService: this,
             addRemovePromise: PromiseUtils.defer(),
             batchCount: 0,
             results: false,
-            onOperationComplete: function cAS_fA_onOperationComplete(aCalendar,
-                                                                     aStatus,
-                                                                     aOperationType,
-                                                                     aId,
-                                                                     aDetail) {
+            onOperationComplete: function(aCalendar, aStatus, aOperationType, aId, aDetail) {
                 this.addRemovePromise.promise.then((aValue) => {
                     // calendar has been loaded, so until now, onLoad events can be ignored:
                     this.alarmService.mLoadedCalendars[aCalendar.id] = true;
 
                     // notify observers that the alarms for the calendar have been loaded
                     this.alarmService.mObservers.notify("onAlarmsLoaded", [aCalendar]);
                 }, (aReason) => {
                     Components.utils.reportError("Promise was rejected: " + aReason);
@@ -502,22 +498,17 @@ calAlarmService.prototype = {
                     this.alarmService.mObservers.notify("onAlarmsLoaded", [aCalendar]);
                 });
 
                 // if no results were returned we still need to resolve the promise
                 if (!this.results) {
                     this.addRemovePromise.resolve();
                 }
             },
-            onGetResult: function cAS_fA_onGetResult(aCalendar,
-                                                     aStatus,
-                                                     aItemType,
-                                                     aDetail,
-                                                     aCount,
-                                                     aItems) {
+            onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
                 let promise = this.addRemovePromise;
                 this.batchCount++;
                 this.results = true;
 
                 cal.forEach(aItems, (item) => {
                     try {
                         this.alarmService.removeAlarmsForItem(item);
                         this.alarmService.addAlarmsForItem(item);
@@ -545,17 +536,17 @@ calAlarmService.prototype = {
                 calendar.getItems(filter, 0, aStart, aUntil, getListener);
             } else {
                 this.mLoadedCalendars[calendar.id] = true;
                 this.mObservers.notify("onAlarmsLoaded", [calendar]);
             }
         }
     },
 
-    initAlarms: function cAS_initAlarms(aCalendars) {
+    initAlarms: function(aCalendars) {
         // Purge out all alarm timers belonging to the refreshed/loaded calendars
         this.disposeCalendarTimers(aCalendars);
 
         // Purge out all alarms from dialog belonging to the refreshed/loaded calendars
         for (let calendar of aCalendars) {
             this.mLoadedCalendars[calendar.id] = false;
             this.mObservers.notify("onRemoveAlarmsByCalendar", [calendar]);
         }
@@ -566,17 +557,17 @@ calAlarmService.prototype = {
         // for a month, they'll miss some, but that's a slim chance
         let start = nowUTC();
         let until = start.clone();
         start.month -= Components.interfaces.calIAlarmService.MAX_SNOOZE_MONTHS;
         until.month += Components.interfaces.calIAlarmService.MAX_SNOOZE_MONTHS;
         this.findAlarms(aCalendars, start, until);
     },
 
-    alarmFired: function cAS_alarmFired(aItem, aAlarm) {
+    alarmFired: function(aItem, aAlarm) {
         if (!aItem.calendar.getProperty("suppressAlarms") &&
             !aItem.calendar.getProperty("disabled") &&
             aItem.getProperty("STATUS") != "CANCELLED") {
             this.mObservers.notify("onAlarm", [aItem, aAlarm]);
         }
     },
 
     get isLoading() {
--- a/calendar/base/src/calAttachment.js
+++ b/calendar/base/src/calAttachment.js
@@ -155,25 +155,25 @@ calAttachment.prototype = {
             return this.mProperties.deleteProperty(aName);
         }
     },
 
     deleteParameter: function(aName) {
         this.mProperties.deleteProperty(aName);
     },
 
-    clone: function cA_clone() {
+    clone: function() {
         let newAttachment = new calAttachment();
         newAttachment.mData = this.mData;
         newAttachment.mHashId = this.mHashId;
         for (let [name, value] of this.mProperties) {
             newAttachment.mProperties.setProperty(name, value);
         }
         return newAttachment;
     },
 
-    setData: function setData(aData) {
+    setData: function(aData) {
         // Sets the data and invalidates the hash so it will be recalculated
         this.mHashId = null;
         this.mData = aData;
         return this.mData;
     }
 };
--- a/calendar/base/src/calAttendee.js
+++ b/calendar/base/src/calAttendee.js
@@ -176,17 +176,17 @@ calAttendee.prototype = {
     },
     set id(aId) {
         this.modify();
         // RFC 1738 para 2.1 says we should be using lowercase mailto: urls
         // we enforce prepending the mailto prefix for email type ids as migration code bug 1199942
         return (this.mId = (aId ? cal.prependMailTo(aId) : null));
     },
 
-    toString: function calAttendee_toString() {
+    toString: function() {
         const emailRE = new RegExp("^mailto:", "i");
         let stringRep = (this.id || "").replace(emailRE, "");
         let commonName = this.commonName;
 
         if (commonName) {
             stringRep = commonName + " <" + stringRep + ">";
         }
 
--- a/calendar/base/src/calCachedCalendar.js
+++ b/calendar/base/src/calCachedCalendar.js
@@ -127,17 +127,17 @@ function calCachedCalendar(uncachedCalen
     this.setupCachedCalendar();
     if (this.supportsChangeLog) {
         uncachedCalendar.offlineStorage = this.mCachedCalendar;
     }
     this.offlineCachedItems = {};
     this.offlineCachedItemFlags = {};
 }
 calCachedCalendar.prototype = {
-    QueryInterface: function cCC_QueryInterface(aIID) {
+    QueryInterface: function(aIID) {
         if (aIID.equals(Components.interfaces.calISchedulingSupport) &&
             this.mUncachedCalendar.QueryInterface(aIID)) {
             // check whether uncached calendar supports it:
             return this;
         } else if (aIID.equals(Components.interfaces.calICalendar) ||
                    aIID.equals(Components.interfaces.nsISupports)) {
             return this;
         } else {
@@ -166,17 +166,17 @@ calCachedCalendar.prototype = {
                 }
             };
 
             this.mCachedCalendar.QueryInterface(Components.interfaces.calICalendarProvider)
                                 .deleteCalendar(this.mCachedCalendar, listener);
         }
     },
 
-    setupCachedCalendar: function cCC_setupCachedCalendar() {
+    setupCachedCalendar: function() {
         try {
             if (this.mCachedCalendar) { // this is actually a resetupCachedCalendar:
                 // Although this doesn't really follow the spec, we know the
                 // storage calendar's deleteCalendar method is synchronous.
                 // TODO put changes into a different calendar and delete
                 // afterwards.
                 this.mCachedCalendar.QueryInterface(Components.interfaces.calICalendarProvider)
                                     .deleteCalendar(this.mCachedCalendar, null);
@@ -217,79 +217,79 @@ calCachedCalendar.prototype = {
                 cachedCalendar.addObserver(this.mCachedObserver);
                 this.mCachedCalendar = cachedCalendar;
             }
         } catch (exc) {
             Components.utils.reportError(exc);
         }
     },
 
-    getOfflineAddedItems: function cCC_getOfflineAddedItems(callbackFunc) {
+    getOfflineAddedItems: function(callbackFunc) {
         let self = this;
         self.offlineCachedItems = {};
         let getListener = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-            onGetResult: function cCC_oOC_cL_onGetResult(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
+            onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
                 for (let item of aItems) {
                     self.offlineCachedItems[item.hashId] = item;
                     self.offlineCachedItemFlags[item.hashId] = cICL.OFFLINE_FLAG_CREATED_RECORD;
                 }
             },
 
-            onOperationComplete: function cCC_oOC_cL_onOperationComplete(aCalendar, aStatus, aOpType, aId, aDetail) {
+            onOperationComplete: function(aCalendar, aStatus, aOpType, aId, aDetail) {
                 self.getOfflineModifiedItems(callbackFunc);
             }
         };
         this.mCachedCalendar.getItems(calICalendar.ITEM_FILTER_ALL_ITEMS | calICalendar.ITEM_FILTER_OFFLINE_CREATED,
                                       0, null, null, getListener);
     },
 
-    getOfflineModifiedItems: function cCC_getOfflineModifiedItems(callbackFunc) {
+    getOfflineModifiedItems: function(callbackFunc) {
         let self = this;
         let getListener = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-            onGetResult: function cCC_oOC_cL_onGetResult(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
+            onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
                 for (let item of aItems) {
                     self.offlineCachedItems[item.hashId] = item;
                     self.offlineCachedItemFlags[item.hashId] = cICL.OFFLINE_FLAG_MODIFIED_RECORD;
                 }
             },
 
-            onOperationComplete: function cCC_oOC_cL_onOperationComplete(aCalendar, aStatus, aOpType, aId, aDetail) {
+            onOperationComplete: function(aCalendar, aStatus, aOpType, aId, aDetail) {
                 self.getOfflineDeletedItems(callbackFunc);
             }
         };
         this.mCachedCalendar.getItems(calICalendar.ITEM_FILTER_OFFLINE_MODIFIED | calICalendar.ITEM_FILTER_ALL_ITEMS,
                                       0, null, null, getListener);
     },
 
-    getOfflineDeletedItems: function cCC_getOfflineDeletedItems(callbackFunc) {
+    getOfflineDeletedItems: function(callbackFunc) {
         let self = this;
         let getListener = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
-            onGetResult: function cCC_oOC_cL_onGetResult(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
+            onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
                 for (let item of aItems) {
                     self.offlineCachedItems[item.hashId] = item;
                     self.offlineCachedItemFlags[item.hashId] = cICL.OFFLINE_FLAG_DELETED_RECORD;
                 }
             },
 
-            onOperationComplete: function cCC_oOC_cL_onOperationComplete(aCalendar, aStatus, aOpType, aId, aDetail) {
+            onOperationComplete: function(aCalendar, aStatus, aOpType, aId, aDetail) {
                 if (callbackFunc) {
                     callbackFunc();
                 }
             }
         };
         this.mCachedCalendar.getItems(calICalendar.ITEM_FILTER_OFFLINE_DELETED | calICalendar.ITEM_FILTER_ALL_ITEMS,
                                       0, null, null, getListener);
     },
 
     mPendingSync: null,
     mSyncQueue: null,
-    synchronize: function cCC_synchronize(respFunc) {
+    synchronize: function(respFunc) {
         let self = this;
         if (this.getProperty("disabled")) {
             return emptyQueue(Components.results.NS_OK);
         }
 
         this.mSyncQueue.push(respFunc);
         if (this.mSyncQueue.length > 1) { // don't use mPendingSync here
             cal.LOG("[calCachedCalendar] sync in action/pending.");
@@ -342,53 +342,44 @@ calCachedCalendar.prototype = {
         let completeListener = {
             QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIOperationListener]),
             modifiedTimes: {},
             hasRenewedCalendar: false,
             getsCompleted: 0,
             getsReceived: 0,
             opCompleted: false,
 
-            onGetResult: function cCC_oOC_cL_onGetResult(aCalendar,
-                                                         aStatus,
-                                                         aItemType,
-                                                         aDetail,
-                                                         aCount,
-                                                         aItems) {
+            onGetResult: function(aCalendar, aStatus, aItemType, aDetail, aCount, aItems) {
                 if (Components.isSuccessCode(aStatus)) {
                     if (!this.hasRenewedCalendar) {
                         // TODO instead of deleting the calendar and creating a new
                         // one, maybe we want to do a "real" sync between the
                         // existing local calendar and the remote calendar.
                         self.setupCachedCalendar();
                         this.hasRenewedCalendar = true;
                     }
 
                     this.getsReceived++;
                     cal.forEach(aItems, function(item) {
                         // Adding items recd from the Memory Calendar
                         // These may be different than what the cache has
                         completeListener.modifiedTimes[item.id] = item.lastModifiedTime;
                         self.mCachedCalendar.addItem(item, null);
-                    }, function completed() {
+                    }, function() {
                         completeListener.getsCompleted++;
                         if (completeListener.opCompleted) {
                             // onOperationComplete was called, but we were not ready yet. call it now.
                             completeListener.onOperationComplete.apply(completeListener, completeListener.opCompleted);
                             completeListener.opCompleted = false;
                         }
                     });
                 }
             },
 
-            onOperationComplete: function cCC_oOC_cL_onOperationComplete(aCalendar,
-                                                                         aStatus,
-                                                                         aOpType,
-                                                                         aId,
-                                                                         aDetail) {
+            onOperationComplete: function(aCalendar, aStatus, aOpType, aId, aDetail) {
                 if (this.getsCompleted < this.getsReceived) {
                     // If not all of our gets have been processed, then save the
                     // arguments and finish processing later.
                     this.opCompleted = Array.slice(arguments);
                     return;
                 }
 
                 if (Components.isSuccessCode(aStatus)) {
@@ -429,18 +420,17 @@ calCachedCalendar.prototype = {
                                         // ...and has not been modified. Delete it now.
                                         self.deleteOfflineItem(item, null);
                                     }
                                 } else {
                                     // Item has already been deleted from the server, no need to change anything.
                                 }
                                 break;
                         }
-                    },
-                    function completed() {
+                    }, function() {
                         self.offlineCachedItems = {};
                         self.offlineCachedItemFlags = {};
                         self.playbackOfflineItems(() => emptyQueue(aStatus));
                     });
                 } else {
                     self.playbackOfflineItems(function() { self.mCachedObserver.onLoad(self.mCachedCalendar); });
                     emptyQueue(aStatus);
                 }
@@ -449,27 +439,27 @@ calCachedCalendar.prototype = {
 
         this.getOfflineAddedItems(() => {
             this.mPendingSync = this.mUncachedCalendar.getItems(Components.interfaces.calICalendar.ITEM_FILTER_ALL_ITEMS,
                                                                     0, null, null, completeListener);
         });
         return this.mPendingSync;
     },
 
-    onOfflineStatusChanged: function cCC_onOfflineStatusChanged(aNewState) {
+    onOfflineStatusChanged: function(aNewState) {
         if (aNewState) {
             // Going offline: (XXX get items before going offline?) => we may ask the user to stay online a bit longer
         } else {
             // Going online (start replaying changes to the remote calendar)
             this.refresh();
         }
     },
 
     // aOldItem is already in the cache
-    promptOverwrite: function cCC_promptOverwrite(aMethod, aItem, aListener, aOldItem) {
+    promptOverwrite: function(aMethod, aItem, aListener, aOldItem) {
         let overwrite = cal.promptOverwrite(aMethod, aItem, aListener, aOldItem);
         if (overwrite) {
             if (aMethod == "modify") {
                 this.modifyOfflineItem(aItem, aOldItem, aListener);
             } else {
                 this.deleteOfflineItem(aItem, aListener);
             }
         }
@@ -480,17 +470,17 @@ calCachedCalendar.prototype = {
      *
      * @param aCallback         (optional) The function to be callled when playback is complete.
      * @param aPlaybackType     (optional) The starting operation type. This function will be
      *                          called recursively through playback operations in the order of
      *                          add, modify, delete. By default playback will start with the add
      *                          operation. Valid values for this parameter are defined as
      *                          OFFLINE_FLAG_XXX constants in the calIChangeLog interface.
      */
-    playbackOfflineItems: function cCC_playbackOfflineItems(aCallback, aPlaybackType) {
+    playbackOfflineItems: function(aCallback, aPlaybackType) {
         let self = this;
         let storage = this.mCachedCalendar.QueryInterface(Components.interfaces.calIOfflineStorage);
 
         let resetListener = gNoOpListener;
         let itemQueue = [];
         let debugOp;
         let nextCallback;
         let uncachedOp;
--- a/calendar/base/src/calCalendarManager.js
+++ b/calendar/base/src/calCalendarManager.js
@@ -36,17 +36,17 @@ calCalendarManager.prototype = {
         flags: Components.interfaces.nsIClassInfo.SINGLETON
     }),
 
     get networkCalendarCount() { return this.mNetworkCalendarCount; },
     get readOnlyCalendarCount() { return this.mReadonlyCalendarCount; },
     get calendarCount() { return this.mCalendarCount; },
 
     // calIStartupService:
-    startup: function ccm_startup(aCompleteListener) {
+    startup: function(aCompleteListener) {
         AddonManager.addAddonListener(gCalendarManagerAddonListener);
         this.checkAndMigrateDB();
         this.mCache = null;
         this.mCalObservers = null;
         this.mRefreshTimer = {};
         this.setupOfflineObservers();
         this.mNetworkCalendarCount = 0;
         this.mReadonlyCalendarCount = 0;
@@ -58,17 +58,17 @@ calCalendarManager.prototype = {
         // pref on startup to avoid checking for every http request
         if (Preferences.get("calendar.network.multirealm", false)) {
             Services.obs.addObserver(this, "http-on-examine-response", false);
         }
 
         aCompleteListener.onResult(null, Components.results.NS_OK);
     },
 
-    shutdown: function ccm_shutdown(aCompleteListener) {
+    shutdown: function(aCompleteListener) {
         for (let id in this.mCache) {
             let calendar = this.mCache[id];
             calendar.removeObserver(this.mCalObservers[calendar.id]);
         }
 
         this.cleanupOfflineObservers();
 
         Services.obs.removeObserver(this, "http-on-modify-request");
@@ -81,25 +81,25 @@ calCalendarManager.prototype = {
         if (Preferences.get("calendar.network.multirealm", false)) {
             Services.obs.removeObserver(this, "http-on-examine-response");
         }
 
         aCompleteListener.onResult(null, Components.results.NS_OK);
     },
 
 
-    setupOfflineObservers: function ccm_setupOfflineObservers() {
+    setupOfflineObservers: function() {
         Services.obs.addObserver(this, "network:offline-status-changed", false);
     },
 
-    cleanupOfflineObservers: function ccm_cleanupOfflineObservers() {
+    cleanupOfflineObservers: function() {
         Services.obs.removeObserver(this, "network:offline-status-changed");
     },
 
-    observe: function ccm_observe(aSubject, aTopic, aData) {
+    observe: function(aSubject, aTopic, aData) {
         switch (aTopic) {
             case "timer-callback":
                 // Refresh all the calendars that can be refreshed.
                 for (let calendar of this.getCalendars({})) {
                     if (!calendar.getProperty("disabled") && calendar.canRefresh) {
                         calendar.refresh();
                     }
                 }
@@ -247,17 +247,17 @@ calCalendarManager.prototype = {
                 // - Decouple schema version from storage calendar
                 // Create the new tables.
                 db.executeSimpleSQL("CREATE TABLE cal_calmgr_schema_version (version INTEGER);");
                 db.executeSimpleSQL("INSERT INTO cal_calmgr_schema_version VALUES(" + DB_SCHEMA_VERSION + ")");
             }
         }
     },
 
-    migrateDB: function calmgr_migrateDB(db) {
+    migrateDB: function(db) {
         let selectCalendars = db.createStatement("SELECT * FROM cal_calendars");
         let selectPrefs = db.createStatement("SELECT name, value FROM cal_calendars_prefs WHERE calendar = :calendar");
         try {
             let sortOrder = {};
 
             while (selectCalendars.executeStep()) {
                 let id = cal.getUUID(); // use fresh uuids
                 Preferences.set(getPrefBranchFor(id) + "type", selectCalendars.row.type);
@@ -310,17 +310,17 @@ calCalendarManager.prototype = {
             Preferences.set("calendar.list.sortOrder", sortOrderAr.join(" "));
             flushPrefs();
         } finally {
             selectPrefs.reset();
             selectCalendars.reset();
         }
     },
 
-    checkAndMigrateDB: function calmgr_checkAndMigrateDB() {
+    checkAndMigrateDB: function() {
         let storageSdb = Services.dirsvc.get("ProfD", Components.interfaces.nsILocalFile);
         storageSdb.append("storage.sdb");
         let db = Services.storage.openDatabase(storageSdb);
 
         db.beginTransactionAs(Components.interfaces.mozIStorageConnection.TRANSACTION_EXCLUSIVE);
         try {
             if (db.tableExists("cal_calendars_prefs")) {
                 // Check if we need to upgrade:
@@ -353,17 +353,17 @@ calCalendarManager.prototype = {
             db.close();
         }
     },
 
     /**
      * @return      db schema version
      * @exception   various, depending on error
      */
-    getSchemaVersion: function calMgrGetSchemaVersion(db) {
+    getSchemaVersion: function(db) {
         let stmt;
         let version = null;
 
         let table;
         if (db.tableExists("cal_calmgr_schema_version")) {
             table = "cal_calmgr_schema_version";
         } else {
             // Fall back to the old schema table
@@ -392,17 +392,17 @@ calCalendarManager.prototype = {
 
         throw table + " SELECT returned no results";
     },
 
     //
     // / DB migration code ends here
     //
 
-    alertAndQuit: function cmgr_alertAndQuit() {
+    alertAndQuit: function() {
         // We want to include the extension name in the error message rather
         // than blaming Thunderbird.
         let hostAppName = calGetString("brand", "brandShortName", null, "branding");
         let calAppName = calGetString("lightning", "brandShortName", null, "lightning");
         let errorBoxTitle = calGetString("calendar", "tooNewSchemaErrorBoxTitle", [calAppName]);
         let errorBoxText = calGetString("calendar", "tooNewSchemaErrorBoxTextLightning", [calAppName, hostAppName]);
         let errorBoxButtonLabel = calGetString("calendar", "tooNewSchemaButtonRestart", [hostAppName]);
 
@@ -418,27 +418,27 @@ calCalendarManager.prototype = {
                             errorBoxButtonFlags,
                             errorBoxButtonLabel,
                             null, // No second button text
                             null, // No third button text
                             null, // No checkbox
                             { value: false }); // Unnecessary checkbox state
 
         // Disable Lightning
-        AddonManager.getAddonByID("{e2fda1a4-762b-4020-b5ad-a41df1933103}", function getLightningExt(aAddon) {
+        AddonManager.getAddonByID("{e2fda1a4-762b-4020-b5ad-a41df1933103}", function(aAddon) {
             aAddon.userDisabled = true;
             Services.startup.quit(Components.interfaces.nsIAppStartup.eRestart |
                 Components.interfaces.nsIAppStartup.eForceQuit);
         });
     },
 
     /**
      * calICalendarManager interface
      */
-    createCalendar: function cmgr_createCalendar(type, uri) {
+    createCalendar: function(type, uri) {
         try {
             if (!Components.classes["@mozilla.org/calendar/calendar;1?type=" + type]) {
                 // Don't notify the user with an extra dialog if the provider
                 // interface is missing.
                 return null;
             }
             let calendar = Components.classes["@mozilla.org/calendar/calendar;1?type=" + type]
                                      .createInstance(Components.interfaces.calICalendar);
@@ -508,17 +508,17 @@ calCalendarManager.prototype = {
 
         if (!calendar.getProperty("disabled") && calendar.canRefresh) {
             calendar.refresh();
         }
 
         this.notifyObservers("onCalendarRegistered", [calendar]);
     },
 
-    setupCalendar: function cmgr_setupCalendar(calendar) {
+    setupCalendar: function(calendar) {
         this.mCache[calendar.id] = calendar;
 
         // Add an observer to track readonly-mode triggers
         let newObserver = new calMgrCalendarObserver(calendar, this);
         calendar.addObserver(newObserver);
         this.mCalObservers[calendar.id] = newObserver;
 
         // Set up statistics
@@ -529,17 +529,17 @@ calCalendarManager.prototype = {
             this.mReadonlyCalendarCount++;
         }
         this.mCalendarCount++;
 
         // Set up the refresh timer
         this.setupRefreshTimer(calendar);
     },
 
-    setupRefreshTimer: function setupRefreshTimer(aCalendar) {
+    setupRefreshTimer: function(aCalendar) {
         // Add the refresh timer for this calendar
         let refreshInterval = aCalendar.getProperty("refreshInterval");
         if (refreshInterval === null) {
             // Default to 30 minutes, in case the value is missing
             refreshInterval = 30;
         }
 
         this.clearRefreshTimer(aCalendar);
@@ -551,17 +551,17 @@ calCalendarManager.prototype = {
 
             this.mRefreshTimer[aCalendar.id]
                 .initWithCallback(new timerCallback(aCalendar),
                                   refreshInterval * 60000,
                                   Components.interfaces.nsITimer.TYPE_REPEATING_SLACK);
         }
     },
 
-    clearRefreshTimer: function clearRefreshTimer(aCalendar) {
+    clearRefreshTimer: function(aCalendar) {
         if (aCalendar.id in this.mRefreshTimer &&
             this.mRefreshTimer[aCalendar.id]) {
             this.mRefreshTimer[aCalendar.id].cancel();
             delete this.mRefreshTimer[aCalendar.id];
         }
     },
 
     unregisterCalendar: function(calendar) {
@@ -631,36 +631,36 @@ calCalendarManager.prototype = {
             if (!wrappedCalendar) {
                 throw new Components.Exception("Calendar is missing a provider implementation for delete");
             }
 
             wrappedCalendar.deleteCalendar(calendar, null);
         }
     },
 
-    getCalendarById: function cmgr_getCalendarById(aId) {
+    getCalendarById: function(aId) {
         if (aId in this.mCache) {
             return this.mCache[aId];
         } else {
             return null;
         }
     },
 
-    getCalendars: function cmgr_getCalendars(count) {
+    getCalendars: function(count) {
         this.assureCache();
         let calendars = [];
         for (let id in this.mCache) {
             let calendar = this.mCache[id];
             calendars.push(calendar);
         }
         count.value = calendars.length;
         return calendars;
     },
 
-    assureCache: function cmgr_assureCache() {
+    assureCache: function() {
         if (!this.mCache) {
             this.mCache = {};
             this.mCalObservers = {};
 
             let allCals = {};
             for (let key of Services.prefs.getChildList(REGISTRY_BRANCH)) { // merge down all keys
                 allCals[key.substring(0, key.indexOf(".", REGISTRY_BRANCH.length))] = true;
             }
@@ -1012,17 +1012,17 @@ calMgrCalendarObserver.prototype = {
 
 function calDummyCalendar(type) {
     this.initProviderBase();
     this.type = type;
 }
 calDummyCalendar.prototype = {
     __proto__: cal.ProviderBase.prototype,
 
-    getProperty: function calDummyCalendar_getProperty(aName) {
+    getProperty: function(aName) {
         switch (aName) {
             case "force-disabled":
                 return true;
             default:
                 return this.__proto__.__proto__.getProperty.apply(this, arguments);
         }
     }
 };
@@ -1042,17 +1042,17 @@ function flushPrefs() {
 
 /**
  * Callback object for the refresh timer. Should be called as an object, i.e
  * let foo = new timerCallback(calendar);
  *
  * @param aCalendar     The calendar to refresh on notification
  */
 function timerCallback(aCalendar) {
-    this.notify = function refreshNotify(aTimer) {
+    this.notify = function(aTimer) {
         if (!aCalendar.getProperty("disabled") && aCalendar.canRefresh) {
             aCalendar.refresh();
         }
     };
 }
 
 var gCalendarManagerAddonListener = {
     onDisabling: function(aAddon, aNeedsRestart) {
--- a/calendar/base/src/calCalendarSearchService.js
+++ b/calendar/base/src/calCalendarSearchService.js
@@ -11,28 +11,28 @@ function calCalendarSearchListener(numOp
         this.notifyResult(null);
     });
 }
 calCalendarSearchListener.prototype = {
     mFinalListener: null,
     mNumOperations: 0,
     opGroup: null,
 
-    notifyResult: function calCalendarSearchListener_notifyResult(result) {
+    notifyResult: function(result) {
         let listener = this.mFinalListener;
         if (listener) {
             if (!this.opGroup.isPending) {
                 this.mFinalListener = null;
             }
             listener.onResult(this.opGroup, result);
         }
     },
 
     // calIGenericOperationListener:
-    onResult: function calCalendarSearchListener_onResult(aOperation, aResult) {
+    onResult: function(aOperation, aResult) {
         if (this.mFinalListener) {
             if (!aOperation || !aOperation.isPending) {
                 --this.mNumOperations;
                 if (this.mNumOperations == 0) {
                     this.opGroup.notifyCompleted();
                 }
             }
             if (aResult) {
@@ -60,20 +60,17 @@ calCalendarSearchService.prototype = {
         classID: calCalendarSearchServiceClassID,
         contractID: "@mozilla.org/calendar/calendarsearch-service;1",
         classDescription: "Calendar Search Service",
         interfaces: calCalendarSearchServiceInterfaces,
         flags: Components.interfaces.nsIClassInfo.SINGLETON
     }),
 
     // calICalendarSearchProvider:
-    searchForCalendars: function calCalendarSearchService_searchForCalendars(aString,
-                                                                             aHints,
-                                                                             aMaxResults,
-                                                                             aListener) {
+    searchForCalendars: function(aString, aHints, aMaxResults, aListener) {
         let groupListener = new calCalendarSearchListener(this.mProviders.size, aListener);
         function searchForCalendars_(provider) {
             try {
                 groupListener.opGroup.add(provider.searchForCalendars(aString,
                                                                       aHints,
                                                                       aMaxResults,
                                                                       groupListener));
             } catch (exc) {
@@ -81,20 +78,20 @@ calCalendarSearchService.prototype = {
                 groupListener.onResult(null, []); // dummy to adopt mNumOperations
             }
         }
         this.mProviders.forEach(searchForCalendars_);
         return groupListener.opGroup;
     },
 
     // calICalendarSearchService:
-    getProviders: function calCalendarSearchService_getProviders(out_aCount) {
+    getProviders: function(out_aCount) {
         let ret = this.mProviders.interfaceArray;
         out_aCount.value = ret.length;
         return ret;
     },
-    addProvider: function calCalendarSearchService_addProvider(aProvider) {
+    addProvider: function(aProvider) {
         this.mProviders.add(aProvider);
     },
-    removeProvider: function calCalendarSearchService_removeProvider(aProvider) {
+    removeProvider: function(aProvider) {
         this.mProviders.remove(aProvider);
     }
 };
--- a/calendar/base/src/calDateTimeFormatter.js
+++ b/calendar/base/src/calDateTimeFormatter.js
@@ -73,31 +73,31 @@ calDateTimeFormatter.prototype = {
     QueryInterface: XPCOMUtils.generateQI(calDateTimeFormatterInterfaces),
     classInfo: XPCOMUtils.generateCI({
         classID: calDateTimeFormatterClassID,
         contractID: "@mozilla.org/calendar/datetime-formatter;1",
         classDescription: "Formats Dates and Times",
         interfaces: calDateTimeFormatterInterfaces,
     }),
 
-    formatDate: function formatDate(aDate) {
+    formatDate: function(aDate) {
         // Format the date using user's format preference (long or short)
         let format = Preferences.get("calendar.date.format", 0);
         return (format == 0 ? this.formatDateLong(aDate) : this.formatDateShort(aDate));
     },
 
-    formatDateShort: function formatDateShort(aDate) {
+    formatDateShort: function(aDate) {
         return this.mDateService.FormatDate("",
                                             nsIScriptableDateFormat.dateFormatShort,
                                             aDate.year,
                                             aDate.month + 1,
                                             aDate.day);
     },
 
-    formatDateLong: function formatDateLong(aDate) {
+    formatDateLong: function(aDate) {
         let longDate;
         if (this.mUseLongDateService) {
             longDate = this.mDateService.FormatDate("",
                                                     nsIScriptableDateFormat.dateFormatLong,
                                                     aDate.year,
                                                     aDate.month + 1,
                                                     aDate.day);
             // check whether weekday name appears as in Lightning localization. if not, this is
@@ -117,68 +117,68 @@ calDateTimeFormatter.prototype = {
                                         [this.shortDayName(aDate.weekday),
                                          this.formatDayWithOrdinal(aDate.day),
                                          this.shortMonthName(aDate.month),
                                          aDate.year]);
         }
         return longDate;
     },
 
-    formatDateWithoutYear: function formatDateWithoutYear(aDate) {
+    formatDateWithoutYear: function(aDate) {
         // Doing this the hard way, because nsIScriptableDateFormat doesn't
         // have a way to not include the year.
         if (this.mMonthFirst) {
             return this.shortMonthName(aDate.month) + " " + this.formatDayWithOrdinal(aDate.day);
         } else {
             return this.formatDayWithOrdinal(aDate.day) + " " + this.shortMonthName(aDate.month);
         }
     },
 
-    formatTime: function formatTime(aDate) {
+    formatTime: function(aDate) {
         if (aDate.isDate) {
             return this.mDateStringBundle.GetStringFromName("AllDay");
         }
 
         return this.mDateService.FormatTime("",
                                             nsIScriptableDateFormat.timeFormatNoSeconds,
                                             aDate.hour,
                                             aDate.minute,
                                             0);
     },
 
-    formatDateTime: function formatDateTime(aDate) {
+    formatDateTime: function(aDate) {
         let formattedDate = this.formatDate(aDate);
         let formattedTime = this.formatTime(aDate);
 
         let timeBeforeDate = Preferences.get("calendar.date.formatTimeBeforeDate", false);
         if (timeBeforeDate) {
             return formattedTime + " " + formattedDate;
         } else {
             return formattedDate + " " + formattedTime;
         }
     },
 
-    formatTimeInterval: function formatTimeInterval(aStartDate, aEndDate) {
+    formatTimeInterval: function(aStartDate, aEndDate) {
         if (!aStartDate && aEndDate) {
             return this.formatTime(aEndDate);
         }
         if (!aEndDate && aStartDate) {
             return this.formatTime(aStartDate);
         }
         if (!aStartDate && !aEndDate) {
             return "";
         }
 
         // TODO do we need l10n for this?
         // TODO should we check for the same day? The caller should know what
         // he is doing...
         return this.formatTime(aStartDate) + "\u2013" + this.formatTime(aEndDate);
     },
 
-    formatInterval: function formatInterval(aStartDate, aEndDate) {
+    formatInterval: function(aStartDate, aEndDate) {
         // Check for tasks without start and/or due date
         if (aEndDate == null && aStartDate == null) {
             return calGetString("calendar", "datetimeIntervalTaskWithoutDate");
         } else if (aEndDate == null) {
             let startDateString = this.formatDate(aStartDate);
             let startTime = this.formatTime(aStartDate);
             return calGetString("calendar", "datetimeIntervalTaskWithoutDueDate", [startDateString, startTime]);
         } else if (aStartDate == null) {
@@ -235,23 +235,23 @@ calDateTimeFormatter.prototype = {
                 // Spanning multiple days, so need to include date and time
                 // for start and end
                 // "5 Jan 2006 13:00 - 7 Jan 2006 9:00"
                 return calGetString("calendar", "datetimeIntervalOnSeveralDays", [startDateString, startTime, endDateString, endTime]);
             }
         }
     },
 
-    formatDayWithOrdinal: function formatDayWithOrdinal(aDay) {
+    formatDayWithOrdinal: function(aDay) {
         let ordinalSymbols = this.mDateStringBundle.GetStringFromName("dayOrdinalSymbol").split(",");
         let dayOrdinalSymbol = ordinalSymbols[aDay - 1] || ordinalSymbols[0];
         return aDay + dayOrdinalSymbol;
     },
 
-    _getItemDates: function _getItemDates(aItem) {
+    _getItemDates: function(aItem) {
         let start = aItem[calGetStartDateProp(aItem)];
         let end = aItem[calGetEndDateProp(aItem)];
         let kDefaultTimezone = calendarDefaultTimezone();
         // Check for tasks without start and/or due date
         if (start) {
             start = start.getInTimezone(kDefaultTimezone);
         }
         if (end) {
@@ -261,36 +261,36 @@ calDateTimeFormatter.prototype = {
         // to get into a format that's understandable.
         if (start && start.isDate && end) {
             end.day -= 1;
         }
 
         return [start, end];
     },
 
-    formatItemInterval: function formatItemInterval(aItem) {
+    formatItemInterval: function(aItem) {
         return this.formatInterval.apply(this, this._getItemDates(aItem));
     },
 
-    formatItemTimeInterval: function formatItemTimeInterval(aItem) {
+    formatItemTimeInterval: function(aItem) {
         return this.formatTimeInterval.apply(this, this._getItemDates(aItem));
     },
 
-    monthName: function monthName(aMonthIndex) {
+    monthName: function(aMonthIndex) {
         let oneBasedMonthIndex = aMonthIndex + 1;
         return this.mDateStringBundle.GetStringFromName("month." + oneBasedMonthIndex + ".name");
     },
 
-    shortMonthName: function shortMonthName(aMonthIndex) {
+    shortMonthName: function(aMonthIndex) {
         let oneBasedMonthIndex = aMonthIndex + 1;
         return this.mDateStringBundle.GetStringFromName("month." + oneBasedMonthIndex + ".Mmm");
     },
 
-    dayName: function dayName(aDayIndex) {
+    dayName: function(aDayIndex) {
         let oneBasedDayIndex = aDayIndex + 1;
         return this.mDateStringBundle.GetStringFromName("day." + oneBasedDayIndex + ".name");
     },
 
-    shortDayName: function shortDayName(aDayIndex) {
+    shortDayName: function(aDayIndex) {
         let oneBasedDayIndex = aDayIndex + 1;
         return this.mDateStringBundle.GetStringFromName("day." + oneBasedDayIndex + ".Mmm");
     }
 };
--- a/calendar/base/src/calDefaultACLManager.js
+++ b/calendar/base/src/calDefaultACLManager.js
@@ -24,32 +24,32 @@ calDefaultACLManager.prototype = {
         classID: calDefaultACLManagerClassID,
         contractID: "@mozilla.org/calendar/acl-manager;1?type=default",
         classDescription: "Default Calendar ACL Provider",
         interfaces: calDefaultACLManagerInterfaces,
         flags: Components.interfaces.nsIClassInfo.SINGLETON
     }),
 
     /* calICalendarACLManager */
-    _getCalendarEntryCached: function cDACLM__getCalendarEntryCached(aCalendar) {
+    _getCalendarEntryCached: function(aCalendar) {
         let calUri = aCalendar.uri.spec;
         if (!(calUri in this.mCalendarEntries)) {
             this.mCalendarEntries[calUri] = new calDefaultCalendarACLEntry(this, aCalendar);
         }
 
         return this.mCalendarEntries[calUri];
     },
-    getCalendarEntry: function cDACLM_getCalendarEntry(aCalendar, aListener) {
+    getCalendarEntry: function(aCalendar, aListener) {
         let entry = this._getCalendarEntryCached(aCalendar);
         aListener.onOperationComplete(aCalendar, Components.results.NS_OK,
                                       Components.interfaces.calIOperationListener.GET,
                                       null,
                                       entry);
     },
-    getItemEntry: function cDACLM_getItemEntry(aItem) {
+    getItemEntry: function(aItem) {
         let calEntry = this._getCalendarEntryCached(aItem.calendar);
         return new calDefaultItemACLEntry(calEntry);
     },
 
 };
 
 function calDefaultCalendarACLEntry(aMgr, aCalendar) {
     this.mACLManager = aMgr;
@@ -67,43 +67,43 @@ calDefaultCalendarACLEntry.prototype = {
         return this.mACLManager;
     },
 
     hasAccessControl: false,
     userIsOwner: true,
     userCanAddItems: true,
     userCanDeleteItems: true,
 
-    _getIdentities: function calDefaultCalendarACLEntry_getUserAddresses(aCount) {
+    _getIdentities: function(aCount) {
         let identities = [];
         cal.calIterateEmailIdentities(function(id, ac) { identities.push(id); });
         aCount.value = identities.length;
         return identities;
     },
 
-    getUserAddresses: function calDefaultCalendarACLEntry_getUserAddresses(aCount) {
+    getUserAddresses: function(aCount) {
         let identities = this.getUserIdentities(aCount);
         let addresses = identities.map(id => id.email);
         return addresses;
     },
 
-    getUserIdentities: function calDefaultCalendarACLEntry_getUserIdentities(aCount) {
+    getUserIdentities: function(aCount) {
         let identity = cal.getEmailIdentityOfCalendar(this.mCalendar);
         if (identity) {
             aCount.value = 1;
             return [identity];
         } else {
             return this._getIdentities(aCount);
         }
     },
-    getOwnerIdentities: function calDefaultCalendarACLEntry_getOwnerIdentities(aCount) {
+    getOwnerIdentities: function(aCount) {
         return this._getIdentities(aCount);
     },
 
-    refresh: function calDefaultCalendarACLEntry_refresh() {
+    refresh: function() {
     }
 };
 
 function calDefaultItemACLEntry(aCalendarEntry) {
     this.calendarEntry = aCalendarEntry;
 }
 
 calDefaultItemACLEntry.prototype = {
--- a/calendar/base/src/calDeletedItems.js
+++ b/calendar/base/src/calDeletedItems.js
@@ -44,23 +44,23 @@ calDeletedItems.prototype = {
     DB_SCHEMA_VERSION: 1,
     STALE_TIME: 30 * 24 * 60 * 60 / 1000, /* 30 days */
 
     // To make the tests more failsafe, we have an internal notifier function.
     // As the deleted items store is just meant to be a hint, this should not
     // be used in real code.
     completedNotifier: null,
 
-    flush: function flush() {
+    flush: function() {
         this.ensureStatements();
         this.stmtFlush.params.stale_time = cal.now().nativeTime - this.STALE_TIME;
         this.stmtFlush.executeAsync(this.completedNotifier);
     },
 
-    getDeletedDate: function calDeletedItems_getDeleted(aId, aCalId) {
+    getDeletedDate: function(aId, aCalId) {
         this.ensureStatements();
         let stmt;
         if (aCalId) {
             stmt = this.stmtGetWithCal;
             stmt.params.calId = aCalId;
         } else {
             stmt = this.stmtGet;
         }
@@ -75,32 +75,32 @@ calDeletedItems.prototype = {
         } catch (e) {
             cal.ERROR(e);
         } finally {
             stmt.reset();
         }
         return null;
     },
 
-    markDeleted: function calDeletedItems_markDeleted(aItem) {
+    markDeleted: function(aItem) {
         this.ensureStatements();
         this.stmtMarkDelete.params.calId = aItem.calendar.id;
         this.stmtMarkDelete.params.id = aItem.id;
         this.stmtMarkDelete.params.time = cal.now().nativeTime;
         this.stmtMarkDelete.params.rid = (aItem.recurrenceId && aItem.recurrenceId.nativeTime) || "";
         this.stmtMarkDelete.executeAsync(this.completedNotifier);
     },
 
-    unmarkDeleted: function calDeletedItems_unmarkDeleted(aItem) {
+    unmarkDeleted: function(aItem) {
         this.ensureStatements();
         this.stmtUnmarkDelete.params.id = aItem.id;
         this.stmtUnmarkDelete.executeAsync(this.completedNotifier);
     },
 
-    initDB: function initDB() {
+    initDB: function() {
         if (this.mDB) {
             // Looks like we've already initialized, exit early
             return;
         }
 
         let file = FileUtils.getFile("ProfD", ["calendar-data", "deleted.sqlite"]);
         this.mDB = Services.storage.openDatabase(file);
 
@@ -116,25 +116,25 @@ calDeletedItems.prototype = {
         }
 
         // We will not init the statements now, we can still do that the
         // first time this interface is used. What we should do though is
         // to clean up at shutdown
         cal.addShutdownObserver(this.shutdown.bind(this));
     },
 
-    observe: function observe(aSubject, aTopic, aData) {
+    observe: function(aSubject, aTopic, aData) {
         if (aTopic == "profile-after-change") {
             // Make sure to observe calendar changes so we know when things are
             // deleted. We don't initialize the statements until first use.
             cal.getCalendarManager().addCalendarObserver(this);
         }
     },
 
-    ensureStatements: function ensureStatements() {
+    ensureStatements: function() {
         if (!this.mDB) {
             this.initDB();
         }
 
         if (!this.stmtMarkDelete) {
             let stmt = "INSERT OR REPLACE INTO cal_deleted_items (cal_id, id, time_deleted, recurrence_id) VALUES(:calId, :id, :time, :rid)";
             this.stmtMarkDelete = this.mDB.createStatement(stmt);
         }
@@ -151,17 +151,17 @@ calDeletedItems.prototype = {
             this.stmtGet = this.mDB.createStatement(stmt);
         }
         if (!this.stmtFlush) {
             let stmt = "DELETE FROM cal_deleted_items WHERE time_deleted < :stale_time";
             this.stmtFlush = this.mDB.createStatement(stmt);
         }
     },
 
-    shutdown: function shutdown() {
+    shutdown: function() {
         try {
             let stmts = [
                 this.stmtMarkDelete, this.stmtUnmarkDelete, this.stmtGet,
                 this.stmtGetWithCal, this.stmtFlush
             ];
             for (let stmt of stmts) {
                 stmt.finalize();
             }
@@ -181,16 +181,16 @@ calDeletedItems.prototype = {
     onError: function() {},
     onPropertyChanged: function() {},
     onPropertyDeleting: function() {},
 
     onAddItem: function(aItem) {
         this.unmarkDeleted(aItem);
     },
 
-    onDeleteItem: function onDeleteItem(aItem) {
+    onDeleteItem: function(aItem) {
         this.markDeleted(aItem);
     },
 
-    onLoad: function onLoad() {
+    onLoad: function() {
         this.flush();
     }
 };
--- a/calendar/base/src/calEvent.js
+++ b/calendar/base/src/calEvent.js
@@ -36,17 +36,17 @@ calEvent.prototype = {
     }),
 
     cloneShallow: function(aNewParent) {
         let m = new calEvent();
         this.cloneItemBaseInto(m, aNewParent);
         return m;
     },
 
-    createProxy: function calEvent_createProxy(aRecurrenceId) {
+    createProxy: function(aRecurrenceId) {
         cal.ASSERT(!this.mIsProxy, "Tried to create a proxy for an existing proxy!", true);
 
         let m = new calEvent();
 
         // override proxy's DTSTART/DTEND/RECURRENCE-ID
         // before master is set (and item might get immutable):
         let endDate = aRecurrenceId.clone();
         endDate.addDuration(this.duration);
--- a/calendar/base/src/calFilter.js
+++ b/calendar/base/src/calFilter.js
@@ -118,37 +118,37 @@ calFilterProperties.prototype = {
     end: null,
     due: null,
     status: null,
     category: null,
     occurrences: null,
 
     onfilter: null,
 
-    equals: function cFP_equals(aFilterProps) {
+    equals: function(aFilterProps) {
         if (!(aFilterProps instanceof calFilterProperties)) {
             return false;
         }
         let props = ["start", "end", "due", "status", "category", "occurrences", "onfilter"];
         return props.every(function(prop) {
             return (this[prop] == aFilterProps[prop]);
         }, this);
     },
 
-    clone: function cFP_clone() {
+    clone: function() {
         let cl = new calFilterProperties();
         let props = ["start", "end", "due", "status", "category", "occurrences", "onfilter"];
         props.forEach(function(prop) {
             cl[prop] = this[prop];
         }, this);
 
         return cl;
     },
 
-    LOG: function cFP_LOG(aString) {
+    LOG: function(aString) {
         cal.LOG("[calFilterProperties] " +
                 (aString || "") +
                 " start=" + this.start +
                 " end=" + this.end +
                 " status=" + this.status +
                 " due=" + this.due +
                 " category=" + this.category);
     }
@@ -175,17 +175,17 @@ calFilter.prototype = {
     mFilterProperties: null,
     mToday: null,
     mTomorrow: null,
     mMaxIterations: 50,
 
     /**
      * Initializes the predefined filters.
      */
-    initDefinedFilters: function cF_initDefinedFilters() {
+    initDefinedFilters: function() {
         let filters = ["all", "notstarted", "overdue", "open", "completed", "throughcurrent",
                        "throughtoday", "throughsevendays", "today", "thisCalendarMonth",
                        "future", "current", "currentview"];
         filters.forEach(function(filter) {
             if (!(filter in this.mDefinedFilters)) {
                 this.defineFilter(filter, this.getPreDefinedFilterProperties(filter));
             }
         }, this);
@@ -193,17 +193,17 @@ calFilter.prototype = {
 
     /**
      * Gets the filter properties for a predefined filter.
      *
      * @param aFilter   The name of the filter to retrieve the filter properties for.
      * @result          The filter properties for the specified filter, or null if the filter
      *                  not predefined.
      */
-    getPreDefinedFilterProperties: function cF_getPreDefinedFilterProperties(aFilter) {
+    getPreDefinedFilterProperties: function(aFilter) {
         let props = new calFilterProperties();
 
         if (!aFilter) {
             return props;
         }
 
         switch (aFilter) {
 
@@ -291,64 +291,64 @@ calFilter.prototype = {
     /**
      * Defines a set of filter properties so that they may be applied by the filter name. If
      * the specified filter name is already defined, it's associated filter properties will be
      * replaced.
      *
      * @param aFilterName         The name to define the filter properties as.
      * @param aFilterProperties   The filter properties to define.
      */
-    defineFilter: function cF_defineFilter(aFilterName, aFilterProperties) {
+    defineFilter: function(aFilterName, aFilterProperties) {
         if (!(aFilterProperties instanceof calFilterProperties)) {
             return;
         }
 
         this.mDefinedFilters[aFilterName] = aFilterProperties;
     },
 
     /**
      * Returns the set of filter properties that were previously defined by a filter name.
      *
      * @param aFilter             The filter name of the defined filter properties.
      * @return                    The properties defined by the filter name, or null if
      *                            the filter name was not previously defined.
      */
-    getDefinedFilterProperties: function cF_getDefinedFilterProperties(aFilter) {
+    getDefinedFilterProperties: function(aFilter) {
         if (aFilter in this.mDefinedFilters) {
             return this.mDefinedFilters[aFilter].clone();
         } else {
             return null;
         }
     },
 
     /**
      * Returns the filter name that a set of filter properties were previously defined as.
      *
      * @param aFilterProperties   The filter properties previously defined.
      * @return                    The name of the first filter name that the properties
      *                            were defined as, or null if the filter properties were
      *                            not previously defined.
      */
-    getDefinedFilterName: function cF_getDefinedFilterName(aFilterProperties) {
+    getDefinedFilterName: function(aFilterProperties) {
         for (filter in this.mDefinedFilters) {
             if (this.mDefinedFilters[filter].equals(aFilterProperties)) {
                 return filter;
             }
         }
         return null;
     },
 
     /**
      * Checks if the item matches the current filter text
      *
      * @param aItem               The item to check.
      * @return                    Returns true if the item matches the filter text or no
      *                            filter text has been set, false otherwise.
      */
-    textFilter: function cF_filterByText(aItem) {
+    textFilter: function(aItem) {
         if (!this.mFilterText) {
             return true;
         }
 
         let searchText = this.mFilterText.toLowerCase();
 
         if (!searchText.length || searchText.match(/^\s*$/)) {
             return true;
@@ -369,29 +369,29 @@ calFilter.prototype = {
 
     /**
      * Checks if the item matches the current filter date range.
      *
      * @param aItem               The item to check.
      * @return                    Returns true if the item falls within the date range
      *                            specified by mStartDate and mEndDate, false otherwise.
      */
-    dateRangeFilter: function cF_dateRangeFilter(aItem) {
+    dateRangeFilter: function(aItem) {
         return checkIfInRange(aItem, this.mStartDate, this.mEndDate);
     },
 
     /**
      * Checks if the item matches the currently applied filter properties. Filter properties
      * with a value of null or that are not applicable to the item's type are not tested.
      *
      * @param aItem               The item to check.
      * @return                    Returns true if the item matches the filter properties
      *                            currently applied, false otherwise.
      */
-    propertyFilter: function cF_propertyFilter(aItem) {
+    propertyFilter: function(aItem) {
         let result;
         let props = this.mFilterProperties;
         if (!props) {
             return false;
         }
 
         // the today and tomorrow properties are precalculated in the updateFilterDates function
         // for better performance when filtering batches of items.
@@ -471,17 +471,17 @@ calFilter.prototype = {
      * @param prop                The value of the date filter property to calculate for. May
      *                            be a constant specifying a relative date range, or a string
      *                            representing a duration offset from the current date time.
      * @param start               If true, the function will return the date value for the
      *                            start of the relative date range, otherwise it will return the
      *                            date value for the end of the date range.
      * @return                    The calculated date for the property.
      */
-    getDateForProperty: function cF_getDateForProperty(prop, start) {
+    getDateForProperty: function(prop, start) {
         let props = this.mFilterProperties || new calFilterProperties();
         let result = null;
         let selectedDate = this.mSelectedDate || currentView().selectedDay || cal.now();
         let nowDate = cal.now();
 
         if (typeof prop == "string") {
             let duration = cal.createDuration(prop);
             if (duration) {
@@ -539,17 +539,17 @@ calFilter.prototype = {
         return result;
     },
 
     /**
      * Calculates the current start and end dates for the currently applied filter.
      *
      * @return                    The current [startDate, endDate] for the applied filter.
      */
-    getDatesForFilter: function cfp_getDatesForFilter() {
+    getDatesForFilter: function() {
         let startDate = null;
         let endDate = null;
 
         if (this.mFilterProperties) {
             startDate = this.getDateForProperty(this.mFilterProperties.start, true);
             endDate = this.getDateForProperty(this.mFilterProperties.end, false);
 
             // swap the start and end dates if necessary
@@ -659,17 +659,17 @@ calFilter.prototype = {
      * Applies the specified filter.
      *
      * @param aFilter           The filter to apply. May be one of the following types:
      *                          - a calFilterProperties object specifying the filter properties
      *                          - a String representing a previously defined filter name
      *                          - a String representing a duration offset from now
      *                          - a Function to use for the onfilter callback for a custom filter
      */
-    applyFilter: function cF_applyFilter(aFilter) {
+    applyFilter: function(aFilter) {
         this.mFilterProperties = null;
 
         if (typeof aFilter == "string") {
             if (aFilter in this.mDefinedFilters) {
                 this.mFilterProperties = this.getDefinedFilterProperties(aFilter);
             } else {
                 let dur = cal.createDuration(aFilter);
                 if (dur.inSeconds > 0) {
@@ -697,17 +697,17 @@ calFilter.prototype = {
 
     /**
      * Calculates the current start and end dates for the currently applied filter, and updates
      * the current filter start and end dates. This function can be used to update the date range
      * for date range filters that are relative to the selected date or current date and time.
      *
      * @return                    The current [startDate, endDate] for the applied filter.
      */
-    updateFilterDates: function cF_updateFilterDates() {
+    updateFilterDates: function() {
         let [startDate, endDate] = this.getDatesForFilter();
         this.mStartDate = startDate;
         this.mEndDate = endDate;
 
         // the today and tomorrow properties are precalculated here
         // for better performance when filtering batches of items.
         this.mToday = cal.now();
         this.mToday.isDate = true;
@@ -723,17 +723,17 @@ calFilter.prototype = {
      * the currently applied filter properties and text filter.
      *
      * @param aItems              The array of items to check.
      * @param aCallback           An optional callback function to be called with each item and
      *                            the result of it's filter test.
      * @return                    A new array containing the items that match the filters, or
      *                            null if no filter has been applied.
      */
-    filterItems: function cF_filterItems(aItems, aCallback) {
+    filterItems: function(aItems, aCallback) {
         if (!this.mFilterProperties) {
             return null;
         }
 
         return aItems.filter(function(aItem) {
             let result = this.propertyFilter(aItem) && this.textFilter(aItem);
 
             if (aCallback && typeof aCallback == "function") {
@@ -746,29 +746,29 @@ calFilter.prototype = {
 
     /**
      * Checks if the item matches the currently applied filter properties and text filter.
      *
      * @param aItem               The item to check.
      * @return                    Returns true if the item matches the filters,
      *                            false otherwise.
      */
-    isItemInFilters: function cF_isItemInFilters(aItem) {
+    isItemInFilters: function(aItem) {
         return this.propertyFilter(aItem) && this.textFilter(aItem);
     },
 
     /**
      * Finds the next occurrence of a repeating item that matches the currently applied
      * filter properties.
      *
      * @param aItem               The parent item to find the next occurrence of.
      * @return                    Returns the next occurrence that matches the filters,
      *                            or null if no match is found.
      */
-    getNextOccurrence: function cF_getNextOccurrence(aItem) {
+    getNextOccurrence: function(aItem) {
         if (!aItem.recurrenceInfo) {
             return this.isItemInFilters(aItem) ? aItem : null;
         }
 
         let count = 0;
         let start = cal.now();
 
         // If the base item matches the filter, we need to check each future occurrence.
@@ -808,17 +808,17 @@ calFilter.prototype = {
      * Gets the occurrences of a repeating item that match the currently applied
      * filter properties and date range.
      *
      * @param aItem               The parent item to find occurrence of.
      * @return                    Returns an array containing the occurrences that
      *                            match the filters, an empty array if there are no
      *                            matches, or null if the filter is not initialized.
      */
-    getOccurrences: function cF_getOccurrences(aItem) {
+    getOccurrences: function(aItem) {
         if (!this.mFilterProperties) {
             return null;
         }
         let props = this.mFilterProperties;
         let occs;
 
         if (!aItem.recurrenceInfo || (!props.occurrences && !this.mEndDate) ||
             props.occurrences == props.FILTER_OCCURRENCES_NONE) {
@@ -848,17 +848,17 @@ calFilter.prototype = {
      * This function is asynchronous, and returns results to a calIOperationListener object.
      *
      * @param aCalendar           The calendar to get items from.
      * @param aItemType           The type of items to get, as defined by the calICalendar
      *                            interface ITEM_FILTER_TYPE_XXX constants.
      * @param aListener           The calIOperationListener object to return results to.
      * @return                    the calIOperation handle to track the operation.
      */
-    getItems: function cF_getItems(aCalendar, aItemType, aListener) {
+    getItems: function(aCalendar, aItemType, aListener) {
         if (!this.mFilterProperties) {
             return null;
         }
         let props = this.mFilterProperties;
 
         // we use a local proxy listener for the calICalendar.getItems() call, and use it
         // to handle occurrence expansion and filter the results before forwarding them to
         // the listener passed in the aListener argument.
--- a/calendar/base/src/calFreeBusyService.js
+++ b/calendar/base/src/calFreeBusyService.js
@@ -14,28 +14,28 @@ function calFreeBusyListener(numOperatio
 }
 calFreeBusyListener.prototype = {
     mFinalListener: null,
     mNumOperations: 0,
     opGroup: null,
 
     QueryInterface: XPCOMUtils.generateQI([Components.interfaces.calIGenericOperationListener]),
 
-    notifyResult: function calFreeBusyListener_notifyResult(result) {
+    notifyResult: function(result) {
         let listener = this.mFinalListener;
         if (listener) {
             if (!this.opGroup.isPending) {
                 this.mFinalListener = null;
             }
             listener.onResult(this.opGroup, result);
         }
     },
 
     // calIGenericOperationListener:
-    onResult: function calFreeBusyListener_onResult(aOperation, aResult) {
+    onResult: function(aOperation, aResult) {
         if (this.mFinalListener) {
             if (!aOperation || !aOperation.isPending) {
                 --this.mNumOperations;
                 if (this.mNumOperations == 0) {
                     this.opGroup.notifyCompleted();
                 }
             }
             let opStatus = aOperation ? aOperation.status : Components.results.NS_OK;
@@ -67,32 +67,28 @@ calFreeBusyService.prototype = {
         classID: calFreeBusyServiceClassID,
         contractID: "@mozilla.org/calendar/freebusy-service;1",
         classDescription: "Calendar FreeBusy Service",
         interfaces: calFreeBusyServiceInterfaces,
         flags: Components.interfaces.nsIClassInfo.SINGLETON
     }),
 
     // calIFreeBusyProvider:
-    getFreeBusyIntervals: function calFreeBusyService_getFreeBusyIntervals(aCalId,
-                                                                           aRangeStart,
-                                                                           aRangeEnd,
-                                                                           aBusyTypes,
-                                                                           aListener) {
+    getFreeBusyIntervals: function(aCalId, aRangeStart, aRangeEnd, aBusyTypes, aListener) {
         let groupListener = new calFreeBusyListener(this.mProviders.size, aListener);
         for (let provider of this.mProviders) {
             let operation = provider.getFreeBusyIntervals(aCalId, aRangeStart,
                                                           aRangeEnd,
                                                           aBusyTypes,
                                                           groupListener);
             groupListener.opGroup.add(operation);
         }
         return groupListener.opGroup;
     },
 
     // calIFreeBusyService:
-    addProvider: function calFreeBusyListener_addProvider(aProvider) {
+    addProvider: function(aProvider) {
         this.mProviders.add(aProvider);
     },
-    removeProvider: function calFreeBusyListener_removeProvider(aProvider) {
+    removeProvider: function(aProvider) {
         this.mProviders.remove(aProvider);
     }
 };
--- a/calendar/base/src/calIcsParser.js
+++ b/calendar/base/src/calIcsParser.js
@@ -21,17 +21,17 @@ calIcsParser.prototype = {
     classInfo: XPCOMUtils.generateCI({
         classID: calIcsParserClassID,
         contractID: "@mozilla.org/calendar/ics-parser;1",
         classDescription: "Calendar ICS Parser",
         interfaces: calIcsParserInterfaces,
         flags: Components.interfaces.nsIClassInfo.THREADSAFE
     }),
 
-    processIcalComponent: function ip_processIcalComponent(rootComp, aAsyncParsing) {
+    processIcalComponent: function(rootComp, aAsyncParsing) {
         let calComp;
         // libical returns the vcalendar component if there is just one vcalendar.
         // If there are multiple vcalendars, it returns an xroot component, with
         // vcalendar children. We need to handle both cases.
         if (rootComp) {
             if (rootComp.componentType == "VCALENDAR") {
                 calComp = rootComp;
             } else {
@@ -110,17 +110,17 @@ calIcsParser.prototype = {
             self.mComponents = self.mComponents.concat(state.extraComponents);
 
             if (aAsyncParsing) {
                 aAsyncParsing.onParsingComplete(Components.results.NS_OK, self);
             }
         });
     },
 
-    parseString: function ip_parseString(aICSString, aTzProvider, aAsyncParsing) {
+    parseString: function(aICSString, aTzProvider, aAsyncParsing) {
         if (aAsyncParsing) {
             let self = this;
 
             // We are using two types of very similar listeners here:
             // aAsyncParsing is a calIcsParsingListener that returns the ics
             //   parser containing the processed items.
             // The listener passed to parseICSAsync is a calICsComponentParsingListener
             //   required by the ics service, that receives the parsed root component.
@@ -134,17 +134,17 @@ calIcsParser.prototype = {
                     }
                 }
             });
         } else {
             this.processIcalComponent(cal.getIcsService().parseICS(aICSString, aTzProvider));
         }
     },
 
-    parseFromStream: function ip_parseFromStream(aStream, aTzProvider, aAsyncParsing) {
+    parseFromStream: function(aStream, aTzProvider, aAsyncParsing) {
         // Read in the string. Note that it isn't a real string at this point,
         // because likely, the file is utf8. The multibyte chars show up as multiple
         // 'chars' in this string. So call it an array of octets for now.