Bug 1253233 - Refactor findbar_window.xul to run the test on remote browsers as well. r=felipe

toolkit/content/tests/chrome/findbar_window.xul

@@ -5,6 +5,9 @@
    - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
 
 <?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet
+  href="chrome://mochikit/content/tests/SimpleTest/test.css"
+  type="text/css"?>
 
 <window id="FindbarTest"
         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
@@ -19,12 +22,10 @@
           src="chrome://mochikit/content/tests/SimpleTest/ChromeUtils.js"/>
 
   <script type="application/javascript"><![CDATA[
-    const Ci = Components.interfaces;
-    const Cc = Components.classes;
-    const Cr = Components.results;
-    const Cu = Components.utils;
-    const { Task } = Cu.import("resource://gre/modules/Task.jsm", {});
-    var { Promise } = Cu.import("resource://gre/modules/Promise.jsm", {});
+    const {interfaces: Ci, classes: Cc, results: Cr, utils: Cu} = Components;
+    Cu.import("resource://gre/modules/Task.jsm");
+    Cu.import("resource://testing-common/ContentTask.jsm");
+    ContentTask.setTestScope(window.opener.wrappedJSObject);
 
     const SAMPLE_URL = "http://www.mozilla.org/";
     const SAMPLE_TEXT = "Some text in a text field.";
@@ -56,60 +57,80 @@
       onBeforeLinkTraversal: function() { }
     };
 
-    function ok(condition, message) {
-      window.opener.wrappedJSObject.SimpleTest.ok(condition, message);
-    }
-    function is(a, b, message) {
-      window.opener.wrappedJSObject.SimpleTest.is(a, b, message);
-    }
-    function finish() {
-      window.close();
-      window.opener.wrappedJSObject.SimpleTest.finish();
+    var imports = ["SimpleTest", "ok", "is", "info"];
+    for (var name of imports) {
+      window[name] = window.opener.wrappedJSObject[name];
     }
 
     function onLoad() {
-      window.QueryInterface(Ci.nsIInterfaceRequestor)
-            .getInterface(Ci.nsIWebNavigation)
-            .QueryInterface(Ci.nsIDocShellTreeItem)
-            .treeOwner
-            .QueryInterface(Ci.nsIInterfaceRequestor)
-            .getInterface(Ci.nsIXULWindow)
-            .XULBrowserWindow = gXULBrowserWindow;
+      Task.spawn(function* () {
+        window.QueryInterface(Ci.nsIInterfaceRequestor)
+              .getInterface(Ci.nsIWebNavigation)
+              .QueryInterface(Ci.nsIDocShellTreeItem)
+              .treeOwner
+              .QueryInterface(Ci.nsIInterfaceRequestor)
+              .getInterface(Ci.nsIXULWindow)
+              .XULBrowserWindow = gXULBrowserWindow;
 
-      var _delayedOnLoad = function() {
         gFindBar = document.getElementById("FindToolbar");
-        gBrowser = document.getElementById("content");
-        gBrowser.addEventListener("pageshow", _delayedOnPageShow, false);
-        gBrowser.loadURI("data:text/html,<h2 id='h2'>" + SEARCH_TEXT + "</h2><h2><a href='" + SAMPLE_URL + "'>Link Test</a></h2><input id='text' type='text' value='" + SAMPLE_TEXT + "'></input><input id='button' type='button'></input><img id='img' width='50' height='50'/>");
-      }
-      setTimeout(_delayedOnLoad, 1000);
+        for (let browserId of ["content", "content-remote"]) {
+          yield startTestWithBrowser(browserId);
+        }
+      }).then(() => {
+        window.close();
+        SimpleTest.finish();
+      });
     }
 
-    function _delayedOnPageShow() {
-      // setTimeout to the test runs after painting suppression ends
-      setTimeout(onPageShow, 0);
+    function* startTestWithBrowser(browserId) {
+      info("Starting test with browser '" + browserId + "'");
+      gBrowser = document.getElementById(browserId);
+      gFindBar.browser = gBrowser;
+
+      // Tests delays the loading of a document for one second.
+      yield new Promise(resolve => setTimeout(resolve, 1000));
+
+      let promise = ContentTask.spawn(gBrowser, null, function* () {
+        return new Promise(resolve => {
+          addEventListener("DOMContentLoaded", function listener() {
+            removeEventListener("DOMContentLoaded", listener);
+            resolve();
+          });
+        });
+      });
+      gBrowser.loadURI("data:text/html,<h2 id='h2'>" + SEARCH_TEXT +
+        "</h2><h2><a href='" + SAMPLE_URL + "'>Link Test</a></h2><input id='text' type='text' value='" +
+        SAMPLE_TEXT + "'></input><input id='button' type='button'></input><img id='img' width='50' height='50'/>");
+      yield promise;
+      yield onDocumentLoaded();
     }
 
-    let onPageShow = Task.async(function* () {
-      testNormalFind();
+    function* onDocumentLoaded() {
+      yield testNormalFind();
       gFindBar.close();
       ok(gFindBar.hidden, "Failed to close findbar after testNormalFind");
       yield openFindbar();
-      testNormalFindWithComposition();
+      yield testNormalFindWithComposition();
       gFindBar.close();
       ok(gFindBar.hidden, "findbar should be hidden after testNormalFindWithComposition");
       yield openFindbar();
-      testAutoCaseSensitivityUI();
-      testQuickFindText();
+      yield testAutoCaseSensitivityUI();
+      yield testQuickFindText();
       gFindBar.close();
       ok(gFindBar.hidden, "Failed to close findbar after testQuickFindText");
-      testFindWithHighlight();
-      gFindBar.close();
-      ok(gFindBar.hidden, "Failed to close findbar after testFindWithHighlight");
-      yield Task.spawn(testFindbarSelection);
+      // TODO: `testFindWithHighlight` tests fastFind integrity, which can not
+      //       be accessed with RemoteFinder. We're skipping it for now.
+      if (gFindBar._browser.finder._fastFind) {
+        yield testFindWithHighlight();
+        gFindBar.close();
+        ok(gFindBar.hidden, "Failed to close findbar after testFindWithHighlight");
+      }
+      yield testFindbarSelection();
       ok(gFindBar.hidden, "Failed to close findbar after testFindbarSelection");
-      testDrop();
-      testQuickFindLink();
+      // TODO: I don't know how to drop a content element on a chrome input.
+      if (!gBrowser.hasAttribute("remote"))
+        testDrop();
+      yield testQuickFindLink();
       if (gHasFindClipboard) {
         yield testStatusText();
       }
@@ -123,9 +144,11 @@
       yield testFailedStringReset();
       gFindBar.close();
       yield testQuickFindClose();
-      yield Task.spawn(testFindAgainNotFound);
-      finish();
-    });
+      // TODO: This doesn't seem to work when the findbar is connected to a
+      //       remote browser element.
+      if (!gBrowser.hasAttribute("remote"))
+        yield testFindAgainNotFound();
+    }
 
     function* testFindbarSelection() {
       function checkFindbarState(aTestName, aExpSelection) {
@@ -138,37 +161,43 @@
              ". Selection: " + gFindBar._findField.value);
         }
 
-        // Clear the value, close the findbar
+        // Clear the value, close the findbar.
         gFindBar._findField.value = "";
         gFindBar.close();
       }
 
-      // test normal selected text
-      var cH2 = gBrowser.contentDocument.getElementById("h2");
-      var cSelection = gBrowser.contentDocument.defaultView.getSelection();
-      var cRange = gBrowser.contentDocument.createRange();
-      cRange.setStart(cH2, 0);
-      cRange.setEnd(cH2, 1);
-      cSelection.removeAllRanges();
-      cSelection.addRange(cRange);
+      // Test normal selected text.
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        let document = content.document;
+        let cH2 = document.getElementById("h2");
+        let cSelection = content.getSelection();
+        let cRange = document.createRange();
+        cRange.setStart(cH2, 0);
+        cRange.setEnd(cH2, 1);
+        cSelection.removeAllRanges();
+        cSelection.addRange(cRange);
+      });
       yield openFindbar();
       checkFindbarState("plain text", SEARCH_TEXT);
 
