--- a/calendar/base/backend/icaljs/calRecurrenceRule.js
+++ b/calendar/base/backend/icaljs/calRecurrenceRule.js
@@ -47,17 +47,17 @@ calRecurrenceRule.prototype = {
   },
 
   getNextOccurrence: function(aStartTime, aRecId) {
     aStartTime = unwrapSingle(ICAL.Time, aStartTime);
     aRecId = unwrapSingle(ICAL.Time, aRecId);
     return wrapGetter(calDateTime, this.innerObject.getNextOccurrence(aStartTime, aRecId));
   },
 
-  getOccurrences: function(aStartTime, aRangeStart, aRangeEnd, aMaxCount, aCount) {
+  getOccurrences: function(aStartTime, aRangeStart, aRangeEnd, aMaxCount) {
     aStartTime = unwrapSingle(ICAL.Time, aStartTime);
     aRangeStart = unwrapSingle(ICAL.Time, aRangeStart);
     aRangeEnd = unwrapSingle(ICAL.Time, aRangeEnd);
 
     if (!aMaxCount && !aRangeEnd && this.count == 0 && this.until == null) {
       throw Cr.NS_ERROR_INVALID_ARG;
     }
 
@@ -68,17 +68,16 @@ calRecurrenceRule.prototype = {
     let dtend = null;
 
     if (aRangeEnd) {
       dtend = aRangeEnd.clone();
       dtend.isDate = false;
 
       // If the start of the recurrence is past the end, we have no dates
       if (aStartTime.compare(dtend) >= 0) {
-        aCount.value = 0;
         return [];
       }
     }
 
     let iter = this.innerObject.iterator(aStartTime);
 
     for (let next = iter.next(); next; next = iter.next()) {
       let dtNext = next.clone();
@@ -100,17 +99,16 @@ calRecurrenceRule.prototype = {
 
       occurrences.push(new calDateTime(next));
 
       if (aMaxCount && aMaxCount >= occurrences.length) {
         break;
       }
     }
 
-    aCount.value = occurrences.length;
     return occurrences;
   },
 
   get icalString() {
     return "RRULE:" + this.innerObject.toString() + ICAL.newLineChar;
   },
   set icalString(val) {
     this.ensureMutable();

--- a/calendar/base/backend/libical/calRecurrenceRule.cpp
+++ b/calendar/base/backend/libical/calRecurrenceRule.cpp
@@ -381,21 +381,20 @@ static inline icaltimetype ensureDateTim
     return ret;
   }
 }
 
 NS_IMETHODIMP
 calRecurrenceRule::GetOccurrences(calIDateTime *aStartTime,
                                   calIDateTime *aRangeStart,
                                   calIDateTime *aRangeEnd, uint32_t aMaxCount,
-                                  uint32_t *aCount, calIDateTime ***aDates) {
+                                  nsTArray<RefPtr<calIDateTime>> &aDates) {
   NS_ENSURE_ARG_POINTER(aStartTime);
   NS_ENSURE_ARG_POINTER(aRangeStart);
-  NS_ENSURE_ARG_POINTER(aCount);
-  NS_ENSURE_ARG_POINTER(aDates);
+  aDates.ClearAndRetainStorage();
 
   // make sure the request is sane; infinite recurrence
   // with no end time is bad times.
   if (!aMaxCount && !aRangeEnd && mIcalRecur.count == 0 &&
       icaltime_is_null_time(mIcalRecur.until))
     return NS_ERROR_INVALID_ARG;
 
   nsCOMArray<calIDateTime> dates;
@@ -433,74 +432,50 @@ calRecurrenceRule::GetOccurrences(calIDa
     NS_ENSURE_SUCCESS(rv, rv);
 
     icalrangeend->ToIcalTime(&dtend);
     dtend = ensureDateTime(dtend);
 
     // if the start of the recurrence is past the end,
     // we have no dates
     if (icaltime_compare(dtstart, dtend) >= 0) {
-      *aDates = nullptr;
-      *aCount = 0;
       return NS_OK;
     }
   }
 
   icalrecur_iterator *recur_iter;
   recur_iter = icalrecur_iterator_new(mIcalRecur, dtstart);
   if (!recur_iter) return NS_ERROR_OUT_OF_MEMORY;
 
-  uint32_t count = 0;
-
   for (icaltimetype next = icalrecur_iterator_next(recur_iter);
        !icaltime_is_null_time(next);
        next = icalrecur_iterator_next(recur_iter)) {
     icaltimetype const dtNext(ensureDateTime(next));
 
     // if this thing is before the range start
     if (icaltime_compare(dtNext, rangestart) < 0) {
       continue;
     }
 
     if (aRangeEnd && icaltime_compare(dtNext, dtend) >= 0) break;
 
-    calIDateTime *const cdt = new calDateTime(&next, tz);
-    if (!cdt) {
-      icalrecur_iterator_free(recur_iter);
-      return NS_ERROR_OUT_OF_MEMORY;
-    }
-
-    dates.AppendObject(cdt);
+    calIDateTime *cdt = new calDateTime(&next, tz);
+    aDates.AppendElement(cdt);
 #ifdef DEBUG_dbo
     {
       nsAutoCString str;
       cdt->ToString(str);
       printf("  occ: %s\n", str.get());
     }
 #endif
-    count++;
-    if (aMaxCount && aMaxCount <= count) break;
+    if (aMaxCount && aMaxCount <= aDates.Length()) break;
   }
 
   icalrecur_iterator_free(recur_iter);
 
-  if (count) {
-    calIDateTime **const dateArray = static_cast<calIDateTime **>(
-        moz_xmalloc(sizeof(calIDateTime *) * count));
-    CAL_ENSURE_MEMORY(dateArray);
-    for (uint32_t i = 0; i < count; ++i) {
-      NS_ADDREF(dateArray[i] = dates[i]);
-    }
-    *aDates = dateArray;
-  } else {
-    *aDates = nullptr;
-  }
-
-  *aCount = count;
-
   return NS_OK;
 }
 
 /**
  ** ical property getting/setting
  **/
 NS_IMETHODIMP
 calRecurrenceRule::GetIcalProperty(calIIcalProperty **prop) {

--- a/calendar/base/public/calIRecurrenceItem.idl
+++ b/calendar/base/public/calIRecurrenceItem.idl
@@ -40,17 +40,16 @@ interface calIRecurrenceItem : nsISuppor
    * @param aTime           The earliest time to find the occurrence after.
    */
   calIDateTime getNextOccurrence(in calIDateTime aRecurrenceId,
                                  in calIDateTime aTime);
 
   // return array of calIDateTime of the start of all occurrences of
   // this event starting at aStartTime, between rangeStart and an
   // optional rangeEnd
-  void getOccurrences (in calIDateTime aStartTime,
-                       in calIDateTime aRangeStart,
-                       in calIDateTime aRangeEnd,
-                       in unsigned long aMaxCount,
-                       out unsigned long aCount, [array,size_is(aCount),retval] out calIDateTime aDates);
+  Array<calIDateTime> getOccurrences(in calIDateTime aStartTime,
+                                     in calIDateTime aRangeStart,
+                                     in calIDateTime aRangeEnd,
+                                     in unsigned long aMaxCount);
 
   attribute calIIcalProperty icalProperty;
   attribute AUTF8String icalString;
 };

--- a/calendar/base/src/calRecurrenceDate.js
+++ b/calendar/base/src/calRecurrenceDate.js
@@ -65,26 +65,24 @@ calRecurrenceDate.prototype = {
   getNextOccurrence: function(aStartTime, aOccurrenceTime) {
     if (this.mDate && this.mDate.compare(aStartTime) > 0) {
       return this.mDate;
     } else {
       return null;
     }
   },
 
-  getOccurrences: function(aStartTime, aRangeStart, aRangeEnd, aMaxCount, aCount) {
+  getOccurrences: function(aStartTime, aRangeStart, aRangeEnd, aMaxCount) {
     if (
       this.mDate &&
       this.mDate.compare(aRangeStart) >= 0 &&
       (!aRangeEnd || this.mDate.compare(aRangeEnd) < 0)
     ) {
-      aCount.value = 1;
       return [this.mDate];
     } else {
-      aCount.value = 0;
       return [];
     }
   },
 
   get icalString() {
     let comp = this.icalProperty;
     return comp ? comp.icalString : "";
   },

--- a/calendar/base/src/calRecurrenceInfo.js
+++ b/calendar/base/src/calRecurrenceInfo.js
@@ -291,17 +291,17 @@ calRecurrenceInfo.prototype = {
       // because its very performance hungry and could potentially
       // lead to a deadlock (i.e RRULE is canceled out by an EXRULE).
       // This is ok for now, since EXRULE is deprecated anyway.
       if (ritem.isFinite) {
         // Get all occurrences starting at our recurrence start date.
         // This is fine, since there will never be an EXDATE that
         // occurs before the event started and its illegal to EXDATE an
         // RDATE.
-        let rdates = ritem.getOccurrences(startDate, startDate, null, 0, {});
+        let rdates = ritem.getOccurrences(startDate, startDate, null, 0);
         // Map all negative dates.
         for (let rdate of rdates) {
           negMap[getRidKey(rdate)] = true;
         }
       } else {
         cal.WARN(
           "Item '" +
             this.mBaseItem.title +
@@ -502,17 +502,17 @@ calRecurrenceInfo.prototype = {
     if (rangeStart && rangeEnd) {
       maxCount = 0;
     } else {
       maxCount = aMaxCount;
     }
 
     // Apply positive rules
     for (let ritem of this.mPositiveRules) {
-      let cur_dates = ritem.getOccurrences(startDate, searchStart, rangeEnd, maxCount, {});
+      let cur_dates = ritem.getOccurrences(startDate, searchStart, rangeEnd, maxCount);
       if (cur_dates.length == 0) {
         continue;
       }
 
       // if positive, we just add these date to the existing set,
       // but only if they're not already there
 
       let index = 0;
@@ -540,17 +540,17 @@ calRecurrenceInfo.prototype = {
         // search could be optimized further
         cal.data.binaryInsert(dates, { id: date, rstart: date }, ridDateSortComptor);
         occurrenceMap[dateKey] = true;
       }
     }
 
     // Apply negative rules
     for (let ritem of this.mNegativeRules) {
-      let cur_dates = ritem.getOccurrences(startDate, searchStart, rangeEnd, maxCount, {});
+      let cur_dates = ritem.getOccurrences(startDate, searchStart, rangeEnd, maxCount);
       if (cur_dates.length == 0) {
         continue;
       }
 
       // XXX: i'm pretty sure negative dates can't really have exceptions
       // (like, you can't make a date "real" by defining an RECURRENCE-ID which
       // is an EXDATE, and then giving it a real DTSTART) -- so we don't
       // check exceptions here