Merge branch 'ext-work'

1 files changed, 0 insertions, 549 deletions

diff --git a/toolkit/mozapps/extensions/test/xpcshell/test_DeferredSave.js b/toolkit/mozapps/extensions/test/xpcshell/test_DeferredSave.js
deleted file mode 100644
index 2a6ff291e..000000000
--- a/toolkit/mozapps/extensions/test/xpcshell/test_DeferredSave.js
+++ /dev/null
@@ -1,549 +0,0 @@
-/* Any copyright is dedicated to the Public Domain.
- * http://creativecommons.org/publicdomain/zero/1.0/
- */
-
-// Test behaviour of module to perform deferred save of data
-// files to disk
-
-"use strict";
-
-const testFile = gProfD.clone();
-testFile.append("DeferredSaveTest");
-
-Components.utils.import("resource://gre/modules/Promise.jsm");
-
-var DSContext = Components.utils.import("resource://gre/modules/DeferredSave.jsm", {});
-var DeferredSave = DSContext.DeferredSave;
-
-// Test wrapper to let us do promise/task based testing of DeferredSave
-function DeferredSaveTester(aDataProvider) {
-  let tester = {
-    // Deferred for the promise returned by the mock writeAtomic
-    waDeferred: null,
-
-    // The most recent data "written" by the mock OS.File.writeAtomic
-    writtenData: undefined,
-
-    dataToSave: "Data to save",
-
-    save: (aData, aWriteHandler) => {
-      tester.writeHandler = aWriteHandler || writer;
-      tester.dataToSave = aData;
-      return tester.saver.saveChanges();
-    },
-
-    flush: (aWriteHandler) => {
-      tester.writeHandler = aWriteHandler || writer;
-      return tester.saver.flush();
-    },
-
-    get lastError() {
-      return tester.saver.lastError;
-    }
-  };
-
-  // Default write handler for most cases where the test case doesn't need
-  // to do anything while the write is in progress; just completes the write
-  // on the next event loop
-  function writer(aTester) {
-    do_print("default write callback");
-    let length = aTester.writtenData.length;
-    do_execute_soon(() => aTester.waDeferred.resolve(length));
-  }
-
-  if (!aDataProvider)
-    aDataProvider = () => tester.dataToSave;
-
-  tester.saver = new DeferredSave(testFile.path, aDataProvider);
-
-  // Install a mock for OS.File.writeAtomic to let us control the async
-  // behaviour of the promise
-  DSContext.OS.File.writeAtomic = function mock_writeAtomic(aFile, aData, aOptions) {
-      do_print("writeAtomic: " + aFile + " data: '" + aData + "', " + aOptions.toSource());
-      tester.writtenData = aData;
-      tester.waDeferred = Promise.defer();
-      tester.writeHandler(tester);
-      return tester.waDeferred.promise;
-    };
-
-  return tester;
-}
-
-/**
- * Install a mock nsITimer factory that triggers on the next spin of
- * the event loop after it is scheduled
- */
-function setQuickMockTimer() {
-  let quickTimer = {
-    initWithCallback: function(aFunction, aDelay, aType) {
-      do_print("Starting quick timer, delay = " + aDelay);
-      do_execute_soon(aFunction);
-    },
-    cancel: function() {
-      do_throw("Attempted to cancel a quickMockTimer");
-    }
-  };
-  DSContext.MakeTimer = () => {
-    do_print("Creating quick timer");
-    return quickTimer;
-  };
-}
-
-/**
- * Install a mock nsITimer factory in DeferredSave.jsm, returning a promise that resolves
- * when the client code sets the timer. Test cases can use this to wait for client code to
- * be ready for a timer event, and then signal the event by calling mockTimer.callback().
- * This could use some enhancement; clients can re-use the returned timer,
- * but with this implementation it's not possible for the test to wait for
- * a second call to initWithCallback() on the re-used timer.
- * @return Promise{mockTimer} that resolves when initWithCallback()
- *         is called
- */
-function setPromiseMockTimer() {
-  let waiter = Promise.defer();
-  let mockTimer = {
-    callback: null,
-    delay: null,
-    type: null,
-    isCancelled: false,
-
-    initWithCallback: function(aFunction, aDelay, aType) {
-      do_print("Starting timer, delay = " + aDelay);
-      this.callback = aFunction;
-      this.delay = aDelay;
-      this.type = aType;
-      // cancelled timers can be re-used
-      this.isCancelled = false;
-      waiter.resolve(this);
-    },
-    cancel: function() {
-      do_print("Cancelled mock timer");
-      this.callback = null;
-      this.delay = null;
-      this.type = null;
-      this.isCancelled = true;
-      // If initWithCallback was never called, resolve to let tests check for cancel
-      waiter.resolve(this);
-    }
-  };
-  DSContext.MakeTimer = () => {
-    do_print("Creating mock timer");
-    return mockTimer;
-  };
-  return waiter.promise;
-}
-
-/**
- * Return a Promise<null> that resolves after the specified number of milliseconds
- */
-function delay(aDelayMS) {
-  let deferred = Promise.defer();
-  do_timeout(aDelayMS, () => deferred.resolve(null));
-  return deferred.promise;
-}
-
-function run_test() {
-  run_next_test();
-}
-
-// Modify set data once, ask for save, make sure it saves cleanly
-add_task(function* test_basic_save_succeeds() {
-  setQuickMockTimer();
-  let tester = DeferredSaveTester();
-  let data = "Test 1 Data";
-
-  yield tester.save(data);
-  do_check_eq(tester.writtenData, data);
-  do_check_eq(1, tester.saver.totalSaves);
-});
-
-// Two saves called during the same event loop, both with callbacks
-// Make sure we save only the second version of the data
-add_task(function* test_two_saves() {
-  setQuickMockTimer();
-  let tester = DeferredSaveTester();
-  let firstCallback_happened = false;
-  let firstData = "Test first save";
-  let secondData = "Test second save";
-
-  // first save should not resolve until after the second one is called,
-  // so we can't just yield this promise
-  tester.save(firstData).then(count => {
-    do_check_eq(secondData, tester.writtenData);
-    do_check_false(firstCallback_happened);
-    firstCallback_happened = true;
-  }, do_report_unexpected_exception);
-
-  yield tester.save(secondData);
-  do_check_true(firstCallback_happened);
-  do_check_eq(secondData, tester.writtenData);
-  do_check_eq(1, tester.saver.totalSaves);
-});
-
-// Two saves called with a delay in between, both with callbacks
-// Make sure we save the second version of the data
-add_task(function* test_two_saves_delay() {
-  let timerPromise = setPromiseMockTimer();
-  let tester = DeferredSaveTester();
-  let firstCallback_happened = false;
-  let delayDone = false;
-
-  let firstData = "First data to save with delay";
-  let secondData = "Modified data to save with delay";
-
-  tester.save(firstData).then(count => {
-    do_check_false(firstCallback_happened);
-    do_check_true(delayDone);
-    do_check_eq(secondData, tester.writtenData);
-    firstCallback_happened = true;
-  }, do_report_unexpected_exception);
-
-  // Wait a short time to let async events possibly spawned by the
-  // first tester.save() to run
-  yield delay(2);
-  delayDone = true;
-  // request to save modified data
-  let saving = tester.save(secondData);
-  // Yield to wait for client code to set the timer
-  let activeTimer = yield timerPromise;
-  // and then trigger it
-  activeTimer.callback();
-  // now wait for the DeferredSave to finish saving
-  yield saving;
-  do_check_true(firstCallback_happened);
-  do_check_eq(secondData, tester.writtenData);
-  do_check_eq(1, tester.saver.totalSaves);
-  do_check_eq(0, tester.saver.overlappedSaves);
-});
-
-// Test case where OS.File immediately reports an error when the write begins
-// Also check that the "error" getter correctly returns the error
-// Then do a write that succeeds, and make sure the error is cleared
-add_task(function* test_error_immediate() {
-  let tester = DeferredSaveTester();
-  let testError = new Error("Forced failure");
-  function writeFail(aTester) {
-    aTester.waDeferred.reject(testError);
-  }
-
-  setQuickMockTimer();
-  yield tester.save("test_error_immediate", writeFail).then(
-    count => do_throw("Did not get expected error"),
-    error => do_check_eq(testError.message, error.message)
-    );
-  do_check_eq(testError, tester.lastError);
-
-  // This write should succeed and clear the error
-  yield tester.save("test_error_immediate succeeds");
-  do_check_eq(null, tester.lastError);
-  // The failed save attempt counts in our total
-  do_check_eq(2, tester.saver.totalSaves);
-});
-
-// Save one set of changes, then while the write is in progress, modify the
-// data two more times. Test that we re-write the dirty data exactly once
-// after the first write succeeds
-add_task(function* dirty_while_writing() {
-  let tester = DeferredSaveTester();
-  let firstData = "First data";
-  let secondData = "Second data";
-  let thirdData = "Third data";
-  let firstCallback_happened = false;
-  let secondCallback_happened = false;
-  let writeStarted = Promise.defer();
-
-  function writeCallback(aTester) {
-    writeStarted.resolve(aTester.waDeferred);
-  }
-
-  setQuickMockTimer();
-  do_print("First save");
-  tester.save(firstData, writeCallback).then(
-    count => {
-      do_check_false(firstCallback_happened);
-      do_check_false(secondCallback_happened);
-      do_check_eq(tester.writtenData, firstData);
-      firstCallback_happened = true;
-    }, do_report_unexpected_exception);
-
-  do_print("waiting for writer");
-  let writer = yield writeStarted.promise;
-  do_print("Write started");
-
-  // Delay a bit, modify the data and call saveChanges, delay a bit more,
-  // modify the data and call saveChanges again, another delay,
-  // then complete the in-progress write
-  yield delay(1);
-
-  tester.save(secondData).then(
-    count => {
-      do_check_true(firstCallback_happened);
-      do_check_false(secondCallback_happened);
-      do_check_eq(tester.writtenData, thirdData);
-      secondCallback_happened = true;
-    }, do_report_unexpected_exception);
-
-  // wait and then do the third change
-  yield delay(1);
-  let thirdWrite = tester.save(thirdData);
-
-  // wait a bit more and then finally finish the first write
-  yield delay(1);
-  writer.resolve(firstData.length);
-
-  // Now let everything else finish
-  yield thirdWrite;
-  do_check_true(firstCallback_happened);
-  do_check_true(secondCallback_happened);
-  do_check_eq(tester.writtenData, thirdData);
-  do_check_eq(2, tester.saver.totalSaves);
-  do_check_eq(1, tester.saver.overlappedSaves);
-});
-
-// A write callback for the OS.File.writeAtomic mock that rejects write attempts
-function disabled_write_callback(aTester) {
-  do_throw("Should not have written during clean flush");
-}
-
-// special write callback that disables itself to make sure
-// we don't try to write twice
-function write_then_disable(aTester) {
-  do_print("write_then_disable");
-  let length = aTester.writtenData.length;
-  aTester.writeHandler = disabled_write_callback;
-  do_execute_soon(() => aTester.waDeferred.resolve(length));
-}
-
-// Flush tests. First, do an ordinary clean save and then call flush;
-// there should not be another save
-add_task(function* flush_after_save() {
-  setQuickMockTimer();
-  let tester = DeferredSaveTester();
-  let dataToSave = "Flush after save";
-
-  yield tester.save(dataToSave);
-  yield tester.flush(disabled_write_callback);
-  do_check_eq(1, tester.saver.totalSaves);
-});
-
-// Flush while a write is in progress, but the in-memory data is clean
-add_task(function* flush_during_write() {
-  let tester = DeferredSaveTester();
-  let dataToSave = "Flush during write";
-  let firstCallback_happened = false;
-  let writeStarted = Promise.defer();
-
-  function writeCallback(aTester) {
-    writeStarted.resolve(aTester.waDeferred);
-  }
-
-  setQuickMockTimer();
-  tester.save(dataToSave, writeCallback).then(
-    count => {
-      do_check_false(firstCallback_happened);
-      firstCallback_happened = true;
-    }, do_report_unexpected_exception);
-
-  let writer = yield writeStarted.promise;
-
-  // call flush with the write callback disabled, delay a bit more, complete in-progress write
-  let flushing = tester.flush(disabled_write_callback);
-  yield delay(2);
-  writer.resolve(dataToSave.length);
-
-  // now wait for the flush to finish
-  yield flushing;
-  do_check_true(firstCallback_happened);
-  do_check_eq(1, tester.saver.totalSaves);
-});
-
-// Flush while dirty but write not in progress
-// The data written should be the value at the time
-// flush() is called, even if it is changed later
-add_task(function* flush_while_dirty() {
-  let timerPromise = setPromiseMockTimer();
-  let tester = DeferredSaveTester();
-  let firstData = "Flush while dirty, valid data";
-  let firstCallback_happened = false;
-
-  tester.save(firstData, write_then_disable).then(
-    count => {
-      do_check_false(firstCallback_happened);
-      firstCallback_happened = true;
-      do_check_eq(tester.writtenData, firstData);
-    }, do_report_unexpected_exception);
-
-  // Wait for the timer to be set, but don't trigger it so the write won't start
-  let activeTimer = yield timerPromise;
-
-  let flushing = tester.flush();
-
-  // Make sure the timer was cancelled
-  do_check_true(activeTimer.isCancelled);
-
-  // Also make sure that data changed after the flush call
-  // (even without a saveChanges() call) doesn't get written
-  tester.dataToSave = "Flush while dirty, invalid data";
-
-  yield flushing;
-  do_check_true(firstCallback_happened);
-  do_check_eq(tester.writtenData, firstData);
-  do_check_eq(1, tester.saver.totalSaves);
-});
-
-// And the grand finale - modify the data, start writing,
-// modify the data again so we're in progress and dirty,
-// then flush, then modify the data again
-// Data for the second write should be taken at the time
-// flush() is called, even if it is modified later
-add_task(function* flush_writing_dirty() {
-  let timerPromise = setPromiseMockTimer();
-  let tester = DeferredSaveTester();
-  let firstData = "Flush first pass data";
-  let secondData = "Flush second pass data";
-  let firstCallback_happened = false;
-  let secondCallback_happened = false;
-  let writeStarted = Promise.defer();
-
-  function writeCallback(aTester) {
-    writeStarted.resolve(aTester.waDeferred);
-  }
-
-  tester.save(firstData, writeCallback).then(
-    count => {
-      do_check_false(firstCallback_happened);
-      do_check_eq(tester.writtenData, firstData);
-      firstCallback_happened = true;
-    }, do_report_unexpected_exception);
-
-  // Trigger the timer callback as soon as the DeferredSave sets it
-  let activeTimer = yield timerPromise;
-  activeTimer.callback();
-  let writer = yield writeStarted.promise;
-  // the first write has started
-
-  // dirty the data and request another save
-  // after the second save completes, there should not be another write
-  tester.save(secondData, write_then_disable).then(
-    count => {
-      do_check_true(firstCallback_happened);
-      do_check_false(secondCallback_happened);
-      do_check_eq(tester.writtenData, secondData);
-      secondCallback_happened = true;
-    }, do_report_unexpected_exception);
-
-  let flushing = tester.flush(write_then_disable);
-  // Flush should have cancelled our timer
-  do_check_true(activeTimer.isCancelled);
-  tester.dataToSave = "Flush, invalid data: changed late";
-  // complete the first write
-  writer.resolve(firstData.length);
-  // now wait for the second write / flush to complete
-  yield flushing;
-  do_check_true(firstCallback_happened);
-  do_check_true(secondCallback_happened);
-  do_check_eq(tester.writtenData, secondData);
-  do_check_eq(2, tester.saver.totalSaves);
-  do_check_eq(1, tester.saver.overlappedSaves);
-});
-
-// A data provider callback that throws an error the first
-// time it is called, and a different error the second time
-// so that tests can (a) make sure the promise is rejected
-// with the error and (b) make sure the provider is only
-// called once in case of error
-const expectedDataError = "Failed to serialize data";
-var badDataError = null;
-function badDataProvider() {
-  let err = new Error(badDataError);
-  badDataError = "badDataProvider called twice";
-  throw err;
-}
-
-// Handle cases where data provider throws
-// First, throws during a normal save
-add_task(function* data_throw() {
-  setQuickMockTimer();
-  badDataError = expectedDataError;
-  let tester = DeferredSaveTester(badDataProvider);
-  yield tester.save("data_throw").then(
-    count => do_throw("Expected serialization failure"),
-    error => do_check_eq(error.message, expectedDataError));
-});
-
-// Now, throws during flush
-add_task(function* data_throw_during_flush() {
-  badDataError = expectedDataError;
-  let tester = DeferredSaveTester(badDataProvider);
-  let firstCallback_happened = false;
-
-  setPromiseMockTimer();
-  // Write callback should never be called
-  tester.save("data_throw_during_flush", disabled_write_callback).then(
-    count => do_throw("Expected serialization failure"),
-    error => {
-      do_check_false(firstCallback_happened);
-      do_check_eq(error.message, expectedDataError);
-      firstCallback_happened = true;
-    });
-
-  // flush() will cancel the timer
-  yield tester.flush(disabled_write_callback).then(
-    count => do_throw("Expected serialization failure"),
-    error => do_check_eq(error.message, expectedDataError)
-    );
-
-  do_check_true(firstCallback_happened);
-});
-
-// Try to reproduce race condition. The observed sequence of events:
-// saveChanges
-// start writing
-// saveChanges
-// finish writing (need to restart delayed timer)
-// saveChanges
-// flush
-// write starts
-// actually restart timer for delayed write
-// write completes
-// delayed timer goes off, throws error because DeferredSave has been torn down
-add_task(function* delay_flush_race() {
-  let timerPromise = setPromiseMockTimer();
-  let tester = DeferredSaveTester();
-  let firstData = "First save";
-  let secondData = "Second save";
-  let thirdData = "Third save";
-  let writeStarted = Promise.defer();
-
-  function writeCallback(aTester) {
-    writeStarted.resolve(aTester.waDeferred);
-  }
-
-  // This promise won't resolve until after writeStarted
-  let firstSave = tester.save(firstData, writeCallback);
-  (yield timerPromise).callback();
-
-  let writer = yield writeStarted.promise;
-  // the first write has started
-
-  // dirty the data and request another save
-  let secondSave = tester.save(secondData);
-
-  // complete the first write
-  writer.resolve(firstData.length);
-  yield firstSave;
-  do_check_eq(tester.writtenData, firstData);
-
-  tester.save(thirdData);
-  let flushing = tester.flush();
-
-  yield secondSave;
-  do_check_eq(tester.writtenData, thirdData);
-
-  yield flushing;
-  do_check_eq(tester.writtenData, thirdData);
-
-  // Our DeferredSave should not have a _timer here; if it
-  // does, the bug caused a reschedule
-  do_check_eq(null, tester.saver._timer);
-});