Add m-esr52 at 52.6.0

1 files changed, 245 insertions, 0 deletions

diff --git a/toolkit/components/formautofill/test/head_common.js b/toolkit/components/formautofill/test/head_common.js
new file mode 100644
index 000000000..82b87e4a6
--- /dev/null
+++ b/toolkit/components/formautofill/test/head_common.js
@@ -0,0 +1,245 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/*
+ * Initialization of Form Autofill tests shared between all frameworks.
+ *
+ * A copy of this file is installed in each of the framework subfolders, this
+ * means it becomes a sibling of the test files in the final layout.  This is
+ * determined by how manifest "support-files" installation works.
+ */
+
+"use strict";
+
+// The requestAutocomplete framework is available at this point, you can add
+// mochitest-chrome specific test initialization here.  If you need shared
+// functions or initialization that are not specific to mochitest-chrome,
+// consider adding them to "head_common.js" in the parent folder instead.
+
+XPCOMUtils.defineLazyModuleGetter(this, "DownloadPaths",
+                                  "resource://gre/modules/DownloadPaths.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+                                  "resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FormAutofill",
+                                  "resource://gre/modules/FormAutofill.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+                                  "resource://gre/modules/osfile.jsm");
+
+/* --- Global helpers --- */
+
+// Some of these functions are already implemented in other parts of the source
+// tree, see bug 946708 about sharing more code.
+
+var TestUtils = {
+  /**
+   * Waits for at least one tick of the event loop.  This means that all pending
+   * events at the time of this call will have been processed.  Other events may
+   * be processed before the returned promise is resolved.
+   *
+   * @return {Promise}
+   * @resolves When pending events have been processed.
+   * @rejects Never.
+   */
+  waitForTick: function () {
+    return new Promise(resolve => executeSoon(resolve));
+  },
+
+  /**
+   * Waits for the specified timeout.
+   *
+   * @param aTimeMs
+   *        Minimum time to wait from the moment of this call, in milliseconds.
+   *        The actual wait may be longer, due to system timer resolution and
+   *        pending events being processed before the promise is resolved.
+   *
+   * @return {Promise}
+   * @resolves When the specified time has passed.
+   * @rejects Never.
+   */
+  waitMs: function (aTimeMs) {
+    return new Promise(resolve => setTimeout(resolve, aTimeMs));
+  },
+
+  /**
+   * Allows waiting for an observer notification once.
+   *
+   * @param aTopic
+   *        Notification topic to observe.
+   *
+   * @return {Promise}
+   * @resolves The array [aSubject, aData] from the observed notification.
+   * @rejects Never.
+   */
+  waitForNotification: function (aTopic) {
+    Output.print("Waiting for notification: '" + aTopic + "'.");
+
+    return new Promise(resolve => Services.obs.addObserver(
+      function observe(aSubject, aTopic, aData) {
+        Services.obs.removeObserver(observe, aTopic);
+        resolve([aSubject, aData]);
+      }, aTopic, false));
+  },
+
+  /**
+   * Waits for a DOM event on the specified target.
+   *
+   * @param aTarget
+   *        The DOM EventTarget on which addEventListener should be called.
+   * @param aEventName
+   *        String with the name of the event.
+   * @param aUseCapture
+   *        This parameter is passed to the addEventListener call.
+   *
+   * @return {Promise}
+   * @resolves The arguments from the observed event.
+   * @rejects Never.
+   */
+  waitForEvent: function (aTarget, aEventName, aUseCapture = false) {
+    Output.print("Waiting for event: '" + aEventName + "' on " + aTarget + ".");
+
+    return new Promise(resolve => aTarget.addEventListener(aEventName,
+      function onEvent(...aArgs) {
+        aTarget.removeEventListener(aEventName, onEvent, aUseCapture);
+        resolve(...aArgs);
+      }, aUseCapture));
+  },
+
+  // While the previous test file should have deleted all the temporary files it
+  // used, on Windows these might still be pending deletion on the physical file
+  // system.  Thus, start from a new base number every time, to make a collision
+  // with a file that is still pending deletion highly unlikely.
+  _fileCounter: Math.floor(Math.random() * 1000000),
+
+  /**
+   * Returns a reference to a temporary file, that is guaranteed not to exist,
+   * and to have never been created before.
+   *
+   * @param aLeafName
+   *        Suggested leaf name for the file to be created.
+   *
+   * @return {Promise}
+   * @resolves Path of a non-existent file in a temporary directory.
+   *
+   * @note It is not enough to delete the file if it exists, or to delete the
+   *       file after calling nsIFile.createUnique, because on Windows the
+   *       delete operation in the file system may still be pending, preventing
+   *       a new file with the same name to be created.
+   */
+  getTempFile: Task.async(function* (aLeafName) {
+    // Prepend a serial number to the extension in the suggested leaf name.
+    let [base, ext] = DownloadPaths.splitBaseNameAndExtension(aLeafName);
+    let leafName = base + "-" + this._fileCounter + ext;
+    this._fileCounter++;
+
+    // Get a file reference under the temporary directory for this test file.
+    let path = OS.Path.join(OS.Constants.Path.tmpDir, leafName);
+    Assert.ok(!(yield OS.File.exists(path)));
+
+    // Ensure the file is deleted whe the test terminates.
+    add_termination_task(function* () {
+      if (yield OS.File.exists(path)) {
+        yield OS.File.remove(path);
+      }
+    });
+
+    return path;
+  }),
+};
+
+/* --- Local helpers --- */
+
+var FormAutofillTest = {
+  /**
+   * Stores the response that the next call to the mock requestAutocomplete UI
+   * will return to the requester, or null to enable displaying the default UI.
+   */
+  requestAutocompleteResponse: null,
+
+  /**
+   * Displays the requestAutocomplete user interface using the specified data.
+   *
+   * @param aFormAutofillData
+   *        Serializable object containing the set of requested fields.
+   *
+   * @return {Promise}
+   * @resolves An object with the following properties:
+   *           {
+   *             uiWindow: Reference to the initialized window.
+   *             promiseResult: Promise resolved by the UI when it closes.
+   *           }
+   */
+  showUI: Task.async(function* (aFormAutofillData) {
+    Output.print("Opening UI with data: " + JSON.stringify(aFormAutofillData));
+
+    // Wait for the initialization event before opening the window.
+    let promiseUIWindow =
+        TestUtils.waitForNotification("formautofill-window-initialized");
+    let ui = yield FormAutofill.integration.createRequestAutocompleteUI(
+                                                         aFormAutofillData);
+    let promiseResult = ui.show();
+
+    // The window is the subject of the observer notification.
+    return {
+      uiWindow: (yield promiseUIWindow)[0],
+      promiseResult: promiseResult,
+    };
+  }),
+};
+
+var TestData = {
+  /**
+   * Autofill UI request for the e-mail field only.
+   */
+  get requestEmailOnly() {
+    return {
+      sections: [{
+        name: "",
+        addressSections: [{
+          addressType: "",
+          fields: [{
+            fieldName: "email",
+            contactType: "",
+          }],
+        }],
+      }],
+    };
+  },
+};
+
+/* --- Initialization and termination functions common to all tests --- */
+
+add_task_in_parent_process(function* () {
+  // If required, we return a mock response instead of displaying the UI.
+  let mockIntegrationFn = base => ({
+    createRequestAutocompleteUI: Task.async(function* () {
+      // Call the base method to display the UI if override is not requested.
+      if (FormAutofillTest.requestAutocompleteResponse === null) {
+        return yield base.createRequestAutocompleteUI.apply(this, arguments);
+      }
+
+      // Return a mock RequestAutocompleteUI object.
+      return {
+        show: Task.async(function* () {
+          let response = FormAutofillTest.requestAutocompleteResponse;
+          Output.print("Mock UI response: " + JSON.stringify(response));
+          return response;
+        }),
+      };
+    }),
+  });
+
+  FormAutofill.registerIntegration(mockIntegrationFn);
+  add_termination_task(function* () {
+    FormAutofill.unregisterIntegration(mockIntegrationFn);
+  });
+});
+
+add_task_in_both_processes(function* () {
+  // We must manually enable the feature while testing.
+  Services.prefs.setBoolPref("dom.forms.requestAutocomplete", true);
+  add_termination_task(function* () {
+    Services.prefs.clearUserPref("dom.forms.requestAutocomplete");
+  });
+});