-      // test nsIDOMNSEditableElement with selection
-      var textInput = gBrowser.contentDocument.getElementById("text");
-      textInput.focus();
-      textInput.select();
+      // Test nsIDOMNSEditableElement with selection.
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        let textInput = content.document.getElementById("text");
+        textInput.focus();
+        textInput.select();
+      });
       yield openFindbar();
       checkFindbarState("text input", SAMPLE_TEXT);
 
-      // test non-editable nsIDOMNSEditableElement (button)
-      gBrowser.contentDocument.getElementById("button").focus();
+      // Test non-editable nsIDOMNSEditableElement (button).
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        content.document.getElementById("button").focus();
+      });
       yield openFindbar();
       checkFindbarState("button", "");
     }
 
-    function testDrop()
-    {
+    function testDrop() {
       gFindBar.open();
       // use an dummy image to start the drag so it doesn't get interrupted by a selection
       var img = gBrowser.contentDocument.getElementById("img");
@@ -178,60 +207,105 @@
     }
 
     function testQuickFindClose() {
-      let deferred = Promise.defer();
-      var _isClosedCallback = function() {
-        ok(gFindBar.hidden,
-           "_isClosedCallback: Failed to auto-close quick find bar after " +
-           gFindBar._quickFindTimeoutLength + "ms");
-        deferred.resolve();
-      };
-      setTimeout(_isClosedCallback, gFindBar._quickFindTimeoutLength + 100);
-      return deferred.promise;
+      return new Promise(resolve => {
+        var _isClosedCallback = function() {
+          ok(gFindBar.hidden,
+             "_isClosedCallback: Failed to auto-close quick find bar after " +
+             gFindBar._quickFindTimeoutLength + "ms");
+          resolve();
+        };
+        setTimeout(_isClosedCallback, gFindBar._quickFindTimeoutLength + 100);
+      });
     }
 
     function testStatusText() {
-      let deferred = Promise.defer();
-      var _delayedCheckStatusText = function() {
-        ok(gStatusText == SAMPLE_URL, "testStatusText: Failed to set status text of found link");
-        deferred.resolve();
-      };
-      setTimeout(_delayedCheckStatusText, 100);
-      return deferred.promise;
+      return new Promise(resolve => {
+        var _delayedCheckStatusText = function() {
+          ok(gStatusText == SAMPLE_URL, "testStatusText: Failed to set status text of found link");
+          resolve();
+        };
+        setTimeout(_delayedCheckStatusText, 100);
+      });
     }
 
-    function enterStringIntoFindField(aString) {
-      for (var i=0; i < aString.length; i++) {
-        var event = document.createEvent("KeyEvents");
-        event.initKeyEvent("keypress", true, true, null, false, false,
-                           false, false, 0, aString.charCodeAt(i));
-        gFindBar._findField.inputField.dispatchEvent(event);
-      }
+    function promiseFindResult() {
+      return new Promise(resolve => {
+        let listener = {
+          onFindResult: function() {
+            gFindBar.browser.finder.removeResultListener(listener);
+            resolve();
+          }
+        };
+        gFindBar.browser.finder.addResultListener(listener);
+      });
     }
 
+    function promiseMatchesCountResult() {
+      return new Promise(resolve => {
+        let listener = {
+          onMatchesCountResult: function() {
+            gFindBar.browser.finder.removeResultListener(listener);
+            resolve();
+          }
+        };
+        gFindBar.browser.finder.addResultListener(listener);
+      });
+    }
+
+    var enterStringIntoFindField = Task.async(function* (str, waitForResult = true) {
+      for (let promise, i = 0; i < str.length; i++) {
+        if (waitForResult) {
+          promise = promiseFindResult();
+        }
+        let event = document.createEvent("KeyEvents");
+        event.initKeyEvent("keypress", true, true, null, false, false,
+                           false, false, 0, str.charCodeAt(i));
+        gFindBar._findField.inputField.dispatchEvent(event);
+        if (waitForResult) {
+          yield promise;
+        }
+      }
+    });
+
     // also test match-case
-    function testNormalFind() {
+    function* testNormalFind() {
       document.getElementById("cmd_find").doCommand();
 
       ok(!gFindBar.hidden, "testNormalFind: failed to open findbar");
       ok(document.commandDispatcher.focusedElement == gFindBar._findField.inputField,
          "testNormalFind: find field is not focused");
 
-      var matchCaseCheckbox = gFindBar.getElement("find-case-sensitive");
-      if (!matchCaseCheckbox.hidden & matchCaseCheckbox.checked)
+      let promise;
+      let matchCaseCheckbox = gFindBar.getElement("find-case-sensitive");
+      if (!matchCaseCheckbox.hidden && matchCaseCheckbox.checked) {
+        promise = promiseFindResult();
         matchCaseCheckbox.click();
+        yield promise;
+      }
 
       var searchStr = "text tes";
-      enterStringIntoFindField(searchStr);
-      ok(gBrowser.contentWindow.getSelection().toString().toLowerCase() == searchStr,
-         "testNormalFind: failed to find '" + searchStr + "'");
-      testClipboardSearchString(gBrowser.contentWindow.getSelection().toString());
+      yield enterStringIntoFindField(searchStr);
+
+      let sel = yield ContentTask.spawn(gBrowser, { searchStr }, function* (args) {
+        let sel = content.getSelection().toString();
+        Assert.equal(sel.toLowerCase(), args.searchStr,
+          "testNormalFind: failed to find '" + args.searchStr + "'");
+        return sel;
+      });
+      testClipboardSearchString(sel);
 
       if (!matchCaseCheckbox.hidden) {
+        promise = promiseFindResult();
         matchCaseCheckbox.click();
+        yield promise;
         enterStringIntoFindField("t");
-        ok(gBrowser.contentWindow.getSelection() != searchStr,
-           "testNormalFind: Case-sensitivy is broken '" + searchStr + "'");
+        yield ContentTask.spawn(gBrowser, { searchStr }, function* (args) {
+          Assert.notEqual(content.getSelection().toString(), args.searchStr,
+            "testNormalFind: Case-sensitivy is broken '" + args.searchStr + "'");
+        });
+        promise = promiseFindResult();
         matchCaseCheckbox.click();
+        yield promise;
       }
     }
 
@@ -240,7 +314,7 @@
       return gFindBar._startFindDeferred.promise;
     }
 
-    function testNormalFindWithComposition() {
+    function* testNormalFindWithComposition() {
       ok(!gFindBar.hidden, "testNormalFindWithComposition: findbar should be open");
       ok(document.commandDispatcher.focusedElement == gFindBar._findField.inputField,
          "testNormalFindWithComposition: find field should be focused");
@@ -267,21 +341,27 @@
           "caret": { "start": searchStr.length, "length": 0 }
         });
 
-      ok(gBrowser.contentWindow.getSelection().toString().toLowerCase() != searchStr,
-         "testNormalFindWithComposition: text shouldn't be found during composition");
+      yield ContentTask.spawn(gBrowser, { searchStr }, function* (args) {
+        Assert.notEqual(content.getSelection().toString().toLowerCase(), args.searchStr,
+          "testNormalFindWithComposition: text shouldn't be found during composition");
+      });
 
       synthesizeComposition({ type: "compositioncommitasis" });
 
-      is(gBrowser.contentWindow.getSelection().toString().toLowerCase(), searchStr,
-         "testNormalFindWithComposition: text should be found after committing composition");
-      testClipboardSearchString(gBrowser.contentWindow.getSelection().toString());
+      let sel = yield ContentTask.spawn(gBrowser, { searchStr }, function* (args) {
+        let sel = content.getSelection().toString();
+        Assert.equal(sel.toLowerCase(), args.searchStr,
+          "testNormalFindWithComposition: text should be found after committing composition");
+        return sel;
+      });
+      testClipboardSearchString(sel);
 
       if (clicked) {
         matchCaseCheckbox.click();
       }
     }
 
-    function testAutoCaseSensitivityUI() {
+    function* testAutoCaseSensitivityUI() {
       var matchCaseCheckbox = gFindBar.getElement("find-case-sensitive");
       var matchCaseLabel = gFindBar.getElement("match-case-status");
       ok(!matchCaseCheckbox.hidden, "match case box is hidden in manual mode");
@@ -296,9 +376,9 @@
       ok(!matchCaseLabel.hidden,
          "match case label is hidden in automatic mode");
 
-      enterStringIntoFindField("a");
+      yield enterStringIntoFindField("a");
       var insensitiveLabel = matchCaseLabel.value;
-      enterStringIntoFindField("A");
+      yield enterStringIntoFindField("A");
       var sensitiveLabel = matchCaseLabel.value;
       ok(insensitiveLabel != sensitiveLabel,
          "Case Sensitive label was not correctly updated");
@@ -311,34 +391,41 @@
       gFindBar.close();
     }
 
-    function clearFocus() {
+    function* clearFocus() {
       document.commandDispatcher.focusedElement = null;
       document.commandDispatcher.focusedWindow = null;
-      gBrowser.contentWindow.focus();
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        content.focus();
+      });
     }
 
-    function testQuickFindLink() {
-      clearFocus();
+    function* testQuickFindLink() {
+      yield clearFocus();
 
-      var event = document.createEvent("KeyEvents");
-      event.initKeyEvent("keypress", true, true, null, false, false,
-                         false, false, 0, "'".charCodeAt(0));
-      gBrowser.contentDocument.documentElement.dispatchEvent(event);
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        let document = content.document;
+        let event = document.createEvent("KeyEvents");
+        event.initKeyEvent("keypress", true, true, null, false, false,
+                           false, false, 0, "'".charCodeAt(0));
+        document.documentElement.dispatchEvent(event);
+      });
 
       ok(!gFindBar.hidden, "testQuickFindLink: failed to open findbar");
       ok(document.commandDispatcher.focusedElement == gFindBar._findField.inputField,
          "testQuickFindLink: find field is not focused");
 
       var searchStr = "Link Test";
-      enterStringIntoFindField(searchStr);
-      ok(gBrowser.contentWindow.getSelection() == searchStr,
+      yield enterStringIntoFindField(searchStr);
+      yield ContentTask.spawn(gBrowser, { searchStr }, function* (args) {
+        Assert.equal(content.getSelection().toString(), args.searchStr,
           "testQuickFindLink: failed to find sample link");
+      });
       testClipboardSearchString(searchStr);
     }
 
     // See bug 963925 for more details on this test.
-    function testFindWithHighlight() {
-      //clearFocus();
+    function* testFindWithHighlight() {
+      //yield clearFocus();
       gFindBar._findField.value = "";
 
       // For this test, we want to closely control the selection. The easiest
@@ -356,7 +443,7 @@
       gFindBar.onCurrentSelection("", true);
 
       searchStr = "e";
-      enterStringIntoFindField(searchStr);
+      yield enterStringIntoFindField(searchStr);
 
       let a = gFindBar._findField.value;
       let b = gFindBar._browser.finder._fastFind.searchString;
@@ -394,37 +481,45 @@
       ok(!highlightButton.checked, "testFindWithHighlight: Highlight All should be unchecked.");
     }
 
-    function testQuickFindText() {
-      clearFocus();
+    function* testQuickFindText() {
+      yield clearFocus();
 
-      var event = document.createEvent("KeyEvents");
-      event.initKeyEvent("keypress", true, true, null, false, false,
-                         false, false, 0, "/".charCodeAt(0));
-      gBrowser.contentDocument.documentElement.dispatchEvent(event);
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        let document = content.document;
+        let event = document.createEvent("KeyEvents");
+        event.initKeyEvent("keypress", true, true, null, false, false,
+                           false, false, 0, "/".charCodeAt(0));
+        document.documentElement.dispatchEvent(event);
+      });
 
       ok(!gFindBar.hidden, "testQuickFindText: failed to open findbar");
       ok(document.commandDispatcher.focusedElement == gFindBar._findField.inputField,
-         "testQuickFindText: find field is not focused");
+        "testQuickFindText: find field is not focused");
 
-      enterStringIntoFindField(SEARCH_TEXT);
-      ok(gBrowser.contentWindow.getSelection() == SEARCH_TEXT,
-         "testQuickFindText: failed to find '" + SEARCH_TEXT + "'");
+      yield enterStringIntoFindField(SEARCH_TEXT);
+      yield ContentTask.spawn(gBrowser, { SEARCH_TEXT }, function* (args) {
+        Assert.equal(content.getSelection().toString(), args.SEARCH_TEXT,
+          "testQuickFindText: failed to find '" + args.SEARCH_TEXT + "'");
+      });
       testClipboardSearchString(SEARCH_TEXT);
     }
 
-    function testFindCountUI(callback) {
-      let deferred = Promise.defer();
+    function* testFindCountUI(callback) {
+      yield clearFocus();
 
-      clearFocus();
       document.getElementById("cmd_find").doCommand();
 
       ok(!gFindBar.hidden, "testFindCountUI: failed to open findbar");
       ok(document.commandDispatcher.focusedElement == gFindBar._findField.inputField,
          "testFindCountUI: find field is not focused");
 
+      let promise;
       let matchCase = gFindBar.getElement("find-case-sensitive");
-      if (matchCase.checked)
+      if (matchCase.checked) {
+        promise = promiseFindResult();
         matchCase.click();
+        yield promise;
+      }
 
       let foundMatches = gFindBar._foundMatches;
       let tests = [{
@@ -454,85 +549,73 @@
           "Total amount of matches should be " + aTest.total);
       }
 
-      function* generatorTest() {
-        for (let test of tests) {
-          gFindBar.clear();
-          yield;
-          enterStringIntoFindField(test.text);
-          yield;
-          let matches = foundMatches.value.match(regex);
-          if (!test.total) {
-            ok(!matches, "No message should be shown when 0 matches are expected");
-          } else {
-            assertMatches(test, matches);
-            for (let i = 1; i < test.total; i++) {
-              gFindBar.onFindAgainCommand();
-              yield;
-              // test.current + 1, test.current + 2, ..., test.total, 1, ..., test.current
-              let current = (test.current + i - 1) % test.total + 1;
-              assertMatches({
-                current: current,
-                total: test.total
-              }, foundMatches.value.match(regex));
-            }
+      for (let test of tests) {
+        promise = promiseMatchesCountResult();
+        gFindBar.clear();
+        yield promise;
+
+        promise = promiseMatchesCountResult();
+        yield enterStringIntoFindField(test.text, false);
+        yield promise;
+        let matches = foundMatches.value.match(regex);
+        if (!test.total) {
+          ok(!matches, "No message should be shown when 0 matches are expected");
+        } else {
+          assertMatches(test, matches);
+          for (let i = 1; i < test.total; i++) {
+            gFindBar.onFindAgainCommand();
+            yield promiseMatchesCountResult();
+            // test.current + 1, test.current + 2, ..., test.total, 1, ..., test.current
+            let current = (test.current + i - 1) % test.total + 1;
+            assertMatches({
+              current: current,
+              total: test.total
+            }, foundMatches.value.match(regex));
           }
         }
-        deferred.resolve();
       }
-      let test = generatorTest();
-      let resultListener = {
-        onMatchesCountResult: function() {
-          test.next();
-        }
-      };
-      gFindBar.browser.finder.addResultListener(resultListener);
-      test.next();
-      return deferred.promise;
     }
 
     // See bug 1051187.
-    function testFindAfterCaseChanged() {
-      let deferred = Promise.defer();
-
+    function* testFindAfterCaseChanged() {
       // Search to set focus on "Text Test" so that searching for "t" selects first
       // (upper case!) "T".
-      enterStringIntoFindField(SEARCH_TEXT);
+      yield enterStringIntoFindField(SEARCH_TEXT);
       gFindBar.clear();
 
       let prefsvc = Cc["@mozilla.org/preferences-service;1"]
                       .getService(Ci.nsIPrefBranch);
       prefsvc.setIntPref("accessibility.typeaheadfind.casesensitive", 0);
 
-      enterStringIntoFindField("t");
-      is(String(gBrowser.contentWindow.getSelection()), "T", "First T should be selected.");
+      yield enterStringIntoFindField("t");
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        Assert.equal(content.getSelection().toString(), "T", "First T should be selected.");
+      });
 
       prefsvc.setIntPref("accessibility.typeaheadfind.casesensitive", 1);
-      setTimeout(function() {
-        is(String(gBrowser.contentWindow.getSelection()), "t", "First t should be selected.");
-        deferred.resolve();
-      }, 0);
-      return deferred.promise;
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        Assert.equal(content.getSelection().toString(), "t", "First t should be selected.");
+      });
     }
 
     // Make sure that _findFailedString is cleared:
     // 1. Do a search that fails with case sensitivity but matches with no case sensitivity.
     // 2. Uncheck case sensitivity button to match the string.
-    function testFailedStringReset(aCallback) {
-      let deferred = Promise.defer();
-
-      var prefsvc = Cc["@mozilla.org/preferences-service;1"].
+    function* testFailedStringReset() {
+      let prefsvc = Cc["@mozilla.org/preferences-service;1"].
                     getService(Components.interfaces.nsIPrefBranch);
       prefsvc.setIntPref("accessibility.typeaheadfind.casesensitive", 1);
 
-      enterStringIntoFindField(SEARCH_TEXT.toUpperCase());
-      is(String(gBrowser.contentWindow.getSelection()), "", "Not found.");
+      yield enterStringIntoFindField(SEARCH_TEXT.toUpperCase(), false);
+      yield ContentTask.spawn(gBrowser, null, function* () {
+        Assert.equal(content.getSelection().toString(), "", "Not found.");
+      });
 
       prefsvc.setIntPref("accessibility.typeaheadfind.casesensitive", 0);
-      setTimeout(function() {
-        is(String(gBrowser.contentWindow.getSelection()), SEARCH_TEXT, "Search text should be selected.");
-        deferred.resolve();
-      }, 0);
-      return deferred.resolve();
+      yield ContentTask.spawn(gBrowser, { SEARCH_TEXT }, function* (args) {
+        Assert.equal(content.getSelection().toString(), args.SEARCH_TEXT,
+          "Search text should be selected.");
+      });
     }
 
     function testClipboardSearchString(aExpected) {
@@ -550,39 +633,28 @@
     // See bug 967982.
     function* testFindAgainNotFound() {
       yield openFindbar();
-      yield findAndWaitForResult(NOT_FOUND_TEXT);
+      yield enterStringIntoFindField(NOT_FOUND_TEXT, false);
       gFindBar.close();
       ok(gFindBar.hidden, "The findbar is closed.");
-      yield findAndWaitForResult();
+      let promise = promiseFindResult();
+      gFindBar.onFindAgainCommand();
+      yield promise;
       ok(!gFindBar.hidden, "Unsuccessful Find Again opens the find bar.");
 
-      yield findAndWaitForResult(SEARCH_TEXT);
+      yield enterStringIntoFindField(SEARCH_TEXT);
       gFindBar.close();
       ok(gFindBar.hidden, "The findbar is closed.");
-      yield findAndWaitForResult();
+      promise = promiseFindResult();
+      gFindBar.onFindAgainCommand();
+      yield promise;
       ok(gFindBar.hidden, "Successful Find Again leaves the find bar closed.");
     }
-
-    function findAndWaitForResult(aText) {
-      return new Promise(resolve => {
-        gFindBar.browser.finder.addResultListener({
-          onFindResult: function(aData) {
-            gFindBar.browser.finder.removeResultListener(this);
-            resolve(aData);
-          }
-        });
-        if (aText) {
-          enterStringIntoFindField(aText);
-        } else {
-          gFindBar.onFindAgainCommand();
-        }
-      });
-    }
   ]]></script>
 
   <commandset>
     <command id="cmd_find" oncommand="document.getElementById('FindToolbar').onFindCommand();"/>
   </commandset>
   <browser type="content-primary" flex="1" id="content" src="about:blank"/>
+  <browser type="content-primary" flex="1" id="content-remote" remote="true" src="about:blank"/>
   <findbar id="FindToolbar" browserid="content"/>
 </window>