Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1076 insertions, 0 deletions

diff --git a/comm/calendar/base/src/CalCalendarManager.jsm b/comm/calendar/base/src/CalCalendarManager.jsm
new file mode 100644
index 0000000000..117737a635
--- /dev/null
+++ b/comm/calendar/base/src/CalCalendarManager.jsm
@@ -0,0 +1,1076 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+/* import-globals-from calCachedCalendar.js */
+
+var EXPORTED_SYMBOLS = ["CalCalendarManager"];
+
+const { AddonManager } = ChromeUtils.importESModule("resource://gre/modules/AddonManager.sys.mjs");
+const { Preferences } = ChromeUtils.importESModule("resource://gre/modules/Preferences.sys.mjs");
+const { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+const { calCachedCalendar } = ChromeUtils.import("resource:///components/calCachedCalendar.js");
+const { setTimeout } = ChromeUtils.importESModule("resource://gre/modules/Timer.sys.mjs");
+
+var REGISTRY_BRANCH = "calendar.registry.";
+var MAX_INT = Math.pow(2, 31) - 1;
+var MIN_INT = -MAX_INT;
+
+function CalCalendarManager() {
+  this.wrappedJSObject = this;
+  this.mObservers = new cal.data.ListenerSet(Ci.calICalendarManagerObserver);
+  this.mCalendarObservers = new cal.data.ListenerSet(Ci.calIObserver);
+
+  this.providerImplementations = {};
+}
+
+var calCalendarManagerClassID = Components.ID("{f42585e7-e736-4600-985d-9624c1c51992}");
+var calCalendarManagerInterfaces = [Ci.calICalendarManager, Ci.calIStartupService, Ci.nsIObserver];
+CalCalendarManager.prototype = {
+  classID: calCalendarManagerClassID,
+  QueryInterface: cal.generateQI(["calICalendarManager", "calIStartupService", "nsIObserver"]),
+  classInfo: cal.generateCI({
+    classID: calCalendarManagerClassID,
+    contractID: "@mozilla.org/calendar/manager;1",
+    classDescription: "Calendar Manager",
+    interfaces: calCalendarManagerInterfaces,
+    flags: Ci.nsIClassInfo.SINGLETON,
+  }),
+
+  get networkCalendarCount() {
+    return this.mNetworkCalendarCount;
+  },
+  get readOnlyCalendarCount() {
+    return this.mReadonlyCalendarCount;
+  },
+  get calendarCount() {
+    return this.mCalendarCount;
+  },
+
+  // calIStartupService:
+  startup(aCompleteListener) {
+    AddonManager.addAddonListener(gCalendarManagerAddonListener);
+    this.mCache = null;
+    this.mCalObservers = null;
+    this.mRefreshTimer = {};
+    this.setupOfflineObservers();
+    this.mNetworkCalendarCount = 0;
+    this.mReadonlyCalendarCount = 0;
+    this.mCalendarCount = 0;
+
+    // We only add the observer if the pref is set and only check for the
+    // pref on startup to avoid checking for every http request
+    if (Services.prefs.getBoolPref("calendar.network.multirealm", false)) {
+      Services.obs.addObserver(this, "http-on-examine-response");
+    }
+
+    aCompleteListener.onResult(null, Cr.NS_OK);
+  },
+
+  shutdown(aCompleteListener) {
+    for (let id in this.mCache) {
+      let calendar = this.mCache[id];
+      calendar.removeObserver(this.mCalObservers[calendar.id]);
+    }
+
+    this.cleanupOfflineObservers();
+
+    AddonManager.removeAddonListener(gCalendarManagerAddonListener);
+
+    // Remove the observer if the pref is set. This might fail when the
+    // user flips the pref, but we assume he is going to restart anyway
+    // afterwards.
+    if (Services.prefs.getBoolPref("calendar.network.multirealm", false)) {
+      Services.obs.removeObserver(this, "http-on-examine-response");
+    }
+
+    aCompleteListener.onResult(null, Cr.NS_OK);
+  },
+
+  setupOfflineObservers() {
+    Services.obs.addObserver(this, "network:offline-status-changed");
+  },
+
+  cleanupOfflineObservers() {
+    Services.obs.removeObserver(this, "network:offline-status-changed");
+  },
+
+  observe(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case "timer-callback": {
+        // Refresh all the calendars that can be refreshed.
+        for (let calendar of this.getCalendars()) {
+          maybeRefreshCalendar(calendar);
+        }
+        break;
+      }
+      case "network:offline-status-changed": {
+        for (let id in this.mCache) {
+          let calendar = this.mCache[id];
+          if (calendar instanceof calCachedCalendar) {
+            calendar.onOfflineStatusChanged(aData == "offline");
+          }
+        }
+        break;
+      }
+      case "http-on-examine-response": {
+        try {
+          let channel = aSubject.QueryInterface(Ci.nsIHttpChannel);
+          if (channel.notificationCallbacks) {
+            // We use the notification callbacks to get the calendar interface, which likely works
+            // for our requests since getInterface is called from the calendar provider context.
+            let authHeader = channel.getResponseHeader("WWW-Authenticate");
+            let calendar = channel.notificationCallbacks.getInterface(Ci.calICalendar);
+            if (calendar && !calendar.getProperty("capabilities.realmrewrite.disabled")) {
+              // The provider may choose to explicitly disable the rewriting, for example if all
+              // calendars on a domain have the same credentials
+              let escapedName = calendar.name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+              authHeader = appendToRealm(authHeader, "(" + escapedName + ")");
+              channel.setResponseHeader("WWW-Authenticate", authHeader, false);
+            }
+          }
+        } catch (e) {
+          if (e.result != Cr.NS_NOINTERFACE && e.result != Cr.NS_ERROR_NOT_AVAILABLE) {
+            throw e;
+          }
+          // Possible reasons we got here:
+          // - Its not a http channel (wtf? Oh well)
+          // - The owner is not a calICalendar (looks like its not our deal)
+          // - The WWW-Authenticate header is missing (that's ok)
+        }
+        break;
+      }
+    }
+  },
+
+  /**
+   * calICalendarManager interface
+   */
+  createCalendar(type, uri) {
+    try {
+      let calendar;
+      if (Cc["@mozilla.org/calendar/calendar;1?type=" + type]) {
+        calendar = Cc["@mozilla.org/calendar/calendar;1?type=" + type].createInstance(
+          Ci.calICalendar
+        );
+      } else if (this.providerImplementations[type]) {
+        let CalendarProvider = this.providerImplementations[type];
+        calendar = new CalendarProvider();
+        if (calendar.QueryInterface) {
+          calendar = calendar.QueryInterface(Ci.calICalendar);
+        }
+      } else {
+        // Don't notify the user with an extra dialog if the provider interface is missing.
+        return null;
+      }
+
+      calendar.uri = uri;
+      return calendar;
+    } catch (ex) {
+      let rc = ex;
+      if (ex instanceof Ci.nsIException) {
+        rc = ex.result;
+      }
+
+      let uiMessage = cal.l10n.getCalString("unableToCreateProvider", [uri.spec]);
+
+      // Log the original exception via error console to provide more debug info
+      cal.ERROR(ex);
+
+      // Log the possibly translated message via the UI.
+      let paramBlock = Cc["@mozilla.org/embedcomp/dialogparam;1"].createInstance(
+        Ci.nsIDialogParamBlock
+      );
+      paramBlock.SetNumberStrings(3);
+      paramBlock.SetString(0, uiMessage);
+      paramBlock.SetString(1, "0x" + rc.toString(0x10));
+      paramBlock.SetString(2, ex);
+      Services.ww.openWindow(
+        null,
+        "chrome://calendar/content/calendar-error-prompt.xhtml",
+        "_blank",
+        "chrome,dialog=yes,alwaysRaised=yes",
+        paramBlock
+      );
+      return null;
+    }
+  },
+
+  /**
+   * Creates a calendar and takes care of initial setup, including enabled/disabled properties and
+   * cached calendars. If the provider doesn't exist, returns a dummy calendar that is
+   * force-disabled.
+   *
+   * @param {string} id - The calendar id.
+   * @param {string} ctype - The calendar type. See {@link calICalendar#type}.
+   * @param {string} uri - The calendar uri.
+   * @returns {calICalendar} The initialized calendar or dummy calendar.
+   */
+  initializeCalendar(id, ctype, uri) {
+    let calendar = this.createCalendar(ctype, uri);
+    if (calendar) {
+      calendar.id = id;
+      if (calendar.getProperty("auto-enabled")) {
+        calendar.deleteProperty("disabled");
+        calendar.deleteProperty("auto-enabled");
+      }
+
+      calendar = maybeWrapCachedCalendar(calendar);
+    } else {
+      // Create dummy calendar that stays disabled for this run.
+      calendar = new calDummyCalendar(ctype);
+      calendar.id = id;
+      calendar.uri = uri;
+      // Try to enable on next startup if calendar has been enabled.
+      if (!calendar.getProperty("disabled")) {
+        calendar.setProperty("auto-enabled", true);
+      }
+      calendar.setProperty("disabled", true);
+    }
+
+    return calendar;
+  },
+
+  /**
+   * Update calendar registrations for the given type. If the provider is missing then the calendars
+   * are replaced with a dummy calendar, and vice versa.
+   *
+   * @param {string} type - The calendar type to update. See {@link calICalendar#type}.
+   * @param {boolean} [clearCache=false] - If true, the calendar cache is also cleared.
+   */
+  updateDummyCalendarRegistration(type, clearCache = false) {
+    let hasImplementation = !!this.providerImplementations[type];
+
+    let calendars = Object.values(this.mCache).filter(calendar => {
+      // Calendars backed by providers despite missing provider implementation, or dummy calendars
+      // despite having a provider implementation.
+      let isDummyCalendar = calendar instanceof calDummyCalendar;
+      return calendar.type == type && hasImplementation == isDummyCalendar;
+    });
+    this.updateCalendarRegistration(calendars, clearCache);
+  },
+
+  /**
+   * Update the calendar registrations for the given set of calendars. This essentially unregisters
+   * the calendar, then sets it up again using id, type and uri. This is similar to what happens on
+   * startup.
+   *
+   * @param {calICalendar[]} calendars - The calendars to update.
+   * @param {boolean} [clearCache=false] - If true, the calendar cache is also cleared.
+   */
+  updateCalendarRegistration(calendars, clearCache = false) {
+    let sortOrderPref = Services.prefs.getStringPref("calendar.list.sortOrder", "").split(" ");
+    let sortOrder = {};
+    for (let i = 0; i < sortOrderPref.length; i++) {
+      sortOrder[sortOrderPref[i]] = i;
+    }
+
+    let needsRefresh = [];
+    for (let calendar of calendars) {
+      try {
+        this.notifyObservers("onCalendarUnregistering", [calendar]);
+        this.unsetupCalendar(calendar, clearCache);
+
+        let replacement = this.initializeCalendar(calendar.id, calendar.type, calendar.uri);
+        replacement.setProperty("initialSortOrderPos", sortOrder[calendar.id]);
+
+        this.setupCalendar(replacement);
+        needsRefresh.push(replacement);
+      } catch (e) {
+        cal.ERROR(
+          `Can't create calendar for ${calendar.id} (${calendar.type}, ${calendar.uri.spec}): ${e}`
+        );
+      }
+    }
+
+    // Do this in a second pass so that all provider calendars are available.
+    for (let calendar of needsRefresh) {
+      maybeRefreshCalendar(calendar);
+      this.notifyObservers("onCalendarRegistered", [calendar]);
+    }
+  },
+
+  /**
+   * Register a calendar provider with the given JavaScript implementation.
+   *
+   * @param {string} type - The calendar type string, see {@link calICalendar#type}.
+   * @param {object} impl - The class that implements calICalendar.
+   */
+  registerCalendarProvider(type, impl) {
+    this.assureCache();
+
+    cal.ASSERT(
+      !this.providerImplementations.hasOwnProperty(type),
+      "[CalCalendarManager::registerCalendarProvider] provider already exists",
+      true
+    );
+
+    this.providerImplementations[type] = impl;
+    this.updateDummyCalendarRegistration(type);
+  },
+
+  /**
+   * Unregister a calendar provider by type. Already registered calendars will be replaced by a
+   * dummy calendar that is force-disabled.
+   *
+   * @param {string} type - The calendar type string, see {@link calICalendar#type}.
+   * @param {boolean} temporary - If true, cached calendars will not be cleared.
+   */
+  unregisterCalendarProvider(type, temporary = false) {
+    cal.ASSERT(
+      this.providerImplementations.hasOwnProperty(type),
+      "[CalCalendarManager::unregisterCalendarProvider] provider doesn't exist or is builtin",
+      true
+    );
+    delete this.providerImplementations[type];
+    this.updateDummyCalendarRegistration(type, !temporary);
+  },
+
+  /**
+   * Checks if a calendar provider has been dynamically registered with the given type. This does
+   * not check for the built-in XPCOM providers.
+   *
+   * @param {string} type - The calendar type string, see {@link calICalendar#type}.
+   * @returns {boolean} True, if the calendar provider type is registered.
+   */
+  hasCalendarProvider(type) {
+    return !!this.providerImplementations[type];
+  },
+
+  registerCalendar(calendar) {
+    this.assureCache();
+
+    // If the calendar is already registered, bail out
+    cal.ASSERT(
+      !calendar.id || !(calendar.id in this.mCache),
+      "[CalCalendarManager::registerCalendar] calendar already registered!",
+      true
+    );
+
+    if (!calendar.id) {
+      calendar.id = cal.getUUID();
+    }
+
+    Services.prefs.setStringPref(getPrefBranchFor(calendar.id) + "type", calendar.type);
+    Services.prefs.setStringPref(getPrefBranchFor(calendar.id) + "uri", calendar.uri.spec);
+
+    calendar = maybeWrapCachedCalendar(calendar);
+
+    this.setupCalendar(calendar);
+    flushPrefs();
+
+    maybeRefreshCalendar(calendar);
+    this.notifyObservers("onCalendarRegistered", [calendar]);
+  },
+
+  /**
+   * Sets up a calendar, this is the initialization required during calendar registration. See
+   * {@link #unsetupCalendar} to revert these steps.
+   *
+   * @param {calICalendar} calendar - The calendar to set up.
+   */
+  setupCalendar(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
+    if (calendar.getProperty("requiresNetwork") !== false) {
+      this.mNetworkCalendarCount++;
+    }
+    if (calendar.readOnly) {
+      this.mReadonlyCalendarCount++;
+    }
+    this.mCalendarCount++;
+
+    // Set up the refresh timer
+    this.setupRefreshTimer(calendar);
+  },
+
+  /**
+   * Reverts the calendar registration setup steps from {@link #setupCalendar}.
+   *
+   * @param {calICalendar} calendar - The calendar to undo setup for.
+   * @param {boolean} [clearCache=false] - If true, the cache is cleared for this calendar.
+   */
+  unsetupCalendar(calendar, clearCache = false) {
+    if (this.mCache) {
+      delete this.mCache[calendar.id];
+    }
+
+    if (clearCache && calendar.wrappedJSObject instanceof calCachedCalendar) {
+      calendar.wrappedJSObject.onCalendarUnregistering();
+    }
+
+    calendar.removeObserver(this.mCalObservers[calendar.id]);
+
+    if (calendar.readOnly) {
+      this.mReadonlyCalendarCount--;
+    }
+
+    if (calendar.getProperty("requiresNetwork") !== false) {
+      this.mNetworkCalendarCount--;
+    }
+    this.mCalendarCount--;
+
+    this.clearRefreshTimer(calendar);
+  },
+
+  setupRefreshTimer(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);
+
+    if (refreshInterval > 0) {
+      this.mRefreshTimer[aCalendar.id] = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+
+      this.mRefreshTimer[aCalendar.id].initWithCallback(
+        new timerCallback(aCalendar),
+        refreshInterval * 60000,
+        Ci.nsITimer.TYPE_REPEATING_SLACK
+      );
+    }
+  },
+
+  clearRefreshTimer(aCalendar) {
+    if (aCalendar.id in this.mRefreshTimer && this.mRefreshTimer[aCalendar.id]) {
+      this.mRefreshTimer[aCalendar.id].cancel();
+      delete this.mRefreshTimer[aCalendar.id];
+    }
+  },
+
+  unregisterCalendar(calendar) {
+    this.notifyObservers("onCalendarUnregistering", [calendar]);
+    this.unsetupCalendar(calendar, true);
+
+    deletePrefBranch(calendar.id);
+    flushPrefs();
+  },
+
+  removeCalendar(calendar, mode = 0) {
+    const cICM = Ci.calICalendarManager;
+
+    let removeModes = new Set(calendar.getProperty("capabilities.removeModes") || ["unsubscribe"]);
+    if (!removeModes.has("unsubscribe") && !removeModes.has("delete")) {
+      // Removing is not allowed
+      return;
+    }
+
+    if (mode & cICM.REMOVE_NO_UNREGISTER && this.mCache && calendar.id in this.mCache) {
+      throw new Components.Exception("Can't remove a registered calendar");
+    } else if (!(mode & cICM.REMOVE_NO_UNREGISTER)) {
+      this.unregisterCalendar(calendar);
+    }
+
+    // This observer notification needs to be fired for both unsubscribe
+    // and delete, we don't differ this at the moment.
+    this.notifyObservers("onCalendarDeleting", [calendar]);
+
+    // For deleting, we also call the deleteCalendar method from the provider.
+    if (removeModes.has("delete") && (mode & cICM.REMOVE_NO_DELETE) == 0) {
+      let wrappedCalendar = calendar.QueryInterface(Ci.calICalendarProvider);
+      wrappedCalendar.deleteCalendar(calendar, null);
+    }
+  },
+
+  getCalendarById(aId) {
+    if (aId in this.mCache) {
+      return this.mCache[aId];
+    }
+    return null;
+  },
+
+  getCalendars() {
+    this.assureCache();
+    let calendars = [];
+    for (let id in this.mCache) {
+      let calendar = this.mCache[id];
+      calendars.push(calendar);
+    }
+    return calendars;
+  },
+
+  /**
+   * Load calendars from the pref branch, if they haven't already been loaded. The calendar
+   * instances will end up in mCache and are refreshed when complete.
+   */
+  assureCache() {
+    if (this.mCache) {
+      return;
+    }
+
+    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;
+    }
+
+    for (let calBranch in allCals) {
+      let id = calBranch.substring(REGISTRY_BRANCH.length);
+      let ctype = Services.prefs.getStringPref(calBranch + ".type", null);
+      let curi = Services.prefs.getStringPref(calBranch + ".uri", null);
+
+      try {
+        if (!ctype || !curi) {
+          // sanity check
+          deletePrefBranch(id);
+          continue;
+        }
+
+        let uri = Services.io.newURI(curi);
+        let calendar = this.initializeCalendar(id, ctype, uri);
+        this.setupCalendar(calendar);
+      } catch (exc) {
+        cal.ERROR(`Can't create calendar for ${id} (${ctype}, ${curi}): ${exc}`);
+      }
+    }
+
+    let shouldResyncGoogleCalDav = false;
+    if (!Services.prefs.prefHasUserValue("calendar.caldav.googleResync")) {
+      // Some users' calendars got into a bad state due to Google rate-limit
+      // problems so this code triggers a full resync.
+      shouldResyncGoogleCalDav = true;
+    }
+
+    // do refreshing in a second step, when *all* calendars are already available
+    // via getCalendars():
+    for (let calendar of Object.values(this.mCache)) {
+      let delay = 0;
+
+      // The special-casing of ICS here is a very ugly hack. We can delay most
+      // cached calendars without an issue, but the ICS implementation has two
+      // properties which make that dangerous in its case:
+      //
+      // 1) ICS files can only be written whole cloth. Since it's a plain file,
+      // we need to know the entire contents of what we want to write.
+      //
+      // 2) It is backed by a memory calendar which it regards as its source of
+      // truth, and the backing calendar is only populated on a refresh.
+      //
+      // The combination of these two means that any update to the ICS calendar
+      // before the memory calendar is populated will erase everything in the
+      // calendar (except potentially the added item if that's what we're
+      // doing). A 15 second window for data loss-inducing updates isn't huge,
+      // but it's more than we should bet on.
+      //
+      // Why not fix this a different way? Trying to populate the memory
+      // calendar outside of a refresh causes the caching calendar to get
+      // confused about event ownership and identity, leading to bogus observer
+      // notifications and potential duplication of events in some parts of the
+      // interface. Having the ICS calendar refresh itself internally can cause
+      // disabled calendars to behave improperly, since calendars don't actually
+      // enforce their own disablement and may not know if they're disabled
+      // until after we try to refresh. Having the ICS calendar ensure it has
+      // refreshed itself before trying to make updates would require a fair bit
+      // of refactoring in its processing queue and, while it should probably
+      // happen, fingers crossed we can rework the provider architecture to make
+      // many of these problems less of an issue first.
+      const canDelay = calendar.getProperty("cache.enabled") && calendar.type != "ics";
+
+      if (canDelay) {
+        // If the calendar is cached, we don't need to refresh it RIGHT NOW, so let's wait a
+        // while and let other things happen first.
+        delay = 15000;
+
+        if (
+          shouldResyncGoogleCalDav &&
+          calendar.type == "caldav" &&
+          calendar.uri.prePath == "https://apidata.googleusercontent.com"
+        ) {
+          cal.LOG(`CalDAV: Resetting sync token of ${calendar.name} to perform a full resync`);
+          let calCachedCalendar = calendar.wrappedJSObject;
+          let calDavCalendar = calCachedCalendar.mUncachedCalendar.wrappedJSObject;
+          calDavCalendar.mWebdavSyncToken = null;
+          calDavCalendar.saveCalendarProperties();
+        }
+      }
+      setTimeout(() => maybeRefreshCalendar(calendar), delay);
+    }
+
+    if (shouldResyncGoogleCalDav) {
+      // Record the fact that we've scheduled a resync, so that we only do it once.
+      // Store the date instead of a boolean because we might want to use this again some day.
+      Services.prefs.setIntPref("calendar.caldav.googleResync", Date.now() / 1000);
+    }
+  },
+
+  getCalendarPref_(calendar, name) {
+    cal.ASSERT(calendar, "Invalid Calendar!");
+    cal.ASSERT(calendar.id !== null, "Calendar id needs to be set!");
+    cal.ASSERT(name && name.length > 0, "Pref Name must be non-empty!");
+
+    let branch = getPrefBranchFor(calendar.id) + name;
+    let value = Preferences.get(branch, null);
+
+    if (typeof value == "string" && value.startsWith("bignum:")) {
+      let converted = Number(value.substr(7));
+      if (!isNaN(converted)) {
+        value = converted;
+      }
+    }
+    return value;
+  },
+
+  setCalendarPref_(calendar, name, value) {
+    cal.ASSERT(calendar, "Invalid Calendar!");
+    cal.ASSERT(calendar.id !== null, "Calendar id needs to be set!");
+    cal.ASSERT(name && name.length > 0, "Pref Name must be non-empty!");
+
+    let branch = getPrefBranchFor(calendar.id) + name;
+
+    if (
+      typeof value == "number" &&
+      (value > MAX_INT || value < MIN_INT || !Number.isInteger(value))
+    ) {
+      // This is something the preferences service can't store directly.
+      // Convert to string and tag it so we know how to handle it.
+      value = "bignum:" + value;
+    }
+
+    // Delete before to allow pref-type changes, then set the pref.
+    Services.prefs.clearUserPref(branch);
+    if (value !== null && value !== undefined) {
+      Preferences.set(branch, value);
+    }
+  },
+
+  deleteCalendarPref_(calendar, name) {
+    cal.ASSERT(calendar, "Invalid Calendar!");
+    cal.ASSERT(calendar.id !== null, "Calendar id needs to be set!");
+    cal.ASSERT(name && name.length > 0, "Pref Name must be non-empty!");
+    Services.prefs.clearUserPref(getPrefBranchFor(calendar.id) + name);
+  },
+
+  mObservers: null,
+  addObserver(aObserver) {
+    this.mObservers.add(aObserver);
+  },
+  removeObserver(aObserver) {
+    this.mObservers.delete(aObserver);
+  },
+  notifyObservers(functionName, args) {
+    this.mObservers.notify(functionName, args);
+  },
+
+  mCalendarObservers: null,
+  addCalendarObserver(aObserver) {
+    return this.mCalendarObservers.add(aObserver);
+  },
+  removeCalendarObserver(aObserver) {
+    return this.mCalendarObservers.delete(aObserver);
+  },
+  notifyCalendarObservers(functionName, args) {
+    this.mCalendarObservers.notify(functionName, args);
+  },
+};
+
+function equalMessage(msg1, msg2) {
+  if (
+    msg1.GetString(0) == msg2.GetString(0) &&
+    msg1.GetString(1) == msg2.GetString(1) &&
+    msg1.GetString(2) == msg2.GetString(2)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function calMgrCalendarObserver(calendar, calMgr) {
+  this.calendar = calendar;
+  // We compare this to determine if the state actually changed.
+  this.storedReadOnly = calendar.readOnly;
+  this.announcedMessages = [];
+  this.calMgr = calMgr;
+}
+
+calMgrCalendarObserver.prototype = {
+  calendar: null,
+  storedReadOnly: null,
+  calMgr: null,
+
+  QueryInterface: ChromeUtils.generateQI(["nsIWindowMediatorListener", "calIObserver"]),
+
+  // calIObserver:
+  onStartBatch() {
+    return this.calMgr.notifyCalendarObservers("onStartBatch", arguments);
+  },
+  onEndBatch() {
+    return this.calMgr.notifyCalendarObservers("onEndBatch", arguments);
+  },
+  onLoad(calendar) {
+    return this.calMgr.notifyCalendarObservers("onLoad", arguments);
+  },
+  onAddItem(aItem) {
+    return this.calMgr.notifyCalendarObservers("onAddItem", arguments);
+  },
+  onModifyItem(aNewItem, aOldItem) {
+    return this.calMgr.notifyCalendarObservers("onModifyItem", arguments);
+  },
+  onDeleteItem(aDeletedItem) {
+    return this.calMgr.notifyCalendarObservers("onDeleteItem", arguments);
+  },
+  onError(aCalendar, aErrNo, aMessage) {
+    this.calMgr.notifyCalendarObservers("onError", arguments);
+    this.announceError(aCalendar, aErrNo, aMessage);
+  },
+
+  onPropertyChanged(aCalendar, aName, aValue, aOldValue) {
+    this.calMgr.notifyCalendarObservers("onPropertyChanged", arguments);
+    switch (aName) {
+      case "requiresNetwork":
+        this.calMgr.mNetworkCalendarCount += aValue ? 1 : -1;
+        break;
+      case "readOnly":
+        this.calMgr.mReadonlyCalendarCount += aValue ? 1 : -1;
+        break;
+      case "refreshInterval":
+        this.calMgr.setupRefreshTimer(aCalendar);
+        break;
+      case "cache.enabled":
+        this.changeCalendarCache(...arguments);
+        break;
+      case "disabled":
+        if (!aValue && aCalendar.canRefresh) {
+          aCalendar.refresh();
+        }
+        break;
+    }
+  },
+
+  changeCalendarCache(aCalendar, aName, aValue, aOldValue) {
+    const cICM = Ci.calICalendarManager;
+    aOldValue = aOldValue || false;
+    aValue = aValue || false;
+
+    // hack for bug 1182264 to deal with calendars, which have set cache.enabled, but in fact do
+    // not support caching (like storage calendars) - this also prevents enabling cache again
+    if (aCalendar.getProperty("cache.supported") === false) {
+      if (aCalendar.getProperty("cache.enabled") === true) {
+        aCalendar.deleteProperty("cache.enabled");
+      }
+      return;
+    }
+
+    if (aOldValue != aValue) {
+      // Try to find the current sort order
+      let sortOrderPref = Services.prefs.getStringPref("calendar.list.sortOrder", "").split(" ");
+      let initialSortOrderPos = null;
+      for (let i = 0; i < sortOrderPref.length; ++i) {
+        if (sortOrderPref[i] == aCalendar.id) {
+          initialSortOrderPos = i;
+        }
+      }
+      // Enabling or disabling cache on a calendar re-creates
+      // it so the registerCalendar call can wrap/unwrap the
+      // calCachedCalendar facade saving the user the need to
+      // restart Thunderbird and making sure a new Id is used.
+      this.calMgr.removeCalendar(aCalendar, cICM.REMOVE_NO_DELETE);
+      let newCal = this.calMgr.createCalendar(aCalendar.type, aCalendar.uri);
+      newCal.name = aCalendar.name;
+
+      // TODO: if properties get added this list will need to be adjusted,
+      // ideally we should add a "getProperties" method to calICalendar.idl
+      // to retrieve all non-transient properties for a calendar.
+      let propsToCopy = [
+        "color",
+        "disabled",
+        "auto-enabled",
+        "cache.enabled",
+        "refreshInterval",
+        "suppressAlarms",
+        "calendar-main-in-composite",
+        "calendar-main-default",
+        "readOnly",
+        "imip.identity.key",
+        "username",
+      ];
+      for (let prop of propsToCopy) {
+        newCal.setProperty(prop, aCalendar.getProperty(prop));
+      }
+
+      if (initialSortOrderPos != null) {
+        newCal.setProperty("initialSortOrderPos", initialSortOrderPos);
+      }
+      this.calMgr.registerCalendar(newCal);
+    } else if (aCalendar.wrappedJSObject instanceof calCachedCalendar) {
+      // any attempt to switch this flag will reset the cached calendar;
+      // could be useful for users in case the cache may be corrupted.
+      aCalendar.wrappedJSObject.setupCachedCalendar();
+    }
+  },
+
+  onPropertyDeleting(aCalendar, aName) {
+    this.onPropertyChanged(aCalendar, aName, false, true);
+  },
+
+  // Error announcer specific functions
+  announceError(aCalendar, aErrNo, aMessage) {
+    let paramBlock = Cc["@mozilla.org/embedcomp/dialogparam;1"].createInstance(
+      Ci.nsIDialogParamBlock
+    );
+    let props = Services.strings.createBundle("chrome://calendar/locale/calendar.properties");
+    let errMsg;
+    paramBlock.SetNumberStrings(3);
+    if (!this.storedReadOnly && this.calendar.readOnly) {
+      // Major errors change the calendar to readOnly
+      errMsg = props.formatStringFromName("readOnlyMode", [this.calendar.name]);
+    } else if (!this.storedReadOnly && !this.calendar.readOnly) {
+      // Minor errors don't, but still tell the user something went wrong
+      errMsg = props.formatStringFromName("minorError", [this.calendar.name]);
+    } else {
+      // The calendar was already in readOnly mode, but still tell the user
+      errMsg = props.formatStringFromName("stillReadOnlyError", [this.calendar.name]);
+    }
+
+    // When possible, change the error number into its name, to
+    // make it slightly more readable.
+    let errCode = "0x" + aErrNo.toString(16);
+    const calIErrors = Ci.calIErrors;
+    // Check if it is worth enumerating all the error codes.
+    if (aErrNo & calIErrors.ERROR_BASE) {
+      for (let err in calIErrors) {
+        if (calIErrors[err] == aErrNo) {
+          errCode = err;
+        }
+      }
+    }
+
+    let message;
+    switch (aErrNo) {
+      case calIErrors.CAL_UTF8_DECODING_FAILED:
+        message = props.GetStringFromName("utf8DecodeError");
+        break;
+      case calIErrors.ICS_MALFORMEDDATA:
+        message = props.GetStringFromName("icsMalformedError");
+        break;
+      case calIErrors.MODIFICATION_FAILED:
+        errMsg = cal.l10n.getCalString("errorWriting2", [aCalendar.name]);
+        message = cal.l10n.getCalString("errorWritingDetails");
+        if (aMessage) {
+          message = aMessage + "\n" + message;
+        }
+        break;
+      default:
+        message = aMessage;
+    }
+
+    paramBlock.SetString(0, errMsg);
+    paramBlock.SetString(1, errCode);
+    paramBlock.SetString(2, message);
+
+    this.storedReadOnly = this.calendar.readOnly;
+    let errorCode = cal.l10n.getCalString("errorCode", [errCode]);
+    let errorDescription = cal.l10n.getCalString("errorDescription", [message]);
+    let summary = errMsg + " " + errorCode + ". " + errorDescription;
+
+    // Log warnings in error console.
+    // Report serious errors in both error console and in prompt window.
+    if (aErrNo == calIErrors.MODIFICATION_FAILED) {
+      console.error(summary);
+      this.announceParamBlock(paramBlock);
+    } else {
+      cal.WARN(summary);
+    }
+  },
+
+  announceParamBlock(paramBlock) {
+    function awaitLoad(event) {
+      promptWindow.addEventListener("unload", awaitUnload, { capture: false, once: true });
+    }
+    let awaitUnload = event => {
+      // unloaded (user closed prompt window),
+      // remove paramBlock and unload listener.
+      try {
+        // remove the message that has been shown from
+        // the list of all announced messages.
+        this.announcedMessages = this.announcedMessages.filter(msg => {
+          return !equalMessage(msg, paramBlock);
+        });
+      } catch (e) {
+        console.error(e);
+      }
+    };
+
+    // silently don't do anything if this message already has been
+    // announced without being acknowledged.
+    if (this.announcedMessages.some(equalMessage.bind(null, paramBlock))) {
+      return;
+    }
+
+    // this message hasn't been announced recently, remember the details of
+    // the message for future reference.
+    this.announcedMessages.push(paramBlock);
+
+    // Will remove paramBlock from announced messages when promptWindow is
+    // closed.  (Closing fires unloaded event, but promptWindow is also
+    // unloaded [to clean it?] before loading, so wait for detected load
+    // event before detecting unload event that signifies user closed this
+    // prompt window.)
+    let promptUrl = "chrome://calendar/content/calendar-error-prompt.xhtml";
+    let features = "chrome,dialog=yes,alwaysRaised=yes";
+    let promptWindow = Services.ww.openWindow(null, promptUrl, "_blank", features, paramBlock);
+    promptWindow.addEventListener("load", awaitLoad, { capture: false, once: true });
+  },
+};
+
+function calDummyCalendar(type) {
+  this.initProviderBase();
+  this.type = type;
+}
+calDummyCalendar.prototype = {
+  __proto__: cal.provider.BaseClass.prototype,
+
+  getProperty(aName) {
+    switch (aName) {
+      case "force-disabled":
+        return true;
+      default:
+        return this.__proto__.__proto__.getProperty.apply(this, arguments);
+    }
+  },
+};
+
+function getPrefBranchFor(id) {
+  return REGISTRY_BRANCH + id + ".";
+}
+
+/**
+ * Removes a calendar from the preferences.
+ *
+ * @param {string} id - ID of the calendar to remove.
+ */
+function deletePrefBranch(id) {
+  for (let prefName of Services.prefs.getChildList(getPrefBranchFor(id))) {
+    Services.prefs.clearUserPref(prefName);
+  }
+}
+
+/**
+ * Helper to refresh a calendar, if it can be refreshed and isn't disabled.
+ *
+ * @param {calICalendar} calendar - The calendar to refresh.
+ */
+function maybeRefreshCalendar(calendar) {
+  if (!calendar.getProperty("disabled") && calendar.canRefresh) {
+    let refreshInterval = calendar.getProperty("refreshInterval");
+    if (refreshInterval != "0") {
+      calendar.refresh();
+    }
+  }
+}
+
+/**
+ * Wrap a calendar using {@link calCachedCalendar}, if the cache is supported and enabled.
+ * Otherwise just return the passed in calendar.
+ *
+ * @param {calICalendar} calendar - The calendar to potentially wrap.
+ * @returns {calICalendar} The potentially wrapped calendar.
+ */
+function maybeWrapCachedCalendar(calendar) {
+  if (
+    calendar.getProperty("cache.supported") !== false &&
+    (calendar.getProperty("cache.enabled") || calendar.getProperty("cache.always"))
+  ) {
+    calendar = new calCachedCalendar(calendar);
+  }
+  return calendar;
+}
+
+/**
+ * Helper function to flush the preferences file. If the application crashes
+ * after a calendar has been created using the prefs registry, then the calendar
+ * won't show up. Writing the prefs helps counteract.
+ */
+function flushPrefs() {
+  Services.prefs.savePrefFile(null);
+}
+
+/**
+ * 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 (aTimer) {
+    if (!aCalendar.getProperty("disabled") && aCalendar.canRefresh) {
+      aCalendar.refresh();
+    }
+  };
+}
+
+var gCalendarManagerAddonListener = {
+  onDisabling(aAddon, aNeedsRestart) {
+    if (!this.queryUninstallProvider(aAddon)) {
+      // If the addon should not be disabled, then re-enable it.
+      aAddon.userDisabled = false;
+    }
+  },
+
+  onUninstalling(aAddon, aNeedsRestart) {
+    if (!this.queryUninstallProvider(aAddon)) {
+      // If the addon should not be uninstalled, then cancel the uninstall.
+      aAddon.cancelUninstall();
+    }
+  },
+
+  queryUninstallProvider(aAddon) {
+    const uri = "chrome://calendar/content/calendar-providerUninstall-dialog.xhtml";
+    const features = "chrome,titlebar,resizable,modal";
+    let affectedCalendars = cal.manager
+      .getCalendars()
+      .filter(calendar => calendar.providerID == aAddon.id);
+    if (!affectedCalendars.length) {
+      // If no calendars are affected, then everything is fine.
+      return true;
+    }
+
+    let args = { shouldUninstall: false, extension: aAddon };
+
+    // Now find a window. The best choice would be the most recent
+    // addons window, otherwise the most recent calendar window, or we
+    // create a new toplevel window.
+    let win =
+      Services.wm.getMostRecentWindow("Extension:Manager") || cal.window.getCalendarWindow();
+    if (win) {
+      win.openDialog(uri, "CalendarProviderUninstallDialog", features, args);
+    } else {
+      // Use the window watcher to open a parentless window.
+      Services.ww.openWindow(null, uri, "CalendarProviderUninstallWindow", features, args);
+    }
+
+    // Now that we are done, check if the dialog was accepted or canceled.
+    return args.shouldUninstall;
+  },
+};
+
+function appendToRealm(authHeader, appendStr) {
+  let isEscaped = false;
+  let idx = authHeader.search(/realm="(.*?)(\\*)"/);
+  if (idx > -1) {
+    let remain = authHeader.substr(idx + 7);
+    idx += 7;
+    while (remain.length && !isEscaped) {
+      let match = remain.match(/(.*?)(\\*)"/);
+      idx += match[0].length;
+
+      isEscaped = match[2].length % 2 == 0;
+      if (!isEscaped) {
+        remain = remain.substr(match[0].length);
+      }
+    }
+    return authHeader.substr(0, idx - 1) + " " + appendStr + authHeader.substr(idx - 1);
+  }
+  return authHeader;
+}