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

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

19 files changed, 3633 insertions, 0 deletions

diff --git a/comm/mail/components/activity/Activity.jsm b/comm/mail/components/activity/Activity.jsm
new file mode 100644
index 0000000000..1b23efe1c7
--- /dev/null
+++ b/comm/mail/components/activity/Activity.jsm
@@ -0,0 +1,322 @@
+/* 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/. */
+
+var EXPORTED_SYMBOLS = ["ActivityProcess", "ActivityEvent", "ActivityWarning"];
+
+// Base class for ActivityProcess and ActivityEvent objects
+
+function Activity() {
+  this._initLogging();
+  this._listeners = [];
+  this._subjects = [];
+}
+
+Activity.prototype = {
+  id: -1,
+  bindingName: "",
+  iconClass: "",
+  groupingStyle: Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT,
+  facet: "",
+  displayText: "",
+  initiator: null,
+  contextType: "",
+  context: "",
+  contextObj: null,
+
+  _initLogging() {
+    this.log = console.createInstance({
+      prefix: "mail.activity",
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mail.activity.loglevel",
+    });
+  },
+
+  addListener(aListener) {
+    this._listeners.push(aListener);
+  },
+
+  removeListener(aListener) {
+    for (let i = 0; i < this._listeners.length; i++) {
+      if (this._listeners[i] == aListener) {
+        this._listeners.splice(i, 1);
+        break;
+      }
+    }
+  },
+
+  addSubject(aSubject) {
+    this._subjects.push(aSubject);
+  },
+
+  getSubjects() {
+    return this._subjects.slice();
+  },
+};
+
+function ActivityProcess() {
+  Activity.call(this);
+  this.bindingName = "activity-process-item";
+  this.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT;
+}
+
+ActivityProcess.prototype = {
+  __proto__: Activity.prototype,
+
+  percentComplete: -1,
+  lastStatusText: "",
+  workUnitComplete: 0,
+  totalWorkUnits: 0,
+  startTime: Date.now(),
+  _cancelHandler: null,
+  _pauseHandler: null,
+  _retryHandler: null,
+  _state: Ci.nsIActivityProcess.STATE_INPROGRESS,
+
+  init(aDisplayText, aInitiator) {
+    this.displayText = aDisplayText;
+    this.initiator = aInitiator;
+  },
+
+  get state() {
+    return this._state;
+  },
+
+  set state(val) {
+    if (val == this._state) {
+      return;
+    }
+
+    // test validity of the new state
+    //
+    if (
+      this._state == Ci.nsIActivityProcess.STATE_INPROGRESS &&
+      !(
+        val == Ci.nsIActivityProcess.STATE_COMPLETED ||
+        val == Ci.nsIActivityProcess.STATE_CANCELED ||
+        val == Ci.nsIActivityProcess.STATE_WAITINGFORRETRY ||
+        val == Ci.nsIActivityProcess.STATE_WAITINGFORINPUT ||
+        val == Ci.nsIActivityProcess.STATE_PAUSED
+      )
+    ) {
+      throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    // we cannot change the state after the activity is completed,
+    // or it is canceled.
+    if (
+      this._state == Ci.nsIActivityProcess.STATE_COMPLETED ||
+      this._state == Ci.nsIActivityProcess.STATE_CANCELED
+    ) {
+      throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    if (
+      this._state == Ci.nsIActivityProcess.STATE_PAUSED &&
+      !(
+        val == Ci.nsIActivityProcess.STATE_COMPLETED ||
+        val == Ci.nsIActivityProcess.STATE_INPROGRESS ||
+        val == Ci.nsIActivityProcess.STATE_WAITINGFORRETRY ||
+        val == Ci.nsIActivityProcess.STATE_WAITINGFORINPUT ||
+        val == Ci.nsIActivityProcess.STATE_CANCELED
+      )
+    ) {
+      throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    if (
+      this._state == Ci.nsIActivityProcess.STATE_WAITINGFORINPUT &&
+      !(
+        val == Ci.nsIActivityProcess.STATE_INPROGRESS ||
+        val == Ci.nsIActivityProcess.STATE_CANCELED
+      )
+    ) {
+      throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    if (
+      this._state == Ci.nsIActivityProcess.STATE_WAITINGFORRETRY &&
+      !(
+        val == Ci.nsIActivityProcess.STATE_INPROGRESS ||
+        val == Ci.nsIActivityProcess.STATE_CANCELED
+      )
+    ) {
+      throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    let oldState = this._state;
+    this._state = val;
+
+    // let the listeners know about the change
+    this.log.debug("Notifying onStateChanged listeners");
+    for (let value of this._listeners) {
+      try {
+        value.onStateChanged(this, oldState);
+      } catch (e) {
+        this.log.error("Exception thrown by onStateChanged listener: " + e);
+      }
+    }
+  },
+
+  setProgress(aStatusText, aWorkUnitsComplete, aTotalWorkUnits) {
+    if (aTotalWorkUnits == 0) {
+      this.percentComplete = -1;
+      this.workUnitComplete = 0;
+      this.totalWorkUnits = 0;
+    } else {
+      this.percentComplete = parseInt(
+        (100.0 * aWorkUnitsComplete) / aTotalWorkUnits
+      );
+      this.workUnitComplete = aWorkUnitsComplete;
+      this.totalWorkUnits = aTotalWorkUnits;
+    }
+    this.lastStatusText = aStatusText;
+
+    // notify listeners
+    for (let value of this._listeners) {
+      try {
+        value.onProgressChanged(
+          this,
+          aStatusText,
+          aWorkUnitsComplete,
+          aTotalWorkUnits
+        );
+      } catch (e) {
+        this.log.error("Exception thrown by onProgressChanged listener: " + e);
+      }
+    }
+  },
+
+  get cancelHandler() {
+    return this._cancelHandler;
+  },
+
+  set cancelHandler(val) {
+    this._cancelHandler = val;
+
+    // let the listeners know about the change
+    this.log.debug("Notifying onHandlerChanged listeners");
+    for (let value of this._listeners) {
+      try {
+        value.onHandlerChanged(this);
+      } catch (e) {
+        this.log.error("Exception thrown by onHandlerChanged listener: " + e);
+      }
+    }
+  },
+
+  get pauseHandler() {
+    return this._pauseHandler;
+  },
+
+  set pauseHandler(val) {
+    this._pauseHandler = val;
+
+    // let the listeners know about the change
+    this.log.debug("Notifying onHandlerChanged listeners");
+    for (let value of this._listeners) {
+      value.onHandlerChanged(this);
+    }
+  },
+
+  get retryHandler() {
+    return this._retryHandler;
+  },
+
+  set retryHandler(val) {
+    this._retryHandler = val;
+
+    // let the listeners know about the change
+    this.log.debug("Notifying onHandlerChanged listeners");
+    for (let value of this._listeners) {
+      value.onHandlerChanged(this);
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIActivityProcess", "nsIActivity"]),
+};
+
+function ActivityEvent() {
+  Activity.call(this);
+  this.bindingName = "activity-event-item";
+  this.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_STANDALONE;
+}
+
+ActivityEvent.prototype = {
+  __proto__: Activity.prototype,
+
+  statusText: "",
+  startTime: 0,
+  completionTime: 0,
+  _undoHandler: null,
+
+  init(aDisplayText, aInitiator, aStatusText, aStartTime, aCompletionTime) {
+    this.displayText = aDisplayText;
+    this.statusText = aStatusText;
+    this.startTime = aStartTime;
+    if (aCompletionTime) {
+      this.completionTime = aCompletionTime;
+    } else {
+      this.completionTime = Date.now();
+    }
+    this.initiator = aInitiator;
+    this._completionTime = aCompletionTime;
+  },
+
+  get undoHandler() {
+    return this._undoHandler;
+  },
+
+  set undoHandler(val) {
+    this._undoHandler = val;
+
+    // let the listeners know about the change
+    this.log.debug("Notifying onHandlerChanged listeners");
+    for (let value of this._listeners) {
+      value.onHandlerChanged(this);
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIActivityEvent", "nsIActivity"]),
+};
+
+function ActivityWarning() {
+  Activity.call(this);
+  this.bindingName = "activity-warning-item";
+  this.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT;
+}
+
+ActivityWarning.prototype = {
+  __proto__: Activity.prototype,
+
+  recoveryTipText: "",
+  _time: 0,
+  _recoveryHandler: null,
+
+  init(aWarningText, aInitiator, aRecoveryTipText) {
+    this.displayText = aWarningText;
+    this.initiator = aInitiator;
+    this.recoveryTipText = aRecoveryTipText;
+    this._time = Date.now();
+  },
+
+  get recoveryHandler() {
+    return this._recoveryHandler;
+  },
+
+  set recoveryHandler(val) {
+    this._recoveryHandler = val;
+
+    // let the listeners know about the change
+    this.log.debug("Notifying onHandlerChanged listeners");
+    for (let value of this._listeners) {
+      value.onHandlerChanged(this);
+    }
+  },
+
+  get time() {
+    return this._time;
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIActivityWarning", "nsIActivity"]),
+};
diff --git a/comm/mail/components/activity/ActivityManager.jsm b/comm/mail/components/activity/ActivityManager.jsm
new file mode 100644
index 0000000000..c808cb3354
--- /dev/null
+++ b/comm/mail/components/activity/ActivityManager.jsm
@@ -0,0 +1,157 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+var EXPORTED_SYMBOLS = ["ActivityManager"];
+
+function ActivityManager() {}
+
+ActivityManager.prototype = {
+  log: console.createInstance({
+    prefix: "mail.activity",
+    maxLogLevel: "Warn",
+    maxLogLevelPref: "mail.activity.loglevel",
+  }),
+  _listeners: [],
+  _processCount: 0,
+  _db: null,
+  _idCounter: 1,
+  _activities: new Map(),
+
+  get processCount() {
+    let count = 0;
+    for (let value of this._activities.values()) {
+      if (value instanceof Ci.nsIActivityProcess) {
+        count++;
+      }
+    }
+
+    return count;
+  },
+
+  getProcessesByContext(aContextType, aContextObj) {
+    let list = [];
+    for (let activity of this._activities.values()) {
+      if (
+        activity instanceof Ci.nsIActivityProcess &&
+        activity.contextType == aContextType &&
+        activity.contextObj == aContextObj
+      ) {
+        list.push(activity);
+      }
+    }
+    return list;
+  },
+
+  get db() {
+    return null;
+  },
+
+  get nextId() {
+    return this._idCounter++;
+  },
+
+  addActivity(aActivity) {
+    try {
+      this.log.info("adding Activity");
+      // get the next valid id for this activity
+      let id = this.nextId;
+      aActivity.id = id;
+
+      // add activity into the activities table
+      this._activities.set(id, aActivity);
+      // notify all the listeners
+      for (let value of this._listeners) {
+        try {
+          value.onAddedActivity(id, aActivity);
+        } catch (e) {
+          this.log.error("Exception calling onAddedActivity" + e);
+        }
+      }
+      return id;
+    } catch (e) {
+      // for some reason exceptions don't end up on the console if we don't
+      // explicitly log them.
+      this.log.error("Exception: " + e);
+      throw e;
+    }
+  },
+
+  removeActivity(aID) {
+    let activity = this.getActivity(aID);
+    if (!activity) {
+      return; // Nothing to remove.
+    }
+
+    // make sure that the activity is not in-progress state
+    if (
+      activity instanceof Ci.nsIActivityProcess &&
+      activity.state == Ci.nsIActivityProcess.STATE_INPROGRESS
+    ) {
+      throw Components.Exception(`Activity in progress`, Cr.NS_ERROR_FAILURE);
+    }
+
+    // remove the activity
+    this._activities.delete(aID);
+
+    // notify all the listeners
+    for (let value of this._listeners) {
+      try {
+        value.onRemovedActivity(aID);
+      } catch (e) {
+        // ignore the exception
+      }
+    }
+  },
+
+  cleanUp() {
+    // Get the list of aIDs.
+    this.log.info("cleanUp\n");
+    for (let [id, activity] of this._activities) {
+      if (activity instanceof Ci.nsIActivityProcess) {
+        // Note: The .state property will return undefined if you aren't in
+        //       this if-instanceof block.
+        let state = activity.state;
+        if (
+          state != Ci.nsIActivityProcess.STATE_INPROGRESS &&
+          state != Ci.nsIActivityProcess.STATE_PAUSED &&
+          state != Ci.nsIActivityProcess.STATE_WAITINGFORINPUT &&
+          state != Ci.nsIActivityProcess.STATE_WAITINGFORRETRY
+        ) {
+          this.removeActivity(id);
+        }
+      } else {
+        this.removeActivity(id);
+      }
+    }
+  },
+
+  getActivity(aID) {
+    return this._activities.get(aID);
+  },
+
+  containsActivity(aID) {
+    return this._activities.has(aID);
+  },
+
+  getActivities() {
+    return [...this._activities.values()];
+  },
+
+  addListener(aListener) {
+    this.log.info("addListener\n");
+    this._listeners.push(aListener);
+  },
+
+  removeListener(aListener) {
+    this.log.info("removeListener\n");
+    for (let i = 0; i < this._listeners.length; i++) {
+      if (this._listeners[i] == aListener) {
+        this._listeners.splice(i, 1);
+      }
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIActivityManager"]),
+};
diff --git a/comm/mail/components/activity/ActivityManagerUI.jsm b/comm/mail/components/activity/ActivityManagerUI.jsm
new file mode 100644
index 0000000000..b36b9b5a72
--- /dev/null
+++ b/comm/mail/components/activity/ActivityManagerUI.jsm
@@ -0,0 +1,47 @@
+/* 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/. */
+
+var EXPORTED_SYMBOLS = ["ActivityManagerUI"];
+
+const ACTIVITY_MANAGER_URL = "chrome://messenger/content/activity.xhtml";
+
+function ActivityManagerUI() {}
+
+ActivityManagerUI.prototype = {
+  show(aWindowContext, aID) {
+    // First we see if it is already visible
+    let window = this.recentWindow;
+    if (window) {
+      window.focus();
+      return;
+    }
+
+    let parent = null;
+    try {
+      if (aWindowContext) {
+        parent = aWindowContext.docShell.domWindow;
+      }
+    } catch (e) {
+      /* it's OK to not have a parent window */
+    }
+
+    Services.ww.openWindow(
+      parent,
+      ACTIVITY_MANAGER_URL,
+      "ActivityManager",
+      "chrome,dialog=no,resizable",
+      {}
+    );
+  },
+
+  get visible() {
+    return null != this.recentWindow;
+  },
+
+  get recentWindow() {
+    return Services.wm.getMostRecentWindow("Activity:Manager");
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIActivityManagerUI"]),
+};
diff --git a/comm/mail/components/activity/components.conf b/comm/mail/components/activity/components.conf
new file mode 100644
index 0000000000..429fd62bb8
--- /dev/null
+++ b/comm/mail/components/activity/components.conf
@@ -0,0 +1,38 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+Classes = [
+  {
+    'cid': '{B2C036A3-F7CE-401C-95EE-9C21505167FD}',
+    'contract_ids': ['@mozilla.org/activity-process;1'],
+    'jsm': 'resource:///modules/Activity.jsm',
+    'constructor': 'ActivityProcess',
+  },
+  {
+    'cid': '{87AAEB20-89D9-4B95-9542-3BF72405CAB2}',
+    'contract_ids': ['@mozilla.org/activity-event;1'],
+    'jsm': 'resource:///modules/Activity.jsm',
+    'constructor': 'ActivityEvent',
+  },
+  {
+    'cid': '{968BAC9E-798B-4952-B384-86B21B8CC71E}',
+    'contract_ids': ['@mozilla.org/activity-warning;1'],
+    'jsm': 'resource:///modules/Activity.jsm',
+    'constructor': 'ActivityWarning',
+  },
+  {
+    'cid': '{8aa5972e-19cb-41cc-9696-645f8a8d1a06}',
+    'contract_ids': ['@mozilla.org/activity-manager;1'],
+    'jsm': 'resource:///modules/ActivityManager.jsm',
+    'constructor': 'ActivityManager',
+  },
+  {
+    'cid': '{5fa5974e-09cb-40cc-9696-643f8a8d9a06}',
+    'contract_ids': ['@mozilla.org/activity-manager-ui;1'],
+    'jsm': 'resource:///modules/ActivityManagerUI.jsm',
+    'constructor': 'ActivityManagerUI',
+  },
+]
diff --git a/comm/mail/components/activity/content/activity-widgets.js b/comm/mail/components/activity/content/activity-widgets.js
new file mode 100644
index 0000000000..44ee16bff8
--- /dev/null
+++ b/comm/mail/components/activity/content/activity-widgets.js
@@ -0,0 +1,384 @@
+/* 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/. */
+
+"use strict";
+
+/* global MozXULElement, activityManager */
+
+// Wrap in a block to prevent leaking to window scope.
+{
+  const { makeFriendlyDateAgo } = ChromeUtils.import(
+    "resource:///modules/TemplateUtils.jsm"
+  );
+
+  let activityStrings = Services.strings.createBundle(
+    "chrome://messenger/locale/activity.properties"
+  );
+
+  /**
+   * The ActivityItemBase widget is the base class for all the activity item.
+   * It initializes activity details: i.e. id, status, icon, name, progress,
+   * date etc. for the activity widgets.
+   *
+   * @abstract
+   * @augments HTMLLIElement
+   */
+  class ActivityItemBase extends HTMLLIElement {
+    connectedCallback() {
+      if (!this.hasChildNodes()) {
+        // fetch the activity and set the base attributes
+        this.log = console.createInstance({
+          prefix: "mail.activity",
+          maxLogLevel: "Warn",
+          maxLogLevelPref: "mail.activity.loglevel",
+        });
+        let actID = this.getAttribute("actID");
+        this._activity = activityManager.getActivity(actID);
+        this._activity.QueryInterface(this.constructor.activityInterface);
+
+        // Construct the children.
+        this.classList.add("activityitem");
+
+        let icon = document.createElement("img");
+        icon.setAttribute(
+          "src",
+          this._activity.iconClass
+            ? `chrome://messenger/skin/icons/new/activity/${this._activity.iconClass}Icon.svg`
+            : this.constructor.defaultIconSrc
+        );
+        icon.setAttribute("alt", "");
+        this.appendChild(icon);
+
+        let display = document.createElement("span");
+        display.classList.add("displayText");
+        this.appendChild(display);
+
+        if (this.isEvent || this.isWarning) {
+          let time = document.createElement("time");
+          time.classList.add("dateTime");
+          this.appendChild(time);
+        }
+
+        if (this.isProcess) {
+          let progress = document.createElement("progress");
+          progress.setAttribute("value", "0");
+          progress.setAttribute("max", "100");
+          progress.classList.add("progressmeter");
+          this.appendChild(progress);
+        }
+
+        let statusText = document.createElement("span");
+        statusText.setAttribute("role", "note");
+        statusText.classList.add("statusText");
+        this.appendChild(statusText);
+      }
+      // (Re-)Attach the listener.
+      this.attachToActivity();
+    }
+
+    disconnectedCallback() {
+      this.detachFromActivity();
+    }
+
+    get isProcess() {
+      return this.constructor.activityInterface == Ci.nsIActivityProcess;
+    }
+
+    get isEvent() {
+      return this.constructor.activityInterface == Ci.nsIActivityEvent;
+    }
+
+    get isWarning() {
+      return this.constructor.activityInterface == Ci.nsIActivityWarning;
+    }
+
+    get isGroup() {
+      return false;
+    }
+
+    get activity() {
+      return this._activity;
+    }
+
+    detachFromActivity() {
+      if (this.activityListener) {
+        this._activity.removeListener(this.activityListener);
+      }
+    }
+
+    attachToActivity() {
+      if (this.activityListener) {
+        this._activity.addListener(this.activityListener);
+      }
+    }
+
+    static _dateTimeFormatter = new Services.intl.DateTimeFormat(undefined, {
+      dateStyle: "long",
+      timeStyle: "short",
+    });
+
+    /**
+     * The time the activity occurred.
+     *
+     * @type {number} - The time in milliseconds since the epoch.
+     */
+    set dateTime(time) {
+      let element = this.querySelector(".dateTime");
+      if (!element) {
+        return;
+      }
+      time = new Date(parseInt(time));
+
+      element.setAttribute("datetime", time.toISOString());
+      element.textContent = makeFriendlyDateAgo(time);
+      element.setAttribute(
+        "title",
+        this.constructor._dateTimeFormatter.format(time)
+      );
+    }
+
+    /**
+     * The text that describes additional information to the user.
+     *
+     * @type {string}
+     */
+    set statusText(val) {
+      this.querySelector(".statusText").textContent = val;
+    }
+
+    get statusText() {
+      return this.querySelector(".statusText").textContent;
+    }
+
+    /**
+     * The text that describes the activity to the user.
+     *
+     * @type {string}
+     */
+    set displayText(val) {
+      this.querySelector(".displayText").textContent = val;
+    }
+
+    get displayText() {
+      return this.querySelector(".displayText").textContent;
+    }
+  }
+
+  /**
+   * The MozActivityEvent widget displays information about events (like
+   * deleting or moving the message): e.g image, name, date and description.
+   * It is typically used in Activity Manager window.
+   *
+   * @augments ActivityItemBase
+   */
+  class ActivityEventItem extends ActivityItemBase {
+    static defaultIconSrc =
+      "chrome://messenger/skin/icons/new/activity/defaultEventIcon.svg";
+    static activityInterface = Ci.nsIActivityEvent;
+
+    connectedCallback() {
+      super.connectedCallback();
+      this.setAttribute("is", "activity-event-item");
+
+      this.displayText = this.activity.displayText;
+      this.statusText = this.activity.statusText;
+      this.dateTime = this.activity.completionTime;
+    }
+  }
+
+  customElements.define("activity-event-item", ActivityEventItem, {
+    extends: "li",
+  });
+
+  /**
+   * The ActivityGroupItem widget displays information about the activities of
+   * the group: e.g. name of the group, list of the activities with their name,
+   * progress and icon. It is shown in Activity Manager window. It gets removed
+   * when there is no activities from the group.
+   *
+   * @augments HTMLLIElement
+   */
+  class ActivityGroupItem extends HTMLLIElement {
+    constructor() {
+      super();
+
+      let heading = document.createElement("h2");
+      heading.classList.add("contextDisplayText");
+      this.appendChild(heading);
+
+      let list = document.createElement("ul");
+      list.classList.add("activitygroup-list", "activityview");
+      this.appendChild(list);
+
+      this.classList.add("activitygroup");
+      this.setAttribute("is", "activity-group-item");
+    }
+
+    /**
+     * The text heading for the group, as seen by the user.
+     *
+     * @type {string}
+     */
+    set contextDisplayText(val) {
+      this.querySelector(".contextDisplayText").textContent = val;
+    }
+
+    get contextDisplayText() {
+      return this.querySelctor(".contextDisplayText").textContent;
+    }
+
+    get isGroup() {
+      return true;
+    }
+  }
+
+  customElements.define("activity-group-item", ActivityGroupItem, {
+    extends: "li",
+  });
+
+  /**
+   * The ActivityProcessItem widget displays information about the internal
+   * process : e.g image, progress, name, date and description.
+   * It is typically used in Activity Manager window.
+   *
+   * @augments ActivityItemBase
+   */
+  class ActivityProcessItem extends ActivityItemBase {
+    static defaultIconSrc =
+      "chrome://messenger/skin/icons/new/activity/deafultProcessIcon.svg";
+    static activityInterface = Ci.nsIActivityProcess;
+    static textMap = {
+      paused: activityStrings.GetStringFromName("paused2"),
+      canceled: activityStrings.GetStringFromName("canceled"),
+      failed: activityStrings.GetStringFromName("failed"),
+      waitingforinput: activityStrings.GetStringFromName("waitingForInput"),
+      waitingforretry: activityStrings.GetStringFromName("waitingForRetry"),
+    };
+
+    constructor() {
+      super();
+
+      this.activityListener = {
+        onStateChanged: (activity, oldState) => {
+          // change the view of the element according to the new state
+          // default states for each item
+          let hideProgressMeter = false;
+          let statusText = this.statusText;
+
+          switch (this.activity.state) {
+            case Ci.nsIActivityProcess.STATE_INPROGRESS:
+              statusText = "";
+              break;
+            case Ci.nsIActivityProcess.STATE_COMPLETED:
+              hideProgressMeter = true;
+              statusText = "";
+              break;
+            case Ci.nsIActivityProcess.STATE_CANCELED:
+              hideProgressMeter = true;
+              statusText = this.constructor.textMap.canceled;
+              break;
+            case Ci.nsIActivityProcess.STATE_PAUSED:
+              statusText = this.constructor.textMap.paused;
+              break;
+            case Ci.nsIActivityProcess.STATE_WAITINGFORINPUT:
+              statusText = this.constructor.textMap.waitingforinput;
+              break;
+            case Ci.nsIActivityProcess.STATE_WAITINGFORRETRY:
+              hideProgressMeter = true;
+              statusText = this.constructor.textMap.waitingforretry;
+              break;
+          }
+
+          // Set the visibility
+          let meter = this.querySelector(".progressmeter");
+          meter.hidden = hideProgressMeter;
+
+          // Ensure progress meter not active when hidden
+          if (hideProgressMeter) {
+            meter.value = 0;
+          }
+
+          // Update Status text and Display Text Areas
+          // In some states we need to modify Display Text area of
+          // the process (e.g. Failure).
+          this.statusText = statusText;
+        },
+        onProgressChanged: (
+          activity,
+          statusText,
+          workUnitsComplete,
+          totalWorkUnits
+        ) => {
+          let element = document.querySelector(".progressmeter");
+          if (totalWorkUnits == 0) {
+            element.removeAttribute("value");
+          } else {
+            let _percentComplete = (100.0 * workUnitsComplete) / totalWorkUnits;
+            element.value = _percentComplete;
+          }
+          this.statusText = statusText;
+        },
+      };
+    }
+
+    connectedCallback() {
+      super.connectedCallback();
+      this.setAttribute("is", "activity-process-item");
+
+      this.displayText = this.activity.displayText;
+      // make sure that custom element reflects the latest state of the process
+      this.activityListener.onStateChanged(
+        this.activity.state,
+        Ci.nsIActivityProcess.STATE_NOTSTARTED
+      );
+      this.activityListener.onProgressChanged(
+        this.activity,
+        this.activity.lastStatusText,
+        this.activity.workUnitComplete,
+        this.activity.totalWorkUnits
+      );
+    }
+
+    get inProgress() {
+      return this.activity.state == Ci.nsIActivityProcess.STATE_INPROGRESS;
+    }
+
+    get isRemovable() {
+      return (
+        this.activity.state == Ci.nsIActivityProcess.STATE_COMPLETED ||
+        this.activity.state == Ci.nsIActivityProcess.STATE_CANCELED
+      );
+    }
+  }
+
+  customElements.define("activity-process-item", ActivityProcessItem, {
+    extends: "li",
+  });
+
+  /**
+   * The ActivityWarningItem widget displays information about
+   * warnings : e.g image, name, date and description.
+   * It is typically used in Activity Manager window.
+   *
+   * @augments ActivityItemBase
+   */
+  class ActivityWarningItem extends ActivityItemBase {
+    static defaultIconSrc =
+      "chrome://messenger/skin/icons/new/activity/warning.svg";
+    static activityInterface = Ci.nsIActivityWarning;
+
+    connectedCallback() {
+      super.connectedCallback();
+      this.setAttribute("is", "activity-warning-item");
+
+      this.displayText = this.activity.displayText;
+      this.dateTime = this.activity.time;
+      this.statusText = this.activity.recoveryTipText;
+    }
+  }
+
+  customElements.define("activity-warning-item", ActivityWarningItem, {
+    extends: "li",
+  });
+}
diff --git a/comm/mail/components/activity/content/activity.js b/comm/mail/components/activity/content/activity.js
new file mode 100644
index 0000000000..dcaba3d808
--- /dev/null
+++ b/comm/mail/components/activity/content/activity.js
@@ -0,0 +1,239 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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/. */
+
+const activityManager = Cc["@mozilla.org/activity-manager;1"].getService(
+  Ci.nsIActivityManager
+);
+
+var ACTIVITY_LIMIT = 250;
+
+var activityObject = {
+  _activityMgrListener: null,
+  _activitiesView: null,
+  _activityLogger: console.createInstance({
+    prefix: "mail.activity",
+    maxLogLevel: "Warn",
+    maxLogLevelPref: "mail.activity.loglevel",
+  }),
+  _ignoreNotifications: false,
+  _groupCache: new Map(),
+
+  // Utility Functions for Activity element management
+
+  /**
+   * Creates the proper element for the given activity
+   */
+  createActivityWidget(type) {
+    let element = document.createElement("li", {
+      is: type.bindingName,
+    });
+
+    if (element) {
+      element.setAttribute("actID", type.id);
+    }
+
+    return element;
+  },
+
+  /**
+   * Returns the activity group element that matches the context_type
+   * and context of the given activity, if any.
+   */
+  getActivityGroupElementByContext(aContextType, aContextObj) {
+    return this._groupCache.get(aContextType + ":" + aContextObj);
+  },
+
+  /**
+   * Inserts the given element into the correct position on the
+   * activity manager window.
+   */
+  placeActivityElement(element) {
+    if (element.isGroup || element.isProcess) {
+      this._activitiesView.insertBefore(
+        element,
+        this._activitiesView.firstElementChild
+      );
+    } else {
+      let next = this._activitiesView.firstElementChild;
+      while (next && (next.isWarning || next.isProcess || next.isGroup)) {
+        next = next.nextElementSibling;
+      }
+      if (next) {
+        this._activitiesView.insertBefore(element, next);
+      } else {
+        this._activitiesView.appendChild(element);
+      }
+    }
+    if (element.isGroup) {
+      this._groupCache.set(
+        element.contextType + ":" + element.contextObj,
+        element
+      );
+    }
+    while (this._activitiesView.children.length > ACTIVITY_LIMIT) {
+      this.removeActivityElement(
+        this._activitiesView.lastElementChild.getAttribute("actID")
+      );
+    }
+  },
+
+  /**
+   * Adds a new element to activity manager window for the
+   * given activity. It is called by ActivityMgrListener when
+   * a new activity is added into the activity manager's internal
+   * list.
+   */
+  addActivityElement(aID, aActivity) {
+    try {
+      this._activityLogger.info(`Adding ActivityElement: ${aID}, ${aActivity}`);
+      // get |groupingStyle| of the activity. Grouping style determines
+      // whether we show the activity standalone or grouped by context in
+      // the activity manager window.
+      let isGroupByContext =
+        aActivity.groupingStyle == Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT;
+
+      // find out if an activity group has already been created for this context
+      let group = null;
+      if (isGroupByContext) {
+        group = this.getActivityGroupElementByContext(
+          aActivity.contextType,
+          aActivity.contextObj
+        );
+        // create a group if it's not already created.
+        if (!group) {
+          group = document.createElement("li", {
+            is: "activity-group-item",
+          });
+          this._activityLogger.info("created group element");
+          // Set the context type and object of the newly created group
+          group.contextType = aActivity.contextType;
+          group.contextObj = aActivity.contextObj;
+          group.contextDisplayText = aActivity.contextDisplayText;
+
+          // add group into the list
+          this.placeActivityElement(group);
+        }
+      }
+
+      // create the appropriate element for the activity
+      let actElement = this.createActivityWidget(aActivity);
+      this._activityLogger.info("created activity element");
+
+      if (group) {
+        // get the inner list element of the group
+        let groupView = group.querySelector(".activitygroup-list");
+        groupView.appendChild(actElement);
+      } else {
+        this.placeActivityElement(actElement);
+      }
+    } catch (e) {
+      this._activityLogger.error("addActivityElement: " + e);
+      throw e;
+    }
+  },
+
+  /**
+   * Removes the activity element from the activity manager window.
+   * It is called by ActivityMgrListener when the activity in question
+   * is removed from the activity manager's internal list.
+   */
+  removeActivityElement(aID) {
+    this._activityLogger.info("removing Activity ID: " + aID);
+    let item = this._activitiesView.querySelector(`[actID="${aID}"]`);
+
+    if (item) {
+      let group = item.closest(".activitygroup");
+      item.remove();
+      if (group && !group.querySelector(".activityitem")) {
+        // Empty group is removed.
+        this._groupCache.delete(group.contextType + ":" + group.contextObj);
+        group.remove();
+      }
+    }
+  },
+
+  // -----------------
+  // Startup, Shutdown
+
+  startup() {
+    try {
+      this._activitiesView = document.getElementById("activityView");
+
+      let activities = activityManager.getActivities();
+      for (
+        let iActivity = Math.max(0, activities.length - ACTIVITY_LIMIT);
+        iActivity < activities.length;
+        iActivity++
+      ) {
+        let activity = activities[iActivity];
+        this.addActivityElement(activity.id, activity);
+      }
+
+      // start listening changes in the activity manager's
+      // internal list
+      this._activityMgrListener = new this.ActivityMgrListener();
+      activityManager.addListener(this._activityMgrListener);
+    } catch (e) {
+      this._activityLogger.error("Exception: " + e);
+    }
+  },
+
+  rebuild() {
+    let activities = activityManager.getActivities();
+    for (let activity of activities) {
+      this.addActivityElement(activity.id, activity);
+    }
+  },
+
+  shutdown() {
+    activityManager.removeListener(this._activityMgrListener);
+  },
+
+  // -----------------
+  // Utility Functions
+
+  /**
+   * Remove all activities not in-progress from the activity list.
+   */
+  clearActivityList() {
+    this._activityLogger.debug("clearActivityList");
+
+    this._ignoreNotifications = true;
+    // If/when we implement search, we'll want to remove just the items
+    // that are on the search display, however for now, we'll just clear up
+    // everything.
+    activityManager.cleanUp();
+
+    while (this._activitiesView.lastChild) {
+      this._activitiesView.lastChild.remove();
+    }
+
+    this._groupCache.clear();
+    this.rebuild();
+    this._ignoreNotifications = false;
+    this._activitiesView.focus();
+  },
+};
+
+// An object to monitor nsActivityManager operations. This class acts as
+// binding layer between nsActivityManager and nsActivityManagerUI objects.
+activityObject.ActivityMgrListener = function () {};
+activityObject.ActivityMgrListener.prototype = {
+  onAddedActivity(aID, aActivity) {
+    activityObject._activityLogger.info(`added activity: ${aID} ${aActivity}`);
+    if (!activityObject._ignoreNotifications) {
+      activityObject.addActivityElement(aID, aActivity);
+    }
+  },
+
+  onRemovedActivity(aID) {
+    if (!activityObject._ignoreNotifications) {
+      activityObject.removeActivityElement(aID);
+    }
+  },
+};
+
+window.addEventListener("load", () => activityObject.startup());
+window.addEventListener("unload", () => activityObject.shutdown());
diff --git a/comm/mail/components/activity/content/activity.xhtml b/comm/mail/components/activity/content/activity.xhtml
new file mode 100644
index 0000000000..cdff19cbe6
--- /dev/null
+++ b/comm/mail/components/activity/content/activity.xhtml
@@ -0,0 +1,61 @@
+<?xml version="1.0"?>
+<!-- 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/. -->
+
+#ifdef XP_UNIX
+#ifndef XP_MACOSX
+#define XP_GNOME 1
+#endif
+#endif
+
+<?xml-stylesheet href="chrome://global/skin/global.css"?>
+<?xml-stylesheet href="chrome://messenger/skin/variables.css"?>
+<?xml-stylesheet href="chrome://messenger/skin/activity/activity.css"?>
+<?xml-stylesheet href="chrome://messenger/skin/colors.css"?>
+<?xml-stylesheet href="chrome://messenger/skin/themeableDialog.css"?>
+
+<!DOCTYPE html [
+<!ENTITY % activityManagerDTD SYSTEM "chrome://messenger/locale/activity.dtd">
+%activityManagerDTD;
+]>
+
+<html xmlns="http://www.w3.org/1999/xhtml"
+      xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+      xmlns:html="http://www.w3.org/1999/xhtml"
+      id="activityManager" windowtype="Activity:Manager"
+      width="&window.width2;" height="&window.height;"
+      screenX="10" screenY="10"
+      persist="width height screenX screenY sizemode"
+      lightweightthemes="true">
+<head>
+  <title>&activity.title;</title>
+
+  <script defer="defer" src="chrome://messenger/content/activity.js"></script>
+  <script defer="defer" src="chrome://messenger/content/activity-widgets.js"></script>
+</head>
+<body>
+  <xul:keyset id="activityKeys">
+    <xul:key id="key_close" key="&cmd.close.commandkey;"
+             oncommand="window.close();" modifiers="accel"/>
+#ifdef XP_GNOME
+    <xul:key id="key_close2" key="&cmd.close2Unix.commandkey;"
+             oncommand="window.close();" modifiers="accel"/>
+#else
+    <xul:key id="key_close2" key="&cmd.close2.commandkey;"
+             oncommand="window.close();" modifiers="accel"/>
+#endif
+    <xul:key keycode="VK_ESCAPE" oncommand="window.close();"/>
+  </xul:keyset>
+
+  <div id="activityContainer">
+    <ul id="activityView" class="activityview"></ul>
+    <button id="clearListButton"
+            onclick="activityObject.clearActivityList();"
+            accesskey="&cmd.clearList.accesskey;"
+            title="&cmd.clearList.tooltip;">
+        &cmd.clearList.label;
+    </button>
+  </div>
+</body>
+</html>
diff --git a/comm/mail/components/activity/jar.mn b/comm/mail/components/activity/jar.mn
new file mode 100644
index 0000000000..babeeac23d
--- /dev/null
+++ b/comm/mail/components/activity/jar.mn
@@ -0,0 +1,8 @@
+# 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/.
+
+messenger.jar:
+  content/messenger/activity.js (content/activity.js)
+  content/messenger/activity-widgets.js (content/activity-widgets.js)
+* content/messenger/activity.xhtml (content/activity.xhtml)
diff --git a/comm/mail/components/activity/modules/activityModules.jsm b/comm/mail/components/activity/modules/activityModules.jsm
new file mode 100644
index 0000000000..945f7473c2
--- /dev/null
+++ b/comm/mail/components/activity/modules/activityModules.jsm
@@ -0,0 +1,33 @@
+/* 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/. */
+
+// This module is designed to be a central place to initialise activity related
+// modules.
+
+const EXPORTED_SYMBOLS = [];
+
+const { sendLaterModule } = ChromeUtils.import(
+  "resource:///modules/activity/sendLater.jsm"
+);
+sendLaterModule.init();
+const { moveCopyModule } = ChromeUtils.import(
+  "resource:///modules/activity/moveCopy.jsm"
+);
+moveCopyModule.init();
+const { glodaIndexerActivity } = ChromeUtils.import(
+  "resource:///modules/activity/glodaIndexer.jsm"
+);
+glodaIndexerActivity.init();
+const { autosyncModule } = ChromeUtils.import(
+  "resource:///modules/activity/autosync.jsm"
+);
+autosyncModule.init();
+const { alertHook } = ChromeUtils.import(
+  "resource:///modules/activity/alertHook.jsm"
+);
+alertHook.init();
+const { pop3DownloadModule } = ChromeUtils.import(
+  "resource:///modules/activity/pop3Download.jsm"
+);
+pop3DownloadModule.init();
diff --git a/comm/mail/components/activity/modules/alertHook.jsm b/comm/mail/components/activity/modules/alertHook.jsm
new file mode 100644
index 0000000000..b3083aef0a
--- /dev/null
+++ b/comm/mail/components/activity/modules/alertHook.jsm
@@ -0,0 +1,101 @@
+/* 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/. */
+
+const EXPORTED_SYMBOLS = ["alertHook"];
+
+var nsActWarning = Components.Constructor(
+  "@mozilla.org/activity-warning;1",
+  "nsIActivityWarning",
+  "init"
+);
+
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+// This module provides a link between the send later service and the activity
+// manager.
+var alertHook = {
+  get activityMgr() {
+    delete this.activityMgr;
+    return (this.activityMgr = Cc["@mozilla.org/activity-manager;1"].getService(
+      Ci.nsIActivityManager
+    ));
+  },
+
+  get alertService() {
+    delete this.alertService;
+    return (this.alertService = Cc["@mozilla.org/alerts-service;1"].getService(
+      Ci.nsIAlertsService
+    ));
+  },
+
+  get brandShortName() {
+    delete this.brandShortName;
+    return (this.brandShortName = Services.strings
+      .createBundle("chrome://branding/locale/brand.properties")
+      .GetStringFromName("brandShortName"));
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIMsgUserFeedbackListener"]),
+
+  onAlert(aMessage, aUrl) {
+    // Create a new warning.
+    let warning = new nsActWarning(aMessage, this.activityMgr, "");
+
+    if (aUrl && aUrl.server && aUrl.server.prettyName) {
+      warning.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT;
+      warning.contextType = "incomingServer";
+      warning.contextDisplayText = aUrl.server.prettyName;
+      warning.contextObj = aUrl.server;
+    } else {
+      warning.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_STANDALONE;
+    }
+
+    this.activityMgr.addActivity(warning);
+
+    // If we have a message window in the url, then show a warning prompt,
+    // just like the modal code used to. Otherwise, don't.
+    try {
+      if (!aUrl || !aUrl.msgWindow) {
+        return true;
+      }
+    } catch (ex) {
+      // nsIMsgMailNewsUrl.msgWindow will throw on a null pointer, so that's
+      // what we're handling here.
+      if (
+        ex instanceof Ci.nsIException &&
+        ex.result == Cr.NS_ERROR_INVALID_POINTER
+      ) {
+        return true;
+      }
+      throw ex;
+    }
+
+    try {
+      let alert = Cc["@mozilla.org/alert-notification;1"].createInstance(
+        Ci.nsIAlertNotification
+      );
+      alert.init(
+        "", // name
+        "chrome://branding/content/icon48.png",
+        this.brandShortName,
+        aMessage
+      );
+      this.alertService.showAlert(alert);
+    } catch (ex) {
+      // XXX On Linux, if libnotify isn't supported, showAlert
+      // can throw an error, so fall-back to the old method of modal dialogs.
+      return false;
+    }
+
+    return true;
+  },
+
+  init() {
+    // We shouldn't need to remove the listener as we're not being held by
+    // anyone except by the send later instance.
+    MailServices.mailSession.addUserFeedbackListener(this);
+  },
+};
diff --git a/comm/mail/components/activity/modules/autosync.jsm b/comm/mail/components/activity/modules/autosync.jsm
new file mode 100644
index 0000000000..c2483c4b53
--- /dev/null
+++ b/comm/mail/components/activity/modules/autosync.jsm
@@ -0,0 +1,433 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+const EXPORTED_SYMBOLS = ["autosyncModule"];
+
+var nsActProcess = Components.Constructor(
+  "@mozilla.org/activity-process;1",
+  "nsIActivityProcess",
+  "init"
+);
+var nsActEvent = Components.Constructor(
+  "@mozilla.org/activity-event;1",
+  "nsIActivityEvent",
+  "init"
+);
+
+/**
+ * This code aims to mediate between the auto-sync code and the activity mgr.
+ *
+ * Not every auto-sync activity is directly  mapped to a process or event.
+ * To prevent a possible event overflow, Auto-Sync monitor generates one
+ * sync'd event per account when after all its _pending_ folders are sync'd,
+ * rather than generating one event per folder sync.
+ */
+
+var autosyncModule = {
+  _inQFolderList: [],
+  _running: false,
+  _syncInfoPerFolder: new Map(),
+  _syncInfoPerServer: new Map(),
+  _lastMessage: new Map(),
+
+  get log() {
+    delete this.log;
+    return (this.log = console.createInstance({
+      prefix: "mail.activity",
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mail.activity.loglevel",
+    }));
+  },
+
+  get activityMgr() {
+    delete this.activityMgr;
+    return (this.activityMgr = Cc["@mozilla.org/activity-manager;1"].getService(
+      Ci.nsIActivityManager
+    ));
+  },
+
+  get autoSyncManager() {
+    delete this.autoSyncManager;
+    return (this.autoSyncManager = Cc[
+      "@mozilla.org/imap/autosyncmgr;1"
+    ].getService(Ci.nsIAutoSyncManager));
+  },
+
+  get bundle() {
+    delete this.bundle;
+    return (this.bundle = Services.strings.createBundle(
+      "chrome://messenger/locale/activity.properties"
+    ));
+  },
+
+  getString(stringName) {
+    try {
+      return this.bundle.GetStringFromName(stringName);
+    } catch (e) {
+      this.log.error("error trying to get a string called: " + stringName);
+      throw e;
+    }
+  },
+
+  createSyncMailProcess(folder) {
+    try {
+      // create an activity process for this folder
+      let msg = this.bundle.formatStringFromName("autosyncProcessDisplayText", [
+        folder.prettyName,
+      ]);
+      let process = new nsActProcess(msg, this.autoSyncManager);
+      // we want to use default auto-sync icon
+      process.iconClass = "syncMail";
+      process.addSubject(folder);
+      // group processes under folder's imap account
+      process.contextType = "account";
+      process.contextDisplayText = this.bundle.formatStringFromName(
+        "autosyncContextDisplayText",
+        [folder.server.prettyName]
+      );
+
+      process.contextObj = folder.server;
+
+      return process;
+    } catch (e) {
+      this.log.error("createSyncMailProcess: " + e);
+      throw e;
+    }
+  },
+
+  createSyncMailEvent(syncItem) {
+    try {
+      // extract the relevant parts
+      let process = syncItem.activity;
+      let folder = syncItem.syncFolder;
+
+      // create an activity event
+
+      let msg = this.bundle.formatStringFromName("autosyncEventDisplayText", [
+        folder.server.prettyName,
+      ]);
+
+      let statusMsg;
+      let numOfMessages = this._syncInfoPerServer.get(
+        folder.server
+      ).totalDownloads;
+      if (numOfMessages) {
+        statusMsg = this.bundle.formatStringFromName(
+          "autosyncEventStatusText",
+          [numOfMessages]
+        );
+      } else {
+        statusMsg = this.getString("autosyncEventStatusTextNoMsgs");
+      }
+
+      let event = new nsActEvent(
+        msg,
+        this.autoSyncManager,
+        statusMsg,
+        this._syncInfoPerServer.get(folder.server).startTime,
+        Date.now()
+      ); // completion time
+
+      // since auto-sync events do not have undo option by nature,
+      // setting these values are informational only.
+      event.contextType = process.contextType;
+      event.contextDisplayText = this.bundle.formatStringFromName(
+        "autosyncContextDisplayText",
+        [folder.server.prettyName]
+      );
+      event.contextObj = process.contextObj;
+      event.iconClass = "syncMail";
+
+      // transfer all subjects.
+      // same as above, not mandatory
+      let subjects = process.getSubjects();
+      for (let subject of subjects) {
+        event.addSubject(subject);
+      }
+
+      return event;
+    } catch (e) {
+      this.log.error("createSyncMailEvent: " + e);
+      throw e;
+    }
+  },
+
+  onStateChanged(running) {
+    try {
+      this._running = running;
+      this.log.info(
+        "OnStatusChanged: " + (running ? "running" : "sleeping") + "\n"
+      );
+    } catch (e) {
+      this.log.error("onStateChanged: " + e);
+      throw e;
+    }
+  },
+
+  onFolderAddedIntoQ(queue, folder) {
+    try {
+      if (
+        folder instanceof Ci.nsIMsgFolder &&
+        queue == Ci.nsIAutoSyncMgrListener.PriorityQueue
+      ) {
+        this._inQFolderList.push(folder);
+        this.log.info(
+          "Auto_Sync OnFolderAddedIntoQ [" +
+            this._inQFolderList.length +
+            "] " +
+            folder.prettyName +
+            " of " +
+            folder.server.prettyName
+        );
+        // create an activity process for this folder
+        let process = this.createSyncMailProcess(folder);
+
+        // create a sync object to keep track of the process of this folder
+        let imapFolder = folder.QueryInterface(Ci.nsIMsgImapMailFolder);
+        let syncItem = {
+          syncFolder: folder,
+          activity: process,
+          percentComplete: 0,
+          totalDownloaded: 0,
+          pendingMsgCount: imapFolder.autoSyncStateObj.pendingMessageCount,
+        };
+
+        // if this is the first folder of this server in the queue, then set the sync start time
+        // for activity event
+        if (!this._syncInfoPerServer.has(folder.server)) {
+          this._syncInfoPerServer.set(folder.server, {
+            startTime: Date.now(),
+            totalDownloads: 0,
+          });
+        }
+
+        // associate the sync object with the folder in question
+        // use folder.URI as key
+        this._syncInfoPerFolder.set(folder.URI, syncItem);
+      }
+    } catch (e) {
+      this.log.error("onFolderAddedIntoQ: " + e);
+      throw e;
+    }
+  },
+  onFolderRemovedFromQ(queue, folder) {
+    try {
+      if (
+        folder instanceof Ci.nsIMsgFolder &&
+        queue == Ci.nsIAutoSyncMgrListener.PriorityQueue
+      ) {
+        let i = this._inQFolderList.indexOf(folder);
+        if (i > -1) {
+          this._inQFolderList.splice(i, 1);
+        }
+
+        this.log.info(
+          "OnFolderRemovedFromQ [" +
+            this._inQFolderList.length +
+            "] " +
+            folder.prettyName +
+            " of " +
+            folder.server.prettyName +
+            "\n"
+        );
+
+        let syncItem = this._syncInfoPerFolder.get(folder.URI);
+        let process = syncItem.activity;
+        let canceled = false;
+        if (process instanceof Ci.nsIActivityProcess) {
+          canceled = process.state == Ci.nsIActivityProcess.STATE_CANCELED;
+          process.state = Ci.nsIActivityProcess.STATE_COMPLETED;
+
+          try {
+            this.activityMgr.removeActivity(process.id);
+          } catch (e) {
+            // It is OK to end up here; If the folder is queued and the
+            // message get manually downloaded by the user, we might get
+            // a folder removed notification even before a download
+            // started for this folder. This behavior stems from the fact
+            // that we add activities into the activity manager in
+            // onDownloadStarted notification rather than onFolderAddedIntoQ.
+            // This is an expected side effect.
+            // Log a warning, but do not throw an error.
+            this.log.warn("onFolderRemovedFromQ: " + e);
+          }
+
+          // remove the folder/syncItem association from the table
+          this._syncInfoPerFolder.delete(folder.URI);
+        }
+
+        // if this is the last folder of this server in the queue
+        // create a sync event and clean the sync start time
+        let found = false;
+        for (let value of this._syncInfoPerFolder.values()) {
+          if (value.syncFolder.server == folder.server) {
+            found = true;
+            break;
+          }
+        }
+        this.log.info(
+          "Auto_Sync OnFolderRemovedFromQ Last folder of the server: " + !found
+        );
+        if (!found) {
+          // create an sync event for the completed process if it's not canceled
+          if (!canceled) {
+            let key = folder.server.prettyName;
+            if (
+              this._lastMessage.has(key) &&
+              this.activityMgr.containsActivity(this._lastMessage.get(key))
+            ) {
+              this.activityMgr.removeActivity(this._lastMessage.get(key));
+            }
+            this._lastMessage.set(
+              key,
+              this.activityMgr.addActivity(this.createSyncMailEvent(syncItem))
+            );
+          }
+          this._syncInfoPerServer.delete(folder.server);
+        }
+      }
+    } catch (e) {
+      this.log.error("onFolderRemovedFromQ: " + e);
+      throw e;
+    }
+  },
+  onDownloadStarted(folder, numOfMessages, totalPending) {
+    try {
+      if (folder instanceof Ci.nsIMsgFolder) {
+        this.log.info(
+          "OnDownloadStarted (" +
+            numOfMessages +
+            "/" +
+            totalPending +
+            "): " +
+            folder.prettyName +
+            " of " +
+            folder.server.prettyName +
+            "\n"
+        );
+
+        let syncItem = this._syncInfoPerFolder.get(folder.URI);
+        let process = syncItem.activity;
+
+        // Update the totalPending number. if new messages have been discovered in the folder
+        // after we added the folder into the q, totalPending might be greater than what we have
+        // initially set
+        if (totalPending > syncItem.pendingMsgCount) {
+          syncItem.pendingMsgCount = totalPending;
+        }
+
+        if (process instanceof Ci.nsIActivityProcess) {
+          // if the process has not beed added to activity manager already, add now
+          if (!this.activityMgr.containsActivity(process.id)) {
+            this.log.info(
+              "Auto_Sync OnDownloadStarted: No process, adding a new process"
+            );
+            this.activityMgr.addActivity(process);
+          }
+
+          syncItem.totalDownloaded += numOfMessages;
+
+          process.state = Ci.nsIActivityProcess.STATE_INPROGRESS;
+          let percent =
+            (syncItem.totalDownloaded / syncItem.pendingMsgCount) * 100;
+          if (percent > syncItem.percentComplete) {
+            syncItem.percentComplete = percent;
+          }
+
+          let msg = this.bundle.formatStringFromName(
+            "autosyncProcessProgress2",
+            [
+              syncItem.totalDownloaded,
+              syncItem.pendingMsgCount,
+              folder.prettyName,
+              folder.server.prettyName,
+            ]
+          );
+
+          process.setProgress(
+            msg,
+            syncItem.totalDownloaded,
+            syncItem.pendingMsgCount
+          );
+
+          let serverInfo = this._syncInfoPerServer.get(
+            syncItem.syncFolder.server
+          );
+          serverInfo.totalDownloads += numOfMessages;
+          this._syncInfoPerServer.set(syncItem.syncFolder.server, serverInfo);
+        }
+      }
+    } catch (e) {
+      this.log.error("onDownloadStarted: " + e);
+      throw e;
+    }
+  },
+
+  onDownloadCompleted(folder) {
+    try {
+      if (folder instanceof Ci.nsIMsgFolder) {
+        this.log.info(
+          "OnDownloadCompleted: " +
+            folder.prettyName +
+            " of " +
+            folder.server.prettyName
+        );
+
+        let process = this._syncInfoPerFolder.get(folder.URI).activity;
+        if (process instanceof Ci.nsIActivityProcess && !this._running) {
+          this.log.info(
+            "OnDownloadCompleted: Auto-Sync Manager is paused, pausing the process"
+          );
+          process.state = Ci.nsIActivityProcess.STATE_PAUSED;
+        }
+      }
+    } catch (e) {
+      this.log.error("onDownloadCompleted: " + e);
+      throw e;
+    }
+  },
+
+  onDownloadError(folder) {
+    if (folder instanceof Ci.nsIMsgFolder) {
+      this.log.error(
+        "OnDownloadError: " +
+          folder.prettyName +
+          " of " +
+          folder.server.prettyName +
+          "\n"
+      );
+    }
+  },
+
+  onDiscoveryQProcessed(folder, numOfHdrsProcessed, leftToProcess) {
+    this.log.info(
+      "onDiscoveryQProcessed: Processed " +
+        numOfHdrsProcessed +
+        "/" +
+        (leftToProcess + numOfHdrsProcessed) +
+        " of " +
+        folder.prettyName +
+        "\n"
+    );
+  },
+
+  onAutoSyncInitiated(folder) {
+    this.log.info(
+      "onAutoSyncInitiated: " +
+        folder.prettyName +
+        " of " +
+        folder.server.prettyName +
+        " has been updated.\n"
+    );
+  },
+
+  init() {
+    // XXX when do we need to remove ourselves?
+    this.log.info("initing");
+    Cc["@mozilla.org/imap/autosyncmgr;1"]
+      .getService(Ci.nsIAutoSyncManager)
+      .addListener(this);
+  },
+};
diff --git a/comm/mail/components/activity/modules/glodaIndexer.jsm b/comm/mail/components/activity/modules/glodaIndexer.jsm
new file mode 100644
index 0000000000..5307d5cefa
--- /dev/null
+++ b/comm/mail/components/activity/modules/glodaIndexer.jsm
@@ -0,0 +1,251 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+const EXPORTED_SYMBOLS = ["glodaIndexerActivity"];
+
+var nsActProcess = Components.Constructor(
+  "@mozilla.org/activity-process;1",
+  "nsIActivityProcess",
+  "init"
+);
+var nsActEvent = Components.Constructor(
+  "@mozilla.org/activity-event;1",
+  "nsIActivityEvent",
+  "init"
+);
+
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PluralForm: "resource://gre/modules/PluralForm.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  Gloda: "resource:///modules/gloda/GlodaPublic.jsm",
+  GlodaConstants: "resource:///modules/gloda/GlodaConstants.jsm",
+  GlodaIndexer: "resource:///modules/gloda/GlodaIndexer.jsm",
+});
+
+/**
+ * Gloda message indexer feedback.
+ */
+var glodaIndexerActivity = {
+  get log() {
+    delete this.log;
+    return (this.log = console.createInstance({
+      prefix: "mail.activity",
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mail.activity.loglevel",
+    }));
+  },
+
+  get activityMgr() {
+    delete this.activityMgr;
+    return (this.activityMgr = Cc["@mozilla.org/activity-manager;1"].getService(
+      Ci.nsIActivityManager
+    ));
+  },
+
+  get bundle() {
+    delete this.bundle;
+    return (this.bundle = Services.strings.createBundle(
+      "chrome://messenger/locale/activity.properties"
+    ));
+  },
+
+  getString(stringName) {
+    try {
+      return this.bundle.GetStringFromName(stringName);
+    } catch (e) {
+      this.log.error("error trying to get a string called: " + stringName);
+      throw e;
+    }
+  },
+
+  init() {
+    // Register a listener with the Gloda indexer that receives notifications
+    // about Gloda indexing status.  We wrap the listener in this function so we
+    // can set |this| to the GlodaIndexerActivity object inside the listener.
+    function listenerWrapper(...aArgs) {
+      glodaIndexerActivity.listener(...aArgs);
+    }
+    lazy.GlodaIndexer.addListener(listenerWrapper);
+  },
+
+  /**
+   * Information about the current job.  An object with these properties:
+   *
+   *   folder       {String}
+   *                the name of the folder being processed by the job
+   *   jobNumber    {Number}
+   *                the index of the job in the list of jobs
+   *   process      {nsIActivityProcess}
+   *                the activity process corresponding to the current job
+   *   startTime    {Date}
+   *                the time at which we were first notified about the job
+   *   totalItemNum {Number}
+   *                the total number of messages being indexed in the job
+   *   jobType      {String}
+   *                The IndexinbJob jobType (ex: "folder", "folderCompact")
+   */
+  currentJob: null,
+
+  listener(aStatus, aFolder, aJobNumber, aItemNumber, aTotalItemNum, aJobType) {
+    this.log.debug("Gloda Indexer Folder/Status: " + aFolder + "/" + aStatus);
+    this.log.debug("Gloda Indexer Job: " + aJobNumber);
+    this.log.debug("Gloda Indexer Item: " + aItemNumber + "/" + aTotalItemNum);
+
+    if (aStatus == lazy.GlodaConstants.kIndexerIdle) {
+      if (this.currentJob) {
+        this.onJobCompleted();
+      }
+    } else {
+      // If the job numbers have changed, the indexer has finished the job
+      // we were previously tracking, so convert the corresponding process
+      // into an event and start a new process to track the new job.
+      if (this.currentJob && aJobNumber != this.currentJob.jobNumber) {
+        this.onJobCompleted();
+      }
+
+      // If we aren't tracking a job, either this is the first time we've been
+      // called or the last job we were tracking was completed.  Either way,
+      // start tracking the new job.
+      if (!this.currentJob) {
+        this.onJobBegun(aFolder, aJobNumber, aTotalItemNum, aJobType);
+      }
+
+      // If there is only one item, don't bother creating a progress item.
+      if (aTotalItemNum != 1) {
+        this.onJobProgress(aFolder, aItemNumber, aTotalItemNum);
+      }
+    }
+  },
+
+  onJobBegun(aFolder, aJobNumber, aTotalItemNum, aJobType) {
+    let displayText = aFolder
+      ? this.getString("indexingFolder").replace("#1", aFolder)
+      : this.getString("indexing");
+    let process = new nsActProcess(displayText, lazy.Gloda);
+
+    process.iconClass = "indexMail";
+    process.contextType = "account";
+    process.contextObj = aFolder;
+    process.addSubject(aFolder);
+
+    this.currentJob = {
+      folder: aFolder,
+      jobNumber: aJobNumber,
+      process,
+      startTime: new Date(),
+      totalItemNum: aTotalItemNum,
+      jobType: aJobType,
+    };
+
+    this.activityMgr.addActivity(process);
+  },
+
+  onJobProgress(aFolder, aItemNumber, aTotalItemNum) {
+    this.currentJob.process.state = Ci.nsIActivityProcess.STATE_INPROGRESS;
+    // The total number of items being processed in the job can change, as can
+    // the folder being processed, since we sometimes get notified about a job
+    // before it has determined these things, so we update them here.
+    this.currentJob.folder = aFolder;
+    this.currentJob.totalItemNum = aTotalItemNum;
+
+    let statusText;
+    if (aTotalItemNum == null) {
+      statusText = aFolder
+        ? this.getString("indexingFolderStatusVague").replace("#1", aFolder)
+        : this.getString("indexingStatusVague");
+    } else {
+      let percentComplete =
+        aTotalItemNum == 0
+          ? 100
+          : parseInt((aItemNumber / aTotalItemNum) * 100);
+      // Note: we must replace the folder name placeholder last; otherwise,
+      // if the name happens to contain another one of the placeholders, we'll
+      // hork the name when replacing it.
+      statusText = this.getString(
+        aFolder ? "indexingFolderStatusExact" : "indexingStatusExact"
+      );
+      statusText = lazy.PluralForm.get(aTotalItemNum, statusText)
+        .replace("#1", aItemNumber + 1)
+        .replace("#2", aTotalItemNum)
+        .replace("#3", percentComplete)
+        .replace("#4", aFolder);
+    }
+
+    this.currentJob.process.setProgress(statusText, aItemNumber, aTotalItemNum);
+  },
+
+  onJobCompleted() {
+    this.currentJob.process.state = Ci.nsIActivityProcess.STATE_COMPLETED;
+
+    this.activityMgr.removeActivity(this.currentJob.process.id);
+
+    // this.currentJob.totalItemNum might still be null at this point
+    // if we were first notified about the job before the indexer determined
+    // the number of messages to index and then it didn't find any to index.
+    let totalItemNum = this.currentJob.totalItemNum || 0;
+
+    // We only create activity events when specific folders get indexed,
+    // since event-driven indexing jobs are too numerous.  We also only create
+    // them when we ended up indexing something in the folder, since otherwise
+    // we'd spam the activity manager with too many "indexed 0 messages" items
+    // that aren't useful enough to justify their presence in the manager.
+    // TODO: Aggregate event-driven indexing jobs into batches significant
+    // enough for us to create activity events for them.
+    if (
+      this.currentJob.jobType == "folder" &&
+      this.currentJob.folder &&
+      totalItemNum > 0
+    ) {
+      // Note: we must replace the folder name placeholder last; otherwise,
+      // if the name happens to contain another one of the placeholders, we'll
+      // hork the name when replacing it.
+      let displayText = lazy.PluralForm.get(
+        totalItemNum,
+        this.getString("indexedFolder")
+      )
+        .replace("#1", totalItemNum)
+        .replace("#2", this.currentJob.folder);
+
+      let endTime = new Date();
+      let secondsElapsed = parseInt(
+        (endTime - this.currentJob.startTime) / 1000
+      );
+
+      let statusText = lazy.PluralForm.get(
+        secondsElapsed,
+        this.getString("indexedFolderStatus")
+      ).replace("#1", secondsElapsed);
+
+      let event = new nsActEvent(
+        displayText,
+        lazy.Gloda,
+        statusText,
+        this.currentJob.startTime,
+        endTime
+      );
+      event.contextType = this.currentJob.contextType;
+      event.contextObj = this.currentJob.contextObj;
+      event.iconClass = "indexMail";
+
+      // Transfer subjects.
+      let subjects = this.currentJob.process.getSubjects();
+      for (let subject of subjects) {
+        event.addSubject(subject);
+      }
+
+      this.activityMgr.addActivity(event);
+    }
+
+    this.currentJob = null;
+  },
+};
diff --git a/comm/mail/components/activity/modules/moveCopy.jsm b/comm/mail/components/activity/modules/moveCopy.jsm
new file mode 100644
index 0000000000..de3e51d85b
--- /dev/null
+++ b/comm/mail/components/activity/modules/moveCopy.jsm
@@ -0,0 +1,396 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+const EXPORTED_SYMBOLS = ["moveCopyModule"];
+
+var nsActEvent = Components.Constructor(
+  "@mozilla.org/activity-event;1",
+  "nsIActivityEvent",
+  "init"
+);
+
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PluralForm } = ChromeUtils.importESModule(
+  "resource://gre/modules/PluralForm.sys.mjs"
+);
+
+// This module provides a link between the move/copy code and the activity
+// manager.
+var moveCopyModule = {
+  lastMessage: {},
+  lastFolder: {},
+
+  get log() {
+    delete this.log;
+    return (this.log = console.createInstance({
+      prefix: "mail.activity",
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mail.activity.loglevel",
+    }));
+  },
+
+  get activityMgr() {
+    delete this.activityMgr;
+    return (this.activityMgr = Cc["@mozilla.org/activity-manager;1"].getService(
+      Ci.nsIActivityManager
+    ));
+  },
+
+  get bundle() {
+    delete this.bundle;
+    return (this.bundle = Services.strings.createBundle(
+      "chrome://messenger/locale/activity.properties"
+    ));
+  },
+
+  getString(stringName) {
+    try {
+      return this.bundle.GetStringFromName(stringName);
+    } catch (e) {
+      this.log.error("error trying to get a string called: " + stringName);
+      throw e;
+    }
+  },
+
+  msgAdded(aMsg) {},
+
+  msgsDeleted(aMsgList) {
+    this.log.info("in msgsDeleted");
+
+    if (aMsgList.length <= 0) {
+      return;
+    }
+
+    let displayCount = aMsgList.length;
+    // get the folder of the deleted messages
+    let folder = aMsgList[0].folder;
+
+    let activities = this.activityMgr.getActivities();
+    if (
+      activities.length > 0 &&
+      activities[activities.length - 1].id == this.lastMessage.id &&
+      this.lastMessage.type == "deleteMail" &&
+      this.lastMessage.folder == folder.prettyName
+    ) {
+      displayCount += this.lastMessage.count;
+      this.activityMgr.removeActivity(this.lastMessage.id);
+    }
+
+    this.lastMessage = {};
+    let displayText = PluralForm.get(
+      displayCount,
+      this.getString("deletedMessages2")
+    );
+    displayText = displayText.replace("#1", displayCount);
+    this.lastMessage.count = displayCount;
+    displayText = displayText.replace("#2", folder.prettyName);
+    this.lastMessage.folder = folder.prettyName;
+
+    let statusText = folder.server.prettyName;
+
+    // create an activity event
+    let event = new nsActEvent(
+      displayText,
+      folder,
+      statusText,
+      Date.now(), // start time
+      Date.now()
+    ); // completion time
+
+    event.iconClass = "deleteMail";
+    this.lastMessage.type = event.iconClass;
+
+    for (let msgHdr of aMsgList) {
+      event.addSubject(msgHdr.messageId);
+    }
+
+    this.lastMessage.id = this.activityMgr.addActivity(event);
+  },
+
+  msgsMoveCopyCompleted(aMove, aSrcMsgList, aDestFolder) {
+    try {
+      this.log.info("in msgsMoveCopyCompleted");
+
+      let count = aSrcMsgList.length;
+      if (count <= 0) {
+        return;
+      }
+
+      // get the folder of the moved/copied messages
+      let folder = aSrcMsgList[0].folder;
+      this.log.info("got folder");
+
+      let displayCount = count;
+
+      let activities = this.activityMgr.getActivities();
+      if (
+        activities.length > 0 &&
+        activities[activities.length - 1].id == this.lastMessage.id &&
+        this.lastMessage.type == (aMove ? "moveMail" : "copyMail") &&
+        this.lastMessage.sourceFolder == folder.prettyName &&
+        this.lastMessage.destFolder == aDestFolder.prettyName
+      ) {
+        displayCount += this.lastMessage.count;
+        this.activityMgr.removeActivity(this.lastMessage.id);
+      }
+
+      let statusText = "";
+      if (folder.server != aDestFolder.server) {
+        statusText = this.getString("fromServerToServer");
+        statusText = statusText.replace("#1", folder.server.prettyName);
+        statusText = statusText.replace("#2", aDestFolder.server.prettyName);
+      } else {
+        statusText = folder.server.prettyName;
+      }
+
+      this.lastMessage = {};
+      let displayText;
+      if (aMove) {
+        displayText = PluralForm.get(
+          displayCount,
+          this.getString("movedMessages")
+        );
+      } else {
+        displayText = PluralForm.get(
+          displayCount,
+          this.getString("copiedMessages")
+        );
+      }
+
+      displayText = displayText.replace("#1", displayCount);
+      this.lastMessage.count = displayCount;
+      displayText = displayText.replace("#2", folder.prettyName);
+      this.lastMessage.sourceFolder = folder.prettyName;
+      displayText = displayText.replace("#3", aDestFolder.prettyName);
+      this.lastMessage.destFolder = aDestFolder.prettyName;
+
+      // create an activity event
+      let event = new nsActEvent(
+        displayText,
+        folder,
+        statusText,
+        Date.now(), // start time
+        Date.now()
+      ); // completion time
+      event.iconClass = aMove ? "moveMail" : "copyMail";
+      this.lastMessage.type = event.iconClass;
+
+      for (let msgHdr of aSrcMsgList) {
+        event.addSubject(msgHdr.messageId);
+      }
+      this.lastMessage.id = this.activityMgr.addActivity(event);
+    } catch (e) {
+      this.log.error("Exception: " + e);
+    }
+  },
+
+  folderAdded(aFolder) {},
+
+  folderDeleted(aFolder) {
+    // When a new account is created we get this notification with an empty named
+    // folder that can't return its server. Ignore it.
+    // TODO: find out what it is.
+    let server = aFolder.server;
+    // If the account has been removed, we're going to ignore this notification.
+    if (
+      !MailServices.accounts.findServer(
+        server.username,
+        server.hostName,
+        server.type
+      )
+    ) {
+      return;
+    }
+
+    let displayText;
+    let statusText = server.prettyName;
+
+    // Display a different message depending on whether we emptied the trash
+    // or actually deleted a folder
+    if (aFolder.isSpecialFolder(Ci.nsMsgFolderFlags.Trash, false)) {
+      displayText = this.getString("emptiedTrash");
+    } else {
+      displayText = this.getString("deletedFolder").replace(
+        "#1",
+        aFolder.prettyName
+      );
+    }
+
+    // create an activity event
+    let event = new nsActEvent(
+      displayText,
+      server,
+      statusText,
+      Date.now(), // start time
+      Date.now()
+    ); // completion time
+
+    event.addSubject(aFolder);
+    event.iconClass = "deleteMail";
+
+    // When we rename, we get a delete event as well as a rename, so store
+    // the last folder we deleted
+    this.lastFolder = {};
+    this.lastFolder.URI = aFolder.URI;
+    this.lastFolder.event = this.activityMgr.addActivity(event);
+  },
+
+  folderMoveCopyCompleted(aMove, aSrcFolder, aDestFolder) {
+    this.log.info("in folderMoveCopyCompleted, aMove = " + aMove);
+
+    let displayText;
+    if (aMove) {
+      displayText = this.getString("movedFolder");
+    } else {
+      displayText = this.getString("copiedFolder");
+    }
+
+    displayText = displayText.replace("#1", aSrcFolder.prettyName);
+    displayText = displayText.replace("#2", aDestFolder.prettyName);
+
+    let statusText = "";
+    if (aSrcFolder.server != aDestFolder.server) {
+      statusText = this.getString("fromServerToServer");
+      statusText = statusText.replace("#1", aSrcFolder.server.prettyName);
+      statusText = statusText.replace("#2", aDestFolder.server.prettyName);
+    } else {
+      statusText = aSrcFolder.server.prettyName;
+    }
+    // create an activity event
+    let event = new nsActEvent(
+      displayText,
+      aSrcFolder.server,
+      statusText,
+      Date.now(), // start time
+      Date.now()
+    ); // completion time
+
+    event.addSubject(aSrcFolder);
+    event.addSubject(aDestFolder);
+    event.iconClass = aMove ? "moveMail" : "copyMail";
+
+    this.activityMgr.addActivity(event);
+  },
+
+  folderRenamed(aOrigFolder, aNewFolder) {
+    this.log.info(
+      "in folderRenamed, aOrigFolder = " +
+        aOrigFolder.prettyName +
+        ", aNewFolder = " +
+        aNewFolder.prettyName
+    );
+
+    let displayText;
+    let statusText = aNewFolder.server.prettyName;
+
+    // Display a different message depending on whether we moved the folder
+    // to the trash or actually renamed the folder.
+    if (aNewFolder.isSpecialFolder(Ci.nsMsgFolderFlags.Trash, true)) {
+      displayText = this.getString("movedFolderToTrash");
+      displayText = displayText.replace("#1", aOrigFolder.prettyName);
+    } else {
+      displayText = this.getString("renamedFolder");
+      displayText = displayText.replace("#1", aOrigFolder.prettyName);
+      displayText = displayText.replace("#2", aNewFolder.prettyName);
+    }
+
+    // When renaming a folder, a delete event is always fired first
+    if (this.lastFolder.URI == aOrigFolder.URI) {
+      this.activityMgr.removeActivity(this.lastFolder.event);
+    }
+
+    // create an activity event
+    let event = new nsActEvent(
+      displayText,
+      aOrigFolder.server,
+      statusText,
+      Date.now(), // start time
+      Date.now()
+    ); // completion time
+
+    event.addSubject(aOrigFolder);
+    event.addSubject(aNewFolder);
+
+    this.activityMgr.addActivity(event);
+  },
+
+  msgUnincorporatedMoved(srcFolder, msgHdr) {
+    try {
+      this.log.info("in msgUnincorporatedMoved");
+
+      // get the folder of the moved/copied messages
+      let destFolder = msgHdr.folder;
+      this.log.info("got folder");
+
+      let displayCount = 1;
+
+      let activities = this.activityMgr.getActivities();
+      if (
+        activities.length > 0 &&
+        activities[activities.length - 1].id == this.lastMessage.id &&
+        this.lastMessage.type == "moveMail" &&
+        this.lastMessage.sourceFolder == srcFolder.prettyName &&
+        this.lastMessage.destFolder == destFolder.prettyName
+      ) {
+        displayCount += this.lastMessage.count;
+        this.activityMgr.removeActivity(this.lastMessage.id);
+      }
+
+      let statusText = "";
+      if (srcFolder.server != destFolder.server) {
+        statusText = this.getString("fromServerToServer");
+        statusText = statusText.replace("#1", srcFolder.server.prettyName);
+        statusText = statusText.replace("#2", destFolder.server.prettyName);
+      } else {
+        statusText = srcFolder.server.prettyName;
+      }
+
+      this.lastMessage = {};
+      let displayText;
+      displayText = PluralForm.get(
+        displayCount,
+        this.getString("movedMessages")
+      );
+
+      displayText = displayText.replace("#1", displayCount);
+      this.lastMessage.count = displayCount;
+      displayText = displayText.replace("#2", srcFolder.prettyName);
+      this.lastMessage.sourceFolder = srcFolder.prettyName;
+      displayText = displayText.replace("#3", destFolder.prettyName);
+      this.lastMessage.destFolder = destFolder.prettyName;
+
+      // create an activity event
+      let event = new nsActEvent(
+        displayText,
+        srcFolder,
+        statusText,
+        Date.now(), // start time
+        Date.now()
+      ); // completion time
+
+      event.iconClass = "moveMail";
+      this.lastMessage.type = event.iconClass;
+      event.addSubject(msgHdr.messageId);
+      this.lastMessage.id = this.activityMgr.addActivity(event);
+    } catch (e) {
+      this.log.error("Exception: " + e);
+    }
+  },
+
+  init() {
+    // XXX when do we need to remove ourselves?
+    MailServices.mfn.addListener(
+      this,
+      MailServices.mfn.msgsDeleted |
+        MailServices.mfn.msgsMoveCopyCompleted |
+        MailServices.mfn.folderDeleted |
+        MailServices.mfn.folderMoveCopyCompleted |
+        MailServices.mfn.folderRenamed |
+        MailServices.mfn.msgUnincorporatedMoved
+    );
+  },
+};
diff --git a/comm/mail/components/activity/modules/pop3Download.jsm b/comm/mail/components/activity/modules/pop3Download.jsm
new file mode 100644
index 0000000000..f203b33212
--- /dev/null
+++ b/comm/mail/components/activity/modules/pop3Download.jsm
@@ -0,0 +1,154 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+const EXPORTED_SYMBOLS = ["pop3DownloadModule"];
+
+var nsActEvent = Components.Constructor(
+  "@mozilla.org/activity-event;1",
+  "nsIActivityEvent",
+  "init"
+);
+
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PluralForm } = ChromeUtils.importESModule(
+  "resource://gre/modules/PluralForm.sys.mjs"
+);
+
+// This module provides a link between the pop3 service code and the activity
+// manager.
+var pop3DownloadModule = {
+  // hash table of most recent download items per folder
+  _mostRecentActivityForFolder: new Map(),
+  // hash table of prev download items per folder, so we can
+  // coalesce consecutive no new message events.
+  _prevActivityForFolder: new Map(),
+
+  get log() {
+    delete this.log;
+    return (this.log = console.createInstance({
+      prefix: "mail.activity",
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mail.activity.loglevel",
+    }));
+  },
+
+  get activityMgr() {
+    delete this.activityMgr;
+    return (this.activityMgr = Cc["@mozilla.org/activity-manager;1"].getService(
+      Ci.nsIActivityManager
+    ));
+  },
+
+  get bundle() {
+    delete this.bundle;
+    return (this.bundle = Services.strings.createBundle(
+      "chrome://messenger/locale/activity.properties"
+    ));
+  },
+
+  getString(stringName) {
+    try {
+      return this.bundle.GetStringFromName(stringName);
+    } catch (e) {
+      this.log.error("error trying to get a string called: " + stringName);
+      throw e;
+    }
+  },
+
+  onDownloadStarted(aFolder) {
+    this.log.info("in onDownloadStarted");
+
+    let displayText = this.bundle.formatStringFromName(
+      "pop3EventStartDisplayText2",
+      [
+        aFolder.server.prettyName, // account name
+        aFolder.prettyName,
+      ]
+    ); // folder name
+    // remember the prev activity for this folder, if any.
+    this._prevActivityForFolder.set(
+      aFolder.URI,
+      this._mostRecentActivityForFolder.get(aFolder.URI)
+    );
+    let statusText = aFolder.server.prettyName;
+
+    // create an activity event
+    let event = new nsActEvent(
+      displayText,
+      aFolder,
+      statusText,
+      Date.now(), // start time
+      Date.now()
+    ); // completion time
+
+    event.iconClass = "syncMail";
+
+    let downloadItem = {};
+    downloadItem.eventID = this.activityMgr.addActivity(event);
+    this._mostRecentActivityForFolder.set(aFolder.URI, downloadItem);
+  },
+
+  onDownloadProgress(aFolder, aNumMsgsDownloaded, aTotalMsgs) {
+    this.log.info("in onDownloadProgress");
+  },
+
+  onDownloadCompleted(aFolder, aNumMsgsDownloaded) {
+    this.log.info("in onDownloadCompleted");
+
+    // Remove activity if there was any.
+    // It can happen that download never started (e.g. couldn't connect to server),
+    // with onDownloadStarted, but we still get a onDownloadCompleted event
+    // when the connection is given up.
+    let recentActivity = this._mostRecentActivityForFolder.get(aFolder.URI);
+    if (recentActivity) {
+      this.activityMgr.removeActivity(recentActivity.eventID);
+    }
+
+    let displayText;
+    if (aNumMsgsDownloaded > 0) {
+      displayText = PluralForm.get(
+        aNumMsgsDownloaded,
+        this.getString("pop3EventStatusText")
+      );
+      displayText = displayText.replace("#1", aNumMsgsDownloaded);
+    } else {
+      displayText = this.getString("pop3EventStatusTextNoMsgs");
+    }
+
+    let statusText = aFolder.server.prettyName;
+
+    // create an activity event
+    let event = new nsActEvent(
+      displayText,
+      aFolder,
+      statusText,
+      Date.now(), // start time
+      Date.now()
+    ); // completion time
+
+    event.iconClass = "syncMail";
+
+    let downloadItem = { numMsgsDownloaded: aNumMsgsDownloaded };
+    this._mostRecentActivityForFolder.set(aFolder.URI, downloadItem);
+    downloadItem.eventID = this.activityMgr.addActivity(event);
+    if (!aNumMsgsDownloaded) {
+      // If we didn't download any messages this time, and the prev event
+      // for this folder also didn't download any messages, remove the
+      // prev event from the activity manager.
+      let prevItem = this._prevActivityForFolder.get(aFolder.URI);
+      if (prevItem != undefined && !prevItem.numMsgsDownloaded) {
+        if (this.activityMgr.containsActivity(prevItem.eventID)) {
+          this.activityMgr.removeActivity(prevItem.eventID);
+        }
+      }
+    }
+  },
+  init() {
+    // XXX when do we need to remove ourselves?
+    MailServices.pop3.addListener(this);
+  },
+};
diff --git a/comm/mail/components/activity/modules/sendLater.jsm b/comm/mail/components/activity/modules/sendLater.jsm
new file mode 100644
index 0000000000..37027d96f1
--- /dev/null
+++ b/comm/mail/components/activity/modules/sendLater.jsm
@@ -0,0 +1,298 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+const EXPORTED_SYMBOLS = ["sendLaterModule"];
+
+var nsActProcess = Components.Constructor(
+  "@mozilla.org/activity-process;1",
+  "nsIActivityProcess",
+  "init"
+);
+var nsActEvent = Components.Constructor(
+  "@mozilla.org/activity-event;1",
+  "nsIActivityEvent",
+  "init"
+);
+var nsActWarning = Components.Constructor(
+  "@mozilla.org/activity-warning;1",
+  "nsIActivityWarning",
+  "init"
+);
+
+/**
+ * This really, really, sucks. Due to mailnews widespread use of
+ * nsIMsgStatusFeedback we're bound to the UI to get any sensible feedback of
+ * mail sending operations. The current send later code can't hook into the
+ * progress listener easily to get the state of messages being sent, so we'll
+ * just have to do it here.
+ */
+var sendMsgProgressListener = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIMsgStatusFeedback",
+    "nsISupportsWeakReference",
+  ]),
+
+  showStatusString(aStatusText) {
+    sendLaterModule.onMsgStatus(aStatusText);
+  },
+
+  startMeteors() {},
+
+  stopMeteors() {},
+
+  showProgress(aPercentage) {
+    sendLaterModule.onMessageSendProgress(0, 0, aPercentage, 0);
+  },
+};
+
+// This module provides a link between the send later service and the activity
+// manager.
+var sendLaterModule = {
+  _sendProcess: null,
+  _copyProcess: null,
+  _identity: null,
+  _subject: null,
+
+  get log() {
+    delete this.log;
+    return (this.log = console.createInstance({
+      prefix: "mail.activity",
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mail.activity.loglevel",
+    }));
+  },
+
+  get activityMgr() {
+    delete this.activityMgr;
+    return (this.activityMgr = Cc["@mozilla.org/activity-manager;1"].getService(
+      Ci.nsIActivityManager
+    ));
+  },
+
+  get bundle() {
+    delete this.bundle;
+    return (this.bundle = Services.strings.createBundle(
+      "chrome://messenger/locale/activity.properties"
+    ));
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIMsgSendLaterListener"]),
+
+  _displayTextForHeader(aLocaleStringBase, aSubject) {
+    return aSubject
+      ? this.bundle.formatStringFromName(aLocaleStringBase + "WithSubject", [
+          aSubject,
+        ])
+      : this.bundle.GetStringFromName(aLocaleStringBase);
+  },
+
+  _newProcess(aLocaleStringBase, aAddSubject) {
+    let process = new nsActProcess(
+      this._displayTextForHeader(
+        aLocaleStringBase,
+        aAddSubject ? this._subject : ""
+      ),
+      this.activityMgr
+    );
+
+    process.iconClass = "sendMail";
+    process.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT;
+    process.contextObj = this;
+    process.contextType = "SendLater";
+    process.contextDisplayText =
+      this.bundle.GetStringFromName("sendingMessages");
+
+    return process;
+  },
+
+  // Use this to group an activity by the identity if we have one.
+  _applyIdentityGrouping(aActivity) {
+    if (this._identity) {
+      aActivity.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_BYCONTEXT;
+      aActivity.contextType = this._identity.key;
+      aActivity.contextObj = this._identity;
+      let contextDisplayText = this._identity.identityName;
+      if (!contextDisplayText) {
+        contextDisplayText = this._identity.email;
+      }
+
+      aActivity.contextDisplayText = contextDisplayText;
+    } else {
+      aActivity.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_STANDALONE;
+    }
+  },
+
+  // Replaces the process with an event that reflects a completed process.
+  _replaceProcessWithEvent(aProcess) {
+    this.activityMgr.removeActivity(aProcess.id);
+
+    let event = new nsActEvent(
+      this._displayTextForHeader("sentMessage", this._subject),
+      this.activityMgr,
+      "",
+      aProcess.startTime,
+      new Date()
+    );
+
+    event.iconClass = "sendMail";
+    this._applyIdentityGrouping(event);
+
+    this.activityMgr.addActivity(event);
+  },
+
+  // Replaces the process with a warning that reflects the failed process.
+  _replaceProcessWithWarning(
+    aProcess,
+    aCopyOrSend,
+    aStatus,
+    aMsg,
+    aMessageHeader
+  ) {
+    this.activityMgr.removeActivity(aProcess.id);
+
+    let warning = new nsActWarning(
+      this._displayTextForHeader("failedTo" + aCopyOrSend, this._subject),
+      this.activityMgr,
+      ""
+    );
+
+    warning.groupingStyle = Ci.nsIActivity.GROUPING_STYLE_STANDALONE;
+    this._applyIdentityGrouping(warning);
+
+    this.activityMgr.addActivity(warning);
+  },
+
+  onStartSending(aTotalMessageCount) {
+    if (!aTotalMessageCount) {
+      this.log.error("onStartSending called with zero messages\n");
+    }
+  },
+
+  onMessageStartSending(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageHeader,
+    aIdentity
+  ) {
+    // We want to use the identity and subject later, so store them for now.
+    this._identity = aIdentity;
+    if (aMessageHeader) {
+      this._subject = aMessageHeader.mime2DecodedSubject;
+    }
+
+    // Create the process to display the send activity.
+    let process = this._newProcess("sendingMessage", true);
+    this._sendProcess = process;
+    this.activityMgr.addActivity(process);
+
+    // Now the one for the copy process.
+    process = this._newProcess("copyMessage", false);
+    this._copyProcess = process;
+    this.activityMgr.addActivity(process);
+  },
+
+  onMessageSendProgress(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageSendPercent,
+    aMessageCopyPercent
+  ) {
+    if (aMessageSendPercent < 100) {
+      // Ensure we are in progress...
+      if (this._sendProcess.state != Ci.nsIActivityProcess.STATE_INPROGRESS) {
+        this._sendProcess.state = Ci.nsIActivityProcess.STATE_INPROGRESS;
+      }
+
+      // ... and update the progress.
+      this._sendProcess.setProgress(
+        this._sendProcess.lastStatusText,
+        aMessageSendPercent,
+        100
+      );
+    } else if (aMessageSendPercent == 100) {
+      if (aMessageCopyPercent == 0) {
+        // Set send state to completed
+        if (this._sendProcess.state != Ci.nsIActivityProcess.STATE_COMPLETED) {
+          this._sendProcess.state = Ci.nsIActivityProcess.STATE_COMPLETED;
+        }
+        this._replaceProcessWithEvent(this._sendProcess);
+
+        // Set copy state to in progress.
+        if (this._copyProcess.state != Ci.nsIActivityProcess.STATE_INPROGRESS) {
+          this._copyProcess.state = Ci.nsIActivityProcess.STATE_INPROGRESS;
+        }
+
+        // We don't know the progress of the copy, so just set to 0, and we'll
+        // display an undetermined progress meter.
+        this._copyProcess.setProgress(this._copyProcess.lastStatusText, 0, 0);
+      } else if (aMessageCopyPercent >= 100) {
+        // We need to set this to completed otherwise activity manager
+        // complains.
+        if (this._copyProcess) {
+          this._copyProcess.state = Ci.nsIActivityProcess.STATE_COMPLETED;
+          this.activityMgr.removeActivity(this._copyProcess.id);
+          this._copyProcess = null;
+        }
+
+        this._sendProcess = null;
+      }
+    }
+  },
+
+  onMessageSendError(aCurrentMessage, aMessageHeader, aStatus, aMsg) {
+    if (
+      this._sendProcess &&
+      this._sendProcess.state != Ci.nsIActivityProcess.STATE_COMPLETED
+    ) {
+      this._sendProcess.state = Ci.nsIActivityProcess.STATE_COMPLETED;
+      this._replaceProcessWithWarning(
+        this._sendProcess,
+        "SendMessage",
+        aStatus,
+        aMsg,
+        aMessageHeader
+      );
+      this._sendProcess = null;
+
+      if (
+        this._copyProcess &&
+        this._copyProcess.state != Ci.nsIActivityProcess.STATE_COMPLETED
+      ) {
+        this._copyProcess.state = Ci.nsIActivityProcess.STATE_COMPLETED;
+        this.activityMgr.removeActivity(this._copyProcess.id);
+        this._copyProcess = null;
+      }
+    }
+  },
+
+  onMsgStatus(aStatusText) {
+    this._sendProcess.setProgress(
+      aStatusText,
+      this._sendProcess.workUnitComplete,
+      this._sendProcess.totalWorkUnits
+    );
+  },
+
+  onStopSending(aStatus, aMsg, aTotalTried, aSuccessful) {},
+
+  init() {
+    // We should need to remove the listener as we're not being held by anyone
+    // except by the send later instance.
+    let sendLaterService = Cc[
+      "@mozilla.org/messengercompose/sendlater;1"
+    ].getService(Ci.nsIMsgSendLater);
+
+    sendLaterService.addListener(this);
+
+    // Also add the nsIMsgStatusFeedback object.
+    let statusFeedback = Cc[
+      "@mozilla.org/messenger/statusfeedback;1"
+    ].createInstance(Ci.nsIMsgStatusFeedback);
+
+    statusFeedback.setWrappedStatusFeedback(sendMsgProgressListener);
+
+    sendLaterService.statusFeedback = statusFeedback;
+  },
+};
diff --git a/comm/mail/components/activity/moz.build b/comm/mail/components/activity/moz.build
new file mode 100644
index 0000000000..efceaacf9f
--- /dev/null
+++ b/comm/mail/components/activity/moz.build
@@ -0,0 +1,34 @@
+# vim: set filetype=python:
+# 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/.
+
+XPIDL_SOURCES += [
+    "nsIActivity.idl",
+    "nsIActivityManager.idl",
+    "nsIActivityManagerUI.idl",
+]
+
+XPIDL_MODULE = "activity"
+
+EXTRA_JS_MODULES.activity += [
+    "modules/activityModules.jsm",
+    "modules/alertHook.jsm",
+    "modules/autosync.jsm",
+    "modules/glodaIndexer.jsm",
+    "modules/moveCopy.jsm",
+    "modules/pop3Download.jsm",
+    "modules/sendLater.jsm",
+]
+
+EXTRA_JS_MODULES += [
+    "Activity.jsm",
+    "ActivityManager.jsm",
+    "ActivityManagerUI.jsm",
+]
+
+JAR_MANIFESTS += ["jar.mn"]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
diff --git a/comm/mail/components/activity/nsIActivity.idl b/comm/mail/components/activity/nsIActivity.idl
new file mode 100644
index 0000000000..d80e69088f
--- /dev/null
+++ b/comm/mail/components/activity/nsIActivity.idl
@@ -0,0 +1,492 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "nsISupports.idl"
+#include "nsISupportsPrimitives.idl"
+
+interface nsIActivityListener;
+interface nsIActivity;
+interface nsIActivityProcess;
+interface nsIActivityEvent;
+interface nsIActivityWarning;
+interface nsIVariant;
+interface nsISupportsPRTime;
+
+/**
+ * See https://wiki.mozilla.org/Thunderbird:Activity_Manager/Developer for UML
+ * diagram and sample codes.
+ */
+
+/**
+ * Background:
+ * Activity handlers define the behavioral capabilities of the activities. They
+ * are used by the Activity Manager to change the execution flow of the activity
+ * based on the user interaction. They are not mandatory, but when set, causes
+ * behavioral changes on the binding representing the activity, such as showing
+ * a cancel button, etc. The following handlers are currently supported;
+ */
+
+/**
+ * The handler to invoke when the recover button is pressed. Used by a Warning
+ * to recover from the situation causing the warning. For instance, recovery
+ * action for a "Over Quota Limit" warning, would be to cleanup some disk space,
+ * and this operation can be implemented and set by the activity developer in
+ * form of nsIActivityRecoveryHandler component.
+ */
+[scriptable, uuid(30E0A76F-880A-4093-8F3C-AF2239977A3D)]
+interface nsIActivityRecoveryHandler : nsISupports {
+  nsresult recover(in nsIActivityWarning aActivity);
+};
+
+/**
+ * The handler to invoke when the cancel button is pressed. Used by a Process to
+ * cancel the operation.
+ */
+[scriptable, uuid(35ee2461-70db-4b3a-90d0-7a68c856e911)]
+interface nsIActivityCancelHandler : nsISupports {
+  nsresult cancel(in nsIActivityProcess aActivity);
+};
+
+/**
+ * The handler to invoke when the pause button is pressed. Used by a Process to
+ * pause/resume the operation.
+ */
+[scriptable, uuid(9eee22bf-5378-460e-83a7-781cdcc9050b)]
+interface nsIActivityPauseHandler : nsISupports {
+  nsresult pause(in nsIActivityProcess aActivity);
+  nsresult resume(in nsIActivityProcess aActivity);
+};
+
+/**
+ * The handler to invoke when the retry button is pressed. Used by a Process to
+ * retry the operation in case of failure.
+ */
+[scriptable, uuid(8ec42517-951f-4bc0-aba5-fde7258b1705)]
+interface nsIActivityRetryHandler : nsISupports {
+  nsresult retry(in nsIActivityProcess aActivity);
+};
+
+/**
+ * The handler to invoke when the undo button is pressed. Used by a Event to
+ * undo the operation generated the event.
+ */
+[scriptable, uuid(b8632ac7-9d8b-4341-a349-ef000e8c89ac)]
+interface nsIActivityUndoHandler : nsISupports {
+  nsresult undo(in nsIActivityEvent aActivity);
+};
+
+/**
+ * Base interface of all activity interfaces. It is abstract in a sense that
+ * there is no component in the activity management system that solely
+ * implements this interface.
+ */
+[scriptable, uuid(6CD33E65-B2D8-4634-9B6D-B80BF1273E99)]
+interface nsIActivity : nsISupports {
+
+  /**
+   * Shows the activity as a standalone item.
+   */
+  const short GROUPING_STYLE_STANDALONE = 1;
+
+  /**
+   * Groups activity by its context.
+   */
+  const short GROUPING_STYLE_BYCONTEXT = 2;
+
+  /**
+   * Internal ID given by the activity manager when
+   * added into the activity list.  Not readonly so that
+   * the activity manager can write to them, but not to be written to
+   * by anyone else.
+   */
+  attribute unsigned long id;
+
+  // Following attributes change the UI characteristics of the activity
+
+  /**
+   * A brief description of the activity, to be shown by the
+   * associated binding (XBL) in the Activity Manager window.
+   */
+  readonly attribute AString displayText;
+
+  /**
+   * Changes the default icon associated with the activity. Core activity
+   * icons are declared in |mail/themes/<themename>/mail/activity/activity.css|
+   * files.
+   *
+   * Extension developers can add and assign their own icons by setting
+   * this attribute.
+   */
+  attribute AString iconClass;
+
+  /**
+   * Textual id of the XBL binding that will be used to represent the
+   * activity in the Activity Manager window.
+   *
+   * This attribute allows to associate default activity components
+   * with custom XBL bindings. See |activity.xml| file for default
+   * activity XBL bindings, and |activity.css| file for default binding
+   * associations.
+   */
+  attribute AString bindingName;
+
+  /**
+   * Defines the grouping style of the activity when being shown in the
+   * activity manager window:
+   *  GROUPING_STYLE_STANDALONE or GROUPING_STYLE_BYCONTEXT
+   */
+  attribute short groupingStyle;
+
+  /**
+   * A text value to associate a facet type with the activity. If empty,
+   * the activity will be shown in the 'Misc' section.
+   */
+  attribute AString facet;
+
+  // UI related attributes end.
+
+  /**
+   * Gets the initiator of the activity. An initiator represents an object
+   * that generates and controls the activity. For example, Copy Service can be
+   * the initiator of the copy, and move activities. Similarly Gloda can be the
+   * initiator of indexing activity, etc.
+   *
+   * This attribute is used mostly by handler components to change the execution
+   * flow of the activity such as canceling, pausing etc. Since not used by the
+   * Activity Manager, it is not mandatory to set it.
+   *
+   * An initiator can be any JS Object or an XPCOM component that provides an
+   * nsIVariant interface.
+   */
+  readonly attribute nsIVariant initiator;
+
+  /**
+   * Adds an object to the activity's internal subject list. Subject list
+   * provides argument(s) to activity handlers to complete their operation.
+   * For example, nsIActivityUndoHandler needs the source and destination
+   * folders to undo a move operation.
+   *
+   * Since subjects are not used by the Activity Manager, it is up to the
+   * activity developer to provide these objects.
+   *
+   * A subject can be any JS object or XPCOM component that supports nsIVariant
+   * interface.
+   */
+  void addSubject(in nsIVariant aSubject);
+
+  /**
+   * Retrieves all subjects associated with this activity.
+   *
+   * @return The list of subject objects associated by the activity.
+   */
+  Array<nsIVariant> getSubjects();
+
+  /*
+   * Background:
+   *  A context is a generic concept that is used to group the processes and
+   *  warnings having similar properties such as same imap server, same smtp
+   *  server etc.
+   *  A context is uniquely identified by its "type" and "object" attributes.
+   *  Each activity that has the same context type and object are considered
+   *  belong to the same logical group, context.
+   *
+   *  There are 4 predefined context types known by the Activity Manager:
+   *  Account, Smtp, Calendar, and Addressbook. The most common context type
+   *  for activities is the "Account Context" and when combined with an account
+   *  server instance, it allows to group different activities happening on the
+   *  the same account server.
+   */
+
+  /**
+   * Sets and gets the context object of the activity. A context object can be
+   * any JS object or XPCOM component that supports nsIVariant interface.
+   */
+  attribute nsIVariant contextObj;
+
+  /**
+   * Sets and gets the context type of the activity. If this is set, then
+   * the contextDisplayText should also be set.
+   */
+  attribute AString contextType;
+
+  /**
+   * Return the displayText to be used for the context
+   **/
+  attribute AString contextDisplayText;
+
+  /**
+   * Adds a listener. See nsIActivityListener below.
+   */
+  void addListener(in nsIActivityListener aListener);
+
+  /**
+   * Removes the given listener. See nsIActivityListener below.
+   */
+  void removeListener(in nsIActivityListener aListener);
+};
+
+
+/**
+ * A Process represents an on-going activity.
+ */
+[scriptable, uuid(9DC7CA67-828D-4AFD-A5C6-3ECE091A98B8)]
+interface nsIActivityProcess : nsIActivity {
+
+  /**
+   * Default state for uninitialized process activity
+   * object.
+   */
+  const short STATE_NOTSTARTED = -1;
+
+  /**
+   * Activity is currently in progress.
+   */
+  const short STATE_INPROGRESS = 0;
+
+  /**
+   * Activity is completed.
+   */
+  const short STATE_COMPLETED = 1;
+
+  /**
+   * Activity was canceled by the user.
+   * (same as completed)
+   */
+  const short STATE_CANCELED = 2;
+
+  /**
+   * Activity was paused by the user.
+   */
+  const short STATE_PAUSED = 3;
+
+  /**
+   * Activity waits for the user input's to retry.
+   * (i.e. login password)
+   */
+  const short STATE_WAITINGFORINPUT = 4;
+
+  /**
+   * Activity is ready for an automatic or manual retry.
+   */
+  const short STATE_WAITINGFORRETRY = 5;
+
+  /**
+   * The state of the activity.
+   * See above for possible values.
+   * @exception NS_ERROR_ILLEGAL_VALUE if the state isn't one of the states
+   *   defined above.
+   */
+  attribute short state;
+
+  /**
+   * The percentage of activity completed.
+   * If the max value is unknown it'll be -1 here.
+   */
+  readonly attribute long percentComplete;
+
+  /**
+   * A brief text about the process' status.
+   */
+  readonly attribute AString lastStatusText;
+
+  /**
+   * The amount of work units completed so far.
+   */
+  readonly attribute unsigned long workUnitComplete;
+
+  /**
+   * Total amount of work units.
+   */
+  readonly attribute unsigned long totalWorkUnits;
+
+  /**
+   * The starting time of the process.
+   * 64-bit signed integers relative to midnight (00:00:00), January 1, 1970
+   * Greenwich Mean Time (GMT). (GMT is also known as Coordinated Universal
+   * Time, UTC.). The units of time are in microseconds.
+   *
+   * In JS Date.now(), in C++ PR_Now() / PR_USEC_PER_MSEC can be used to set
+   * this value.
+   */
+  readonly attribute long long startTime;
+
+  /**
+   * The handler to invoke when the cancel button is pressed. If present
+   * (non-null), the activity can be canceled and a cancel button will be
+   * displayed to the user.  If null, it cannot be canceled and no button will
+   * be displayed.
+   */
+  attribute nsIActivityCancelHandler cancelHandler;
+
+  /**
+   * The handler to invoke when the pause button is pressed. If present
+   * (non-null), the activity can be pauseable and a pause button will be
+   * displayed to the user.  If null, it cannot be paused and no button will
+   * be displayed.
+   */
+  attribute nsIActivityPauseHandler pauseHandler;
+
+  /**
+   * The handler to invoke when the retry button is pressed. If present
+   * (non-null), the activity can be retryable and a retry button will be
+   * displayed to the user.  If null, it cannot be retried and no button will
+   * be displayed.
+   */
+  attribute nsIActivityRetryHandler retryHandler;
+
+  /**
+   * Updates the activity progress info.
+   *
+   * @param aStatusText A localized text describing the current status of the
+   *                    process
+   * @param aWorkUnitComplete The amount of work units completed. Not used by
+   *                          Activity Manager or default binding for any
+   *                          purpose.
+   * @param aTotalWorkUnits Total amount of work units. Not used by
+   *                        Activity Manager or default binding for any
+   *                        purpose. If set to zero, this indicates that the
+   *                        number of work units is unknown, and the percentage
+   *                        attribute will be set to -1.
+   */
+  void setProgress(in AString aStatusText,
+                   in unsigned long aWorkUnitComplete,
+                   in unsigned long aTotalWorkUnits);
+
+  /**
+   * Component initialization method.
+   *
+   * @param aDisplayText A localized text to be shown on the Activity Manager
+   *                     window
+   * @param aInitiator The initiator of the process
+   */
+  void init(in AString aDisplayText, in nsIVariant aInitiator);
+};
+
+/**
+ * Historical actions performed by the user, by extensions or by the system.
+ */
+[scriptable, uuid(5B1B0D03-2820-4E37-8BF8-102AFDE4FC45)]
+interface nsIActivityEvent : nsIActivity {
+
+  /**
+   * Any localized textual information related to this event.
+   * It is shown at the bottom of the displayText area.
+   */
+  readonly attribute AString statusText;
+
+  /**
+   * The starting time of the event.
+   * 64-bit signed integers relative to midnight (00:00:00), January 1, 1970
+   * Greenwich Mean Time (GMT). (GMT is also known as Coordinated Universal
+   * Time, UTC.). The units of time are in microseconds.
+   *
+   * In JS Date.now(), in C++ PR_Now() / PR_USEC_PER_MSEC can be used to set
+   * this value.
+   */
+  readonly attribute long long startTime;
+
+  /**
+   * The completion time of the event in microseconds.
+   * 64-bit signed integers relative to midnight (00:00:00), January 1, 1970
+   * Greenwich Mean Time (GMT). (GMT is also known as Coordinated Universal
+   * Time, UTC.). The units of time are in microseconds.
+   *
+   * In JS Date.now(), in C++ PR_Now() / PR_USEC_PER_MSEC can be used to set
+   * this value.
+   */
+  readonly attribute long long completionTime;
+
+  /**
+   * The handler to invoke when the undo button is pressed.  If present
+   * (non-null), the activity can be undoable and an undo button will be
+   * displayed to the user.  If null, it cannot be undone and no button will
+   * be displayed.
+   */
+  attribute nsIActivityUndoHandler undoHandler;
+
+  /**
+   * Component initialization method.
+   *
+   * @param aDisplayText Any localized text describing the event and its context
+   * @param aInitiator The initiator of the event
+   * @param aStatusText Any localized additional information about the event
+   * @param aStartTime The starting time of the event
+   * @param aCompletionTime The completion time of the event
+   */
+  void init(in AString aDisplayText, in nsIVariant aInitiator,
+            in AString aStatusText, in long long aStartTime,
+            in long long aCompletionTime);
+};
+
+[scriptable, uuid(8265833e-c604-4585-a43c-a76bd8ed3a8c)]
+interface nsIActivityWarning : nsIActivity {
+
+  /**
+   * Any localized textual information related to this warning.
+   */
+  readonly attribute AString warningText;
+
+  /**
+   * The time of the warning.
+   * 64-bit signed integers relative to midnight (00:00:00), January 1, 1970
+   * Greenwich Mean Time (GMT). (GMT is also known as Coordinated Universal
+   * Time, UTC.). The units of time are in microseconds.
+   *
+   * In JS Date.now(), in C++ PR_Now() / PR_USEC_PER_MSEC can be used to set
+   * this value.
+   */
+  readonly attribute long long time;
+
+  /**
+   * Recovery tip of the warning, localized.
+   */
+  readonly attribute AString recoveryTipText;
+
+  /**
+   * The handler to invoke when the recover button is pressed.  If present
+   * (non-null), the activity can be recoverable and a recover button will be
+   * displayed to the user.  If null, it cannot be recovered and no button will
+   * be displayed.
+   */
+  attribute nsIActivityRecoveryHandler recoveryHandler;
+
+  /**
+   * Component initialization method.
+   *
+   * @param aWarningText The localized text that will be shown on the display
+   *                     area
+   * @param aInitiator The initiator of the warning
+   * @param aRecoveryTip A localized textual information to guide the user in
+   *                     order to recover from the warning situation.
+   */
+  void init(in AString aWarningText, in nsIVariant aInitiator,
+            in AString aRecoveryTip);
+};
+
+[scriptable, uuid(bd11519f-b297-4b34-a793-1861dc90d5e9)]
+interface nsIActivityListener : nsISupports {
+  /**
+   * Triggered after activity state is changed.
+   */
+  void onStateChanged(in nsIActivity aActivity, in short aOldState);
+
+  /**
+   * Triggered after the progress of the process activity is changed.
+   */
+  void onProgressChanged(in nsIActivity aActivity,
+                         in AString aStatusText,
+                         in unsigned long aWorkUnitsCompleted,
+                         in unsigned long aTotalWorkUnits);
+
+  /**
+   * Triggered after one of the activity handler is set.
+   *
+   * This is mostly used to update the UI of the activity when
+   * one of the handler is set to null after the operation is completed.
+   * For example after the activity is undone, to make the undo button
+   * invisible.
+   */
+  void onHandlerChanged(in nsIActivity aActivity);
+};
diff --git a/comm/mail/components/activity/nsIActivityManager.idl b/comm/mail/components/activity/nsIActivityManager.idl
new file mode 100644
index 0000000000..860b4e1e2b
--- /dev/null
+++ b/comm/mail/components/activity/nsIActivityManager.idl
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "nsISupports.idl"
+
+interface mozIStorageConnection;
+interface nsIActivity;
+interface nsIActivityProcess;
+interface nsIVariant;
+
+/**
+ * See https://wiki.mozilla.org/Thunderbird:Activity_Manager/Developer for UML
+ * diagram and sample codes.
+ */
+
+/**
+ * An interface to get notified by the major Activity Manager events.
+ * Mostly used by UI glue code in activity.js.
+ */
+[scriptable, uuid(14cfad1c-3401-4c44-ab04-4a11b6662663)]
+interface nsIActivityMgrListener : nsISupports {
+  /**
+   * Called _after_ activity manager adds an activity into
+   * the managed list.
+   */
+  void onAddedActivity(in unsigned long aID, in nsIActivity aActivity);
+
+  /**
+   * Called _after_ activity manager removes an activity from
+   * the managed list.
+   */
+  void onRemovedActivity(in unsigned long aID);
+};
+
+/**
+ * Activity Manager is a simple component that understands how do display a
+ * combination of user activity and history. The activity manager works in
+ * conjunction with the 'Interactive Status Bar' to give the user the right
+ * level of notifications concerning what Thunderbird is doing on it's own and
+ * how Thunderbird has handled user requests.
+ *
+ * There are 3 different classifications of activity items which can be
+ * displayed in the Activity Manager Window:
+ *  o Process: Processes are transient in the display. They are not written to
+ *    disk as they are always acting on some data that already exists
+ *    locally or remotely. If a process has finished and needs to keep
+ *    some state for the user (like last sync time) it can convert
+ *    itself into an event.
+ * o Event: Historical actions performed by the user and created by a process
+ *   for the Activity Manager Window. Events can show up in the
+ *   'Interactive Status Bar' and be displayed to users as they are
+ *   created.
+ * o Warning: Alerts sent by Thunderbird or servers (i.e. imap server) that need
+ *   attention by the user. For example a Quota Alert from the imap
+ *   server can be represented as a Warning to the user. They are not
+ *   written to disk.
+ */
+[scriptable, uuid(9BFCC031-50E1-4D30-A35F-23509ABCB8D1)]
+interface nsIActivityManager : nsISupports {
+
+  /**
+   * Adds the given activity into the managed activities list.
+   *
+   * @param aActivity The activity that will be added.
+   *
+   * @return Unique activity identifier.
+   */
+  unsigned long addActivity(in nsIActivity aActivity);
+
+  /**
+   * Removes the activity with the given id if it's not currently
+   * in-progress.
+   *
+   * @param aID The unique ID of the activity.
+   *
+   * @throws NS_ERROR_FAILURE if the activity is in-progress.
+   */
+  void removeActivity(in unsigned long aID);
+
+  /**
+   * Retrieves an activity managed by the activity manager. This can be one that
+   * is in progress, or one that has completed in the past and is stored in the
+   * persistent store.
+   *
+   * @param aID The unique ID of the activity.
+   *
+   * @return The activity with the specified ID, or null if not found.
+   */
+  nsIActivity getActivity(in unsigned long aID);
+
+  /**
+   * Tests whether the activity in question in the activity list or not.
+   */
+  boolean containsActivity(in unsigned long aID);
+
+  /**
+   * Retrieves all activities managed by the activity manager. This can be one
+   * that is in progress (process), one that is represented as a warning, or one
+   * that has completed (event) in the past and is stored in the persistent
+   * store.
+   *
+   * @return A read-only list of activities managed by the activity manager.
+   */
+  Array<nsIActivity> getActivities();
+
+  /**
+   * Retrieves processes with given context type and object.
+   *
+   * @return A read-only list of processes matching to given criteria.
+   */
+  Array<nsIActivityProcess> getProcessesByContext(in AString aContextType,
+                                                  in nsIVariant aContextObject);
+
+  /**
+   *  Call to remove all activities apart from those that are in progress.
+   */
+  void cleanUp();
+
+  /**
+   * The number of processes in the activity list.
+   */
+  readonly attribute long processCount;
+
+  /**
+   * Adds a listener.
+   */
+  void addListener(in nsIActivityMgrListener aListener);
+
+  /**
+   * Removes the given listener.
+   */
+  void removeListener(in nsIActivityMgrListener aListener);
+};
diff --git a/comm/mail/components/activity/nsIActivityManagerUI.idl b/comm/mail/components/activity/nsIActivityManagerUI.idl
new file mode 100644
index 0000000000..07a2a30394
--- /dev/null
+++ b/comm/mail/components/activity/nsIActivityManagerUI.idl
@@ -0,0 +1,50 @@
+/* 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/. */
+
+#include "nsISupports.idl"
+
+interface nsIInterfaceRequestor;
+
+[scriptable, uuid(ae7853b0-2e1f-4dc1-89cd-f8bbfb745d4d)]
+interface nsIActivityManagerUI : nsISupports {
+  /**
+   * The reason that should be passed when the user requests to show the
+   * activity manager's UI.
+   */
+  const short REASON_USER_INTERACTED = 0;
+
+  /**
+   * The reason that should be passed to the show method when we are displaying
+   * the UI because a new activity is being added to it.
+   */
+  const short REASON_NEW_ACTIVITY = 1;
+
+ /**
+  * Shows the Activity Manager's UI to the user.
+  *
+  * @param [optional] aWindowContext
+  *        The parent window context to show the UI.
+  * @param [optional] aID
+  *        The id of the activity to be preselected upon opening.
+  * @param [optional] aReason
+  *        The reason to show the activity manager's UI.  This defaults to
+  *        REASON_USER_INTERACTED, and should be one of the previously listed
+  *        constants.
+  */
+  void show([optional] in nsIInterfaceRequestor aWindowContext,
+            [optional] in unsigned long aID,
+            [optional] in short aReason);
+
+ /**
+  * Indicates if the UI is visible or not.
+  */
+  readonly attribute boolean visible;
+
+ /**
+  * Brings attention to the UI if it is already visible
+  *
+  * @throws NS_ERROR_UNEXPECTED if the UI is not visible.
+  */
+  void getAttention();
+};