From 0adc8ded6e9212e271b2552e10c5eb5c6fa366f4 Mon Sep 17 00:00:00 2001
From: Wes Kocher <wkocher@mozilla.com>
Date: Wed, 8 Jun 2016 14:53:57 -0700
Subject: [PATCH] Backed out 6 changesets (bug 384458) for frequent
 browser_FinderHighlighter.js failures

Backed out changeset ded915ec401f (bug 384458)
Backed out changeset 63ec66da50fa (bug 384458)
Backed out changeset ae71396d3be0 (bug 384458)
Backed out changeset 3b025cbfbe3c (bug 384458)
Backed out changeset 091c5465acf7 (bug 384458)
Backed out changeset 5eabde153def (bug 384458)
---
 browser/app/profile/firefox.js                |    2 -
 .../mochitest/browserElement_Find.js          |   18 +-
 modules/libpref/init/all.js                   |    6 +-
 testing/profiles/prefs_general.js             |    2 -
 toolkit/content/tests/browser/browser.ini     |    1 -
 .../tests/browser/browser_bug451286.js        |   16 -
 .../content/tests/chrome/bug360437_window.xul |   41 +-
 toolkit/content/widgets/browser.xml           |    1 +
 toolkit/content/widgets/editor.xml            |    1 +
 toolkit/content/widgets/findbar.xml           |  110 +-
 toolkit/modules/Finder.jsm                    |  500 ++++++--
 toolkit/modules/FinderHighlighter.jsm         | 1062 -----------------
 toolkit/modules/RemoteFinder.jsm              |   39 +-
 toolkit/modules/moz.build                     |    1 -
 toolkit/modules/tests/browser/browser.ini     |    2 -
 .../browser/browser_FinderHighlighter.js      |  188 ---
 widget/nsXPLookAndFeel.cpp                    |    9 -
 widget/nsXPLookAndFeel.h                      |    1 -
 18 files changed, 481 insertions(+), 1519 deletions(-)
 delete mode 100644 toolkit/modules/FinderHighlighter.jsm
 delete mode 100644 toolkit/modules/tests/browser/browser_FinderHighlighter.js

diff --git a/browser/app/profile/firefox.js b/browser/app/profile/firefox.js
index 498aed3ce3bf..e59f98ba82a1 100644
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -614,8 +614,6 @@ pref("accessibility.typeaheadfind", false);
 pref("accessibility.typeaheadfind.timeout", 5000);
 pref("accessibility.typeaheadfind.linksonly", false);
 pref("accessibility.typeaheadfind.flashBar", 1);
-pref("findbar.highlightAll", true);
-pref("findbar.modalHighlight", true);
 
 // Tracks when accessibility is loaded into the previous session.
 pref("accessibility.loadedInLastSession", false);
diff --git a/dom/browser-element/mochitest/browserElement_Find.js b/dom/browser-element/mochitest/browserElement_Find.js
index 03eef4385552..2ab378ff1884 100644
--- a/dom/browser-element/mochitest/browserElement_Find.js
+++ b/dom/browser-element/mochitest/browserElement_Find.js
@@ -37,7 +37,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'foo',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 1,
       numberOfMatches: 5,
     }), `test ${testCount++}`);
@@ -48,7 +48,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'foo',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 2,
       numberOfMatches: 5,
     }), `test ${testCount++}`);
@@ -59,7 +59,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'foo',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 1,
       numberOfMatches: 5,
     }), `test ${testCount++}`);
@@ -70,7 +70,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'xxx',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 0,
       numberOfMatches: 0,
     }), `test ${testCount++}`);
@@ -81,7 +81,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'bar',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 1,
       numberOfMatches: 4,
     }), `test ${testCount++}`);
@@ -92,7 +92,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'bar',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 2,
       numberOfMatches: 4,
     }), `test ${testCount++}`);
@@ -103,7 +103,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'bar',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 3,
       numberOfMatches: 4,
     }), `test ${testCount++}`);
@@ -114,7 +114,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'bar',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 4,
       numberOfMatches: 4,
     }), `test ${testCount++}`);
@@ -125,7 +125,7 @@ function runTest() {
       msg_name: "findchange",
       active: true,
       searchString: 'bar',
-      searchLimit: 1000,
+      searchLimit: 100,
       activeMatchOrdinal: 1,
       numberOfMatches: 4,
     }), `test ${testCount++}`);
diff --git a/modules/libpref/init/all.js b/modules/libpref/init/all.js
index ec268f74ed0f..fbcabb6cc046 100644
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -856,10 +856,8 @@ pref("accessibility.typeaheadfind.prefillwithselection", false);
 #else
 pref("accessibility.typeaheadfind.prefillwithselection", true);
 #endif
-pref("accessibility.typeaheadfind.matchesCountTimeout", 100);
-pref("accessibility.typeaheadfind.matchesCountLimit", 1000);
-pref("findbar.highlightAll", false);
-pref("findbar.modalHighlight", false);
+pref("accessibility.typeaheadfind.matchesCountTimeout", 250);
+pref("accessibility.typeaheadfind.matchesCountLimit", 100);
 
 // use Mac OS X Appearance panel text smoothing setting when rendering text, disabled by default
 pref("gfx.use_text_smoothing_setting", false);
diff --git a/testing/profiles/prefs_general.js b/testing/profiles/prefs_general.js
index 4fb0c1cf66b7..0a85eedc90ea 100644
--- a/testing/profiles/prefs_general.js
+++ b/testing/profiles/prefs_general.js
@@ -23,8 +23,6 @@ user_pref("browser.shell.checkDefaultBrowser", false);
 user_pref("shell.checkDefaultClient", false);
 user_pref("browser.warnOnQuit", false);
 user_pref("accessibility.typeaheadfind.autostart", false);
-user_pref("findbar.highlightAll", false);
-user_pref("findbar.modalHighlight", false);
 user_pref("javascript.options.showInConsole", true);
 user_pref("devtools.browsertoolbox.panel", "jsdebugger");
 user_pref("devtools.debugger.remote-port", 6023);
diff --git a/toolkit/content/tests/browser/browser.ini b/toolkit/content/tests/browser/browser.ini
index 295360d85c2f..12139b6412ff 100644
--- a/toolkit/content/tests/browser/browser.ini
+++ b/toolkit/content/tests/browser/browser.ini
@@ -11,7 +11,6 @@ support-files =
 [browser_autoscroll_disabled.js]
 [browser_bug295977_autoscroll_overflow.js]
 [browser_bug451286.js]
-skip-if = !e10s
 [browser_bug594509.js]
 [browser_bug982298.js]
 [browser_bug1198465.js]
diff --git a/toolkit/content/tests/browser/browser_bug451286.js b/toolkit/content/tests/browser/browser_bug451286.js
index a5dadeb84929..f467f034f962 100644
--- a/toolkit/content/tests/browser/browser_bug451286.js
+++ b/toolkit/content/tests/browser/browser_bug451286.js
@@ -20,7 +20,6 @@ add_task(function*() {
 
   yield openFindBarAndWait();
   gFindBar._findField.value = SEARCH_TEXT;
-  yield findAgainAndWait();
   var matchCase = gFindBar.getElement("find-case-sensitive");
   if (matchCase.checked)
     matchCase.doCommand();
@@ -119,21 +118,6 @@ function toggleHighlightAndWait(shouldHighlight) {
   });
 }
 
-function findAgainAndWait() {
-  return new Promise(resolve => {
-    let listener = {
-      onFindResult() {
-        gFindBar.browser.finder.removeResultListener(listener);
-        resolve();
-      },
-      onHighlightFinished() {},
-      onMatchesCountResult() {}
-    };
-    gFindBar.browser.finder.addResultListener(listener);
-    gFindBar.onFindAgainCommand();
-  });
-}
-
 function* openFindBarAndWait() {
   let awaitTransitionEnd = BrowserTestUtils.waitForEvent(gFindBar, "transitionend");
   gFindBar.open();
diff --git a/toolkit/content/tests/chrome/bug360437_window.xul b/toolkit/content/tests/chrome/bug360437_window.xul
index a09d48599bad..b937c8c8b493 100644
--- a/toolkit/content/tests/chrome/bug360437_window.xul
+++ b/toolkit/content/tests/chrome/bug360437_window.xul
@@ -64,7 +64,7 @@
 
       // Make sure the findfield is correctly focused on open
       var searchStr = "text inside an input element";
-      yield promiseEnterStringIntoFindField(searchStr);
+      yield* enterStringIntoFindField(searchStr);
       is(document.commandDispatcher.focusedElement,
          gFindBar._findField.inputField, "Find field isn't focused");
 
@@ -72,6 +72,12 @@
       // when the find bar is closed.
       gFindBar.close();
       gFindBar.onFindAgainCommand(false);
+      // For remote browsers, the content document DOM tree is not accessible, thus
+      // the focused element should fall back to the browser element.
+      if (gBrowser.hasAttribute("remote")) {
+        is(document.commandDispatcher.focusedElement, gBrowser,
+          "Browser element isn't focused");
+      }
       yield ContentTask.spawn(gBrowser, null, function* () {
         Assert.equal(content.document.activeElement,
          content.document.getElementById("input"), "Input Element isn't focused");
@@ -87,30 +93,23 @@
          "Focus was stolen from a chrome element");
     }
 
-    function promiseFindResult(str = null) {
-      return new Promise(resolve => {
-        let listener = {
-          onFindResult: function({ searchString }) {
-            if (str !== null && str != searchString) {
-              return;
-            }
-            gFindBar.browser.finder.removeResultListener(listener);
-            resolve();
-          }
-        };
-        gFindBar.browser.finder.addResultListener(listener);
-      });
-    }
-
-    function promiseEnterStringIntoFindField(str) {
-      let promise = promiseFindResult(str);
-      for (let i = 0; i < str.length; i++) {
+    function* enterStringIntoFindField(aString) {
+      for (let i = 0; i < aString.length; i++) {
         let event = document.createEvent("KeyEvents");
+        let promise = new Promise(resolve => {
+          let listener = {
+            onFindResult: function() {
+              gFindBar.browser.finder.removeResultListener(listener);
+              resolve();
+            }
+          };
+          gFindBar.browser.finder.addResultListener(listener);
+        });
         event.initKeyEvent("keypress", true, true, null, false, false,
-                           false, false, 0, str.charCodeAt(i));
+                           false, false, 0, aString.charCodeAt(i));
         gFindBar._findField.inputField.dispatchEvent(event);
+        yield promise;
       }
-      return promise;
     }
   ]]></script>
   <textbox id="textbox"/>
diff --git a/toolkit/content/widgets/browser.xml b/toolkit/content/widgets/browser.xml
index a5423540151e..d802bc215f4a 100644
--- a/toolkit/content/widgets/browser.xml
+++ b/toolkit/content/widgets/browser.xml
@@ -436,6 +436,7 @@
       </property>
 
       <field name="_lastSearchString">null</field>
+      <field name="_lastSearchHighlight">false</field>
 
       <property name="webProgress"
                 readonly="true"
diff --git a/toolkit/content/widgets/editor.xml b/toolkit/content/widgets/editor.xml
index 637586dc2c74..96cd4e9e1f43 100644
--- a/toolkit/content/widgets/editor.xml
+++ b/toolkit/content/widgets/editor.xml
@@ -124,6 +124,7 @@
       </property>
 
       <field name="_lastSearchString">null</field>
+      <field name="_lastSearchHighlight">false</field>
 
       <property name="editortype"
                 onget="return this.getAttribute('editortype');"
diff --git a/toolkit/content/widgets/findbar.xml b/toolkit/content/widgets/findbar.xml
index 06a520341dd5..3a95a36122c2 100644
--- a/toolkit/content/widgets/findbar.xml
+++ b/toolkit/content/widgets/findbar.xml
@@ -290,22 +290,12 @@
             this._browser.finder.addResultListener(this);
 
             this._findField.value = this._browser._lastSearchString;
+            this.toggleHighlight(this.browser._lastSearchHighlight);
           }
           return val;
         ]]></setter>
       </property>
 
-      <field name="__prefsvc">null</field>
-      <property name="_prefsvc">
-        <getter><![CDATA[
-          if (!this.__prefsvc) {
-            this.__prefsvc = Components.classes["@mozilla.org/preferences-service;1"]
-              .getService(Components.interfaces.nsIPrefBranch);
-          }
-          return this.__prefsvc;
-        ]]></getter>
-      </property>
-
       <field name="_observer"><![CDATA[({
         _self: this,
 
@@ -322,7 +312,8 @@
           if (aTopic != "nsPref:changed")
             return;
 
-          let prefsvc = this._self._prefsvc;
+          let prefsvc =
+            aSubject.QueryInterface(Components.interfaces.nsIPrefBranch);
 
           switch (aPrefName) {
             case "accessibility.typeaheadfind":
@@ -334,14 +325,6 @@
             case "accessibility.typeaheadfind.casesensitive":
               this._self._setCaseSensitivity(prefsvc.getIntPref(aPrefName));
               break;
-            case "findbar.highlightAll":
-              this._self.toggleHighlight(prefsvc.getBoolPref(aPrefName), true);
-              break;
-            case "findbar.modalHighlight":
-              this._self._useModalHighlight = prefsvc.getBoolPref(aPrefName);
-              if (this._self.browser.finder)
-                this._self.browser.finder.onModalHighlightChange(this._self._useModalHighlight);
-              break;
           }
         }
       })]]></field>
@@ -357,7 +340,9 @@
 
         this._foundURL = null;
 
-        let prefsvc = this._prefsvc;
+        let prefsvc =
+          Components.classes["@mozilla.org/preferences-service;1"]
+                    .getService(Components.interfaces.nsIPrefBranch);
 
         this._quickFindTimeoutLength =
           prefsvc.getIntPref("accessibility.typeaheadfind.timeout");
@@ -367,7 +352,6 @@
           prefsvc.getIntPref("accessibility.typeaheadfind.matchesCountTimeout");
         this._matchesCountLimit =
           prefsvc.getIntPref("accessibility.typeaheadfind.matchesCountLimit");
-        this._useModalHighlight = prefsvc.getBoolPref("findbar.modalHighlight");
 
         prefsvc.addObserver("accessibility.typeaheadfind",
                             this._observer, false);
@@ -375,8 +359,6 @@
                             this._observer, false);
         prefsvc.addObserver("accessibility.typeaheadfind.casesensitive",
                             this._observer, false);
-        prefsvc.addObserver("findbar.highlightAll", this._observer, false);
-        prefsvc.addObserver("findbar.modalHighlight", this._observer, false);
 
         this._findAsYouType =
           prefsvc.getBoolPref("accessibility.typeaheadfind");
@@ -384,7 +366,6 @@
           prefsvc.getBoolPref("accessibility.typeaheadfind.linksonly");
         this._typeAheadCaseSensitive =
           prefsvc.getIntPref("accessibility.typeaheadfind.casesensitive");
-        this._highlightAll = prefsvc.getBoolPref("findbar.highlightAll");
 
         // Convenience
         this.nsITypeAheadFind = Components.interfaces.nsITypeAheadFind;
@@ -412,20 +393,17 @@
             return;
           this._destroyed = true;
 
-          if (this.browser.finder)
-            this.browser.finder.destroy();
-
           this.browser = null;
 
-          let prefsvc = this._prefsvc;
+          let prefsvc =
+            Components.classes["@mozilla.org/preferences-service;1"]
+                      .getService(Components.interfaces.nsIPrefBranch);
           prefsvc.removeObserver("accessibility.typeaheadfind",
                                  this._observer);
           prefsvc.removeObserver("accessibility.typeaheadfind.linksonly",
                                  this._observer);
           prefsvc.removeObserver("accessibility.typeaheadfind.casesensitive",
                                  this._observer);
-          prefsvc.removeObserver("findbar.highlightAll", this._observer);
-          prefsvc.removeObserver("findbar.modalHighlight", this._observer);
 
           // Clear all timers that might still be running.
           this._cancelTimers();
@@ -513,30 +491,19 @@
         - Turns highlight on or off.
         - @param aHighlight (boolean)
         -        Whether to turn the highlight on or off
-        - @param aFromPrefObserver (boolean)
-        -        Whether the callee is the pref observer, which means we should
-        -        not set the same pref again.
         -->
       <method name="toggleHighlight">
         <parameter name="aHighlight"/>
-        <parameter name="aFromPrefObserver"/>
         <body><![CDATA[
-          if (aHighlight === this._highlightAll) {
+          if (!this._dispatchFindEvent("highlightallchange"))
             return;
-          }
-          this._highlightAll = aHighlight;
-
-          if (!this._dispatchFindEvent("highlightallchange")) {
-            return;
-          }
-
-          this._setHighlightAll(aHighlight, aFromPrefObserver);
 
           let word = this._findField.value;
           // Bug 429723. Don't attempt to highlight ""
           if (aHighlight && !word)
             return;
 
+          this.browser._lastSearchHighlight = aHighlight;
           this.browser.finder.highlight(aHighlight, word);
 
           // Update the matches count
@@ -544,30 +511,6 @@
         ]]></body>
       </method>
 
-      <!--
-        - Updates the highlight-all mode of the findbar and its UI.
-        - @param aHighlight (boolean)
-        -        Whether to turn the highlight on or off.
-        - @param aFromPrefObserver (boolean)
-        -        Whether the callee is the pref observer, which means we should
-        -        not set the same pref again.
-        -->
-      <method name="_setHighlightAll">
-        <parameter name="aHighlight"/>
-        <parameter name="aFromPrefObserver"/>
-        <body><![CDATA[
-          if (typeof aHighlight != "boolean") {
-            aHighlight = this._highlightAll;
-          }
-          if (aHighlight !== this._highlightAll && !aFromPrefObserver) {
-            this._prefsvc.setBoolPref("findbar.highlightAll", aHighlight);
-          }
-          this._highlightAll = aHighlight;
-          let checkbox = this.getElement("highlight");
-          checkbox.checked = this._highlightAll;
-        ]]></body>
-      </method>
-
       <!--
         - Updates the case-sensitivity mode of the findbar and its UI.
         - @param [optional] aString
@@ -699,7 +642,8 @@
             this.setAttribute("noanim", true);
           this.hidden = true;
 
-          this.browser.finder.onFindbarClose();
+          this.browser.finder.focusContent();
+          this.browser.finder.enableSelection();
 
           this._cancelTimers();
 
@@ -910,7 +854,6 @@
             this.getElement("find-previous").hidden = showMinimalUI;
           foundMatches.hidden = showMinimalUI || !foundMatches.value;
           this._updateCaseSensitivity();
-          this._setHighlightAll();
 
           if (showMinimalUI)
             this._findField.classList.add("minimal");
@@ -1065,7 +1008,7 @@
           event.initCustomEvent("find" + aType, true, true, {
             query: this._findField.value,
             caseSensitive: !!this._typeAheadCaseSensitive,
-            highlightAll: this._highlightAll,
+            highlightAll: this.getElement("highlight").checked,
             findPrevious: aFindPrevious
           });
           return this.dispatchEvent(event);
@@ -1084,7 +1027,9 @@
       <method name="startFind">
         <parameter name="aMode"/>
         <body><![CDATA[
-          let prefsvc = this._prefsvc;
+          let prefsvc =
+            Components.classes["@mozilla.org/preferences-service;1"]
+                      .getService(Components.interfaces.nsIPrefBranch);
           let userWantsPrefill = true;
           this.open(aMode);
 
@@ -1162,16 +1107,10 @@
           this._findFailedString = null;
 
           // Ensure the stored SearchString is in sync with what we want to find
-          if (this._findField.value != this._browser.finder.searchString) {
+          if (this._findField.value != this._browser.finder.searchString)
             this._find(this._findField.value);
-          } else {
+          else
             this._findAgain(aFindPrevious);
-            if (this._useModalHighlight) {
-              this.open();
-              this._findField.select();
-              this._findField.focus();
-            }
-          }
 
           return undefined;
         ]]></body>
@@ -1192,7 +1131,9 @@
 
       <method name="_onFindFieldFocus">
         <body><![CDATA[
-          let prefsvc = this._prefsvc;
+          let prefsvc =
+            Components.classes["@mozilla.org/preferences-service;1"]
+                      .getService(Components.interfaces.nsIPrefBranch);
           const kPref = "accessibility.typeaheadfind.prefillwithselection";
           if (this.prefillWithSelection && prefsvc.getBoolPref(kPref))
             return;
@@ -1276,13 +1217,6 @@
         ]]></body>
       </method>
 
-      <method name="onHighlightFinished">
-        <parameter name="result"/>
-        <body><![CDATA[
-          // Noop.
-        ]]></body>
-      </method>
-
       <method name="onCurrentSelection">
         <parameter name="aSelectionString" />
         <parameter name="aIsInitialSelection" />
diff --git a/toolkit/modules/Finder.jsm b/toolkit/modules/Finder.jsm
index 8dc0dcdf9f95..27263358c486 100644
--- a/toolkit/modules/Finder.jsm
+++ b/toolkit/modules/Finder.jsm
@@ -22,6 +22,7 @@ XPCOMUtils.defineLazyServiceGetter(this, "ClipboardHelper",
                                          "@mozilla.org/widget/clipboardhelper;1",
                                          "nsIClipboardHelper");
 
+const kHighlightIterationSizeMax = 100;
 const kSelectionMaxLen = 150;
 
 function Finder(docShell) {
@@ -32,7 +33,6 @@ function Finder(docShell) {
   this._listeners = [];
   this._previousLink = null;
   this._searchString = null;
-  this._highlighter = null;
 
   docShell.QueryInterface(Ci.nsIInterfaceRequestor)
           .getInterface(Ci.nsIWebProgress)
@@ -40,19 +40,6 @@ function Finder(docShell) {
 }
 
 Finder.prototype = {
-  destroy: function() {
-    if (this._highlighter) {
-      this._highlighter.clear();
-      this._highlighter.hide();
-    }
-    this.listeners = [];
-    this._docShell.QueryInterface(Ci.nsIInterfaceRequestor)
-      .getInterface(Ci.nsIWebProgress)
-      .removeProgressListener(this, Ci.nsIWebProgress.NOTIFY_LOCATION);
-    this._listeners = [];
-    this._fastFind = this._docShell = this._previousLink = this._highlighter = null;
-  },
-
   addResultListener: function (aListener) {
     if (this._listeners.indexOf(aListener) === -1)
       this._listeners.push(aListener);
@@ -62,15 +49,12 @@ Finder.prototype = {
     this._listeners = this._listeners.filter(l => l != aListener);
   },
 
-  _notify: function (options) {
-    if (typeof options.storeResult != "boolean")
-      options.storeResult = true;
-
-    if (options.storeResult) {
-      this._searchString = options.searchString;
-      this.clipboardSearchString = options.searchString
+  _notify: function (aSearchString, aResult, aFindBackwards, aDrawOutline, aStoreResult = true) {
+    if (aStoreResult) {
+      this._searchString = aSearchString;
+      this.clipboardSearchString = aSearchString
     }
-    this._outlineLink(options.drawOutline);
+    this._outlineLink(aDrawOutline);
 
     let foundLink = this._fastFind.foundLink;
     let linkURL = null;
@@ -83,15 +67,18 @@ Finder.prototype = {
       linkURL = TextToSubURIService.unEscapeURIForUI(docCharset, foundLink.href);
     }
 
-    options.linkURL = linkURL;
-    options.rect = this._getResultRect();
-    options.searchString = this._searchString;
-
-    this.highlighter.update(options);
+    let data = {
+      result: aResult,
+      findBackwards: aFindBackwards,
+      linkURL: linkURL,
+      rect: this._getResultRect(),
+      searchString: this._searchString,
+      storeResult: aStoreResult
+    };
 
     for (let l of this._listeners) {
       try {
-        l.onFindResult(options);
+        l.onFindResult(data);
       } catch (ex) {}
     }
   },
@@ -121,14 +108,6 @@ Finder.prototype = {
     this._fastFind.caseSensitive = aSensitive;
   },
 
-  get highlighter() {
-    if (this._highlighter)
-      return this._highlighter;
-
-    const {FinderHighlighter} = Cu.import("resource://gre/modules/FinderHighlighter.jsm", {});
-    return this._highlighter = new FinderHighlighter(this);
-  },
-
   _lastFindResult: null,
 
   /**
@@ -141,13 +120,7 @@ Finder.prototype = {
   fastFind: function (aSearchString, aLinksOnly, aDrawOutline) {
     this._lastFindResult = this._fastFind.find(aSearchString, aLinksOnly);
     let searchString = this._fastFind.searchString;
-    this._notify({
-      searchString,
-      result: this._lastFindResult,
-      findBackwards: false,
-      findAgain: false,
-      drawOutline: aDrawOutline
-    });
+    this._notify(searchString, this._lastFindResult, false, aDrawOutline);
   },
 
   /**
@@ -162,13 +135,7 @@ Finder.prototype = {
   findAgain: function (aFindBackwards, aLinksOnly, aDrawOutline) {
     this._lastFindResult = this._fastFind.findAgain(aFindBackwards, aLinksOnly);
     let searchString = this._fastFind.searchString;
-    this._notify({
-      searchString,
-      result: this._lastFindResult,
-      findBackwards: aFindBackwards,
-      fidnAgain: true,
-      drawOutline: aDrawOutline
-    });
+    this._notify(searchString, this._lastFindResult, aFindBackwards, aDrawOutline);
   },
 
   /**
@@ -186,22 +153,25 @@ Finder.prototype = {
     return searchString;
   },
 
-  highlight: Task.async(function* (aHighlight, aWord) {
-    this.highlighter.maybeAbort();
+  _notifyHighlightFinished: function(aHighlight) {
+    for (let l of this._listeners) {
+      try {
+        l.onHighlightFinished(aHighlight);
+      } catch (ex) {}
+    }
+  },
 
-    let found = yield this.highlighter.highlight(aHighlight, aWord, null);
-    this.highlighter.notifyFinished(aHighlight);
+  highlight: Task.async(function* (aHighlight, aWord) {
+    if (this._abortHighlight) {
+      this._abortHighlight();
+    }
+
+    let found = yield this._highlight(aHighlight, aWord, null);
+    this._notifyHighlightFinished(aHighlight);
     if (aHighlight) {
       let result = found ? Ci.nsITypeAheadFind.FIND_FOUND
                          : Ci.nsITypeAheadFind.FIND_NOTFOUND;
-      this._notify({
-        searchString: aWord,
-        result,
-        findBackwards: false,
-        findAgain: false,
-        drawOutline: false,
-        storeResult: false
-      });
+      this._notify(aWord, result, false, false, false);
     }
   }),
 
@@ -260,7 +230,6 @@ Finder.prototype = {
   removeSelection: function() {
     this._fastFind.collapseSelection();
     this.enableSelection();
-    this.highlighter.clear();
   },
 
   focusContent: function() {
@@ -292,17 +261,6 @@ Finder.prototype = {
     } catch (e) {}
   },
 
-  onFindbarClose: function() {
-    this.focusContent();
-    this.enableSelection();
-    this.highlighter.hide();
-  },
-
-  onModalHighlightChange(useModalHighlight) {
-    if (this._highlighter)
-      this._highlighter.onModalHighlightChange(useModalHighlight);
-  },
-
   keyPress: function (aEvent) {
     let controller = this._getSelectionController(this._getWindow());
 
@@ -476,6 +434,28 @@ Finder.prototype = {
     }
   },
 
+  _highlightIterator: Task.async(function* (aWord, aWindow, aOnFind) {
+    let count = 0;
+    for (let range of this._findIterator(aWord, aWindow)) {
+      aOnFind(range);
+      if (++count >= kHighlightIterationSizeMax) {
+          count = 0;
+          yield this._highlightSleep(0);
+      }
+    }
+  }),
+
+  _abortHighlight: null,
+  _highlightSleep: function(delay) {
+    return new Promise((resolve, reject) => {
+      this._abortHighlight = () => {
+        this._abortHighlight = null;
+        reject();
+      };
+      this._getWindow().setTimeout(resolve, delay);
+    });
+  },
+
   /**
    * Helper method for `_countMatchesInWindow` that recursively collects all
    * visible (i)frames inside a window.
@@ -618,6 +598,84 @@ Finder.prototype = {
     }
   },
 
+  _highlight: Task.async(function* (aHighlight, aWord, aWindow) {
+    let win = aWindow || this._getWindow();
+
+    let found = false;
+    for (let i = 0; win.frames && i < win.frames.length; i++) {
+      if (yield this._highlight(aHighlight, aWord, win.frames[i]))
+        found = true;
+    }
+
+    let controller = this._getSelectionController(win);
+    let doc = win.document;
+    if (!controller || !doc || !doc.documentElement) {
+      // Without the selection controller,
+      // we are unable to (un)highlight any matches
+      return found;
+    }
+
+    if (aHighlight) {
+      yield this._highlightIterator(aWord, win, aRange => {
+        this._highlightRange(aRange, controller);
+        found = true;
+      });
+    } else {
+      // First, attempt to remove highlighting from main document
+      let sel = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
+      sel.removeAllRanges();
+
+      // Next, check our editor cache, for editors belonging to this
+      // document
+      if (this._editors) {
+        for (let x = this._editors.length - 1; x >= 0; --x) {
+          if (this._editors[x].document == doc) {
+            sel = this._editors[x].selectionController
+                                  .getSelection(Ci.nsISelectionController.SELECTION_FIND);
+            sel.removeAllRanges();
+            // We don't need to listen to this editor any more
+            this._unhookListenersAtIndex(x);
+          }
+        }
+      }
+
+      // Removing the highlighting always succeeds, so return true.
+      found = true;
+    }
+
+    return found;
+  }),
+
+  _highlightRange: function(aRange, aController) {
+    let node = aRange.startContainer;
+    let controller = aController;
+
+    let editableNode = this._getEditableNode(node);
+    if (editableNode)
+      controller = editableNode.editor.selectionController;
+
+    let findSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
+    findSelection.addRange(aRange);
+
+    if (editableNode) {
+      // Highlighting added, so cache this editor, and hook up listeners
+      // to ensure we deal properly with edits within the highlighting
+      if (!this._editors) {
+        this._editors = [];
+        this._stateListeners = [];
+      }
+
+      let existingIndex = this._editors.indexOf(editableNode.editor);
+      if (existingIndex == -1) {
+        let x = this._editors.length;
+        this._editors[x] = editableNode.editor;
+        this._stateListeners[x] = this._createStateListener();
+        this._editors[x].addEditActionListener(this);
+        this._editors[x].addDocumentStateListener(this._stateListeners[x]);
+      }
+    }
+  },
+
   _getSelectionController: function(aWindow) {
     // display: none iframes don't have a selection controller, see bug 493658
     try {
@@ -640,6 +698,129 @@ Finder.prototype = {
     return controller;
   },
 
+  /*
+   * For a given node returns its editable parent or null if there is none.
+   * It's enough to check if aNode is a text node and its parent's parent is
+   * instance of nsIDOMNSEditableElement.
+   *
+   * @param aNode the node we want to check
+   * @returns the first node in the parent chain that is editable,
+   *          null if there is no such node
+   */
+  _getEditableNode: function (aNode) {
+    if (aNode.nodeType === aNode.TEXT_NODE && aNode.parentNode && aNode.parentNode.parentNode &&
+        aNode.parentNode.parentNode instanceof Ci.nsIDOMNSEditableElement) {
+      return aNode.parentNode.parentNode;
+    }
+    return null;
+  },
+
+  /*
+   * Helper method to unhook listeners, remove cached editors
+   * and keep the relevant arrays in sync
+   *
+   * @param aIndex the index into the array of editors/state listeners
+   *        we wish to remove
+   */
+  _unhookListenersAtIndex: function (aIndex) {
+    this._editors[aIndex].removeEditActionListener(this);
+    this._editors[aIndex]
+        .removeDocumentStateListener(this._stateListeners[aIndex]);
+    this._editors.splice(aIndex, 1);
+    this._stateListeners.splice(aIndex, 1);
+    if (!this._editors.length) {
+      delete this._editors;
+      delete this._stateListeners;
+    }
+  },
+
+  /*
+   * Remove ourselves as an nsIEditActionListener and
+   * nsIDocumentStateListener from a given cached editor
+   *
+   * @param aEditor the editor we no longer wish to listen to
+   */
+  _removeEditorListeners: function (aEditor) {
+    // aEditor is an editor that we listen to, so therefore must be
+    // cached. Find the index of this editor
+    let idx = this._editors.indexOf(aEditor);
+    if (idx == -1)
+      return;
+    // Now unhook ourselves, and remove our cached copy
+    this._unhookListenersAtIndex(idx);
+  },
+
+  /*
+   * nsIEditActionListener logic follows
+   *
+   * We implement this interface to allow us to catch the case where
+   * the findbar found a match in a HTML <input> or <textarea>. If the
+   * user adjusts the text in some way, it will no longer match, so we
+   * want to remove the highlight, rather than have it expand/contract
+   * when letters are added or removed.
+   */
+
+  /*
+   * Helper method used to check whether a selection intersects with
+   * some highlighting
+   *
+   * @param aSelectionRange the range from the selection to check
+   * @param aFindRange the highlighted range to check against
+   * @returns true if they intersect, false otherwise
+   */
+  _checkOverlap: function (aSelectionRange, aFindRange) {
+    // The ranges overlap if one of the following is true:
+    // 1) At least one of the endpoints of the deleted selection
+    //    is in the find selection
+    // 2) At least one of the endpoints of the find selection
+    //    is in the deleted selection
+    if (aFindRange.isPointInRange(aSelectionRange.startContainer,
+                                  aSelectionRange.startOffset))
+      return true;
+    if (aFindRange.isPointInRange(aSelectionRange.endContainer,
+                                  aSelectionRange.endOffset))
+      return true;
+    if (aSelectionRange.isPointInRange(aFindRange.startContainer,
+                                       aFindRange.startOffset))
+      return true;
+    if (aSelectionRange.isPointInRange(aFindRange.endContainer,
+                                       aFindRange.endOffset))
+      return true;
+
+    return false;
+  },
+
+  /*
+   * Helper method to determine if an edit occurred within a highlight
+   *
+   * @param aSelection the selection we wish to check
+   * @param aNode the node we want to check is contained in aSelection
+   * @param aOffset the offset into aNode that we want to check
+   * @returns the range containing (aNode, aOffset) or null if no ranges
+   *          in the selection contain it
+   */
+  _findRange: function (aSelection, aNode, aOffset) {
+    let rangeCount = aSelection.rangeCount;
+    let rangeidx = 0;
+    let foundContainingRange = false;
+    let range = null;
+
+    // Check to see if this node is inside one of the selection's ranges
+    while (!foundContainingRange && rangeidx < rangeCount) {
+      range = aSelection.getRangeAt(rangeidx);
+      if (range.isPointInRange(aNode, aOffset)) {
+        foundContainingRange = true;
+        break;
+      }
+      rangeidx++;
+    }
+
+    if (foundContainingRange)
+      return range;
+
+    return null;
+  },
+
   /**
    * Determines whether a range is inside a link.
    * @param aRange
@@ -684,7 +865,176 @@ Finder.prototype = {
 
     // Avoid leaking if we change the page.
     this._previousLink = null;
-    this.highlighter.onLocationChange();
+  },
+
+  // Start of nsIEditActionListener implementations
+
+  WillDeleteText: function (aTextNode, aOffset, aLength) {
+    let editor = this._getEditableNode(aTextNode).editor;
+    let controller = editor.selectionController;
+    let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
+    let range = this._findRange(fSelection, aTextNode, aOffset);
+
+    if (range) {
+      // Don't remove the highlighting if the deleted text is at the
+      // end of the range
+      if (aTextNode != range.endContainer ||
+          aOffset != range.endOffset) {
+        // Text within the highlight is being removed - the text can
+        // no longer be a match, so remove the highlighting
+        fSelection.removeRange(range);
+        if (fSelection.rangeCount == 0)
+          this._removeEditorListeners(editor);
+      }
+    }
+  },
+
+  DidInsertText: function (aTextNode, aOffset, aString) {
+    let editor = this._getEditableNode(aTextNode).editor;
+    let controller = editor.selectionController;
+    let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
+    let range = this._findRange(fSelection, aTextNode, aOffset);
+
+    if (range) {
+      // If the text was inserted before the highlight
+      // adjust the highlight's bounds accordingly
+      if (aTextNode == range.startContainer &&
+          aOffset == range.startOffset) {
+        range.setStart(range.startContainer,
+                       range.startOffset+aString.length);
+      } else if (aTextNode != range.endContainer ||
+                 aOffset != range.endOffset) {
+        // The edit occurred within the highlight - any addition of text
+        // will result in the text no longer being a match,
+        // so remove the highlighting
+        fSelection.removeRange(range);
+        if (fSelection.rangeCount == 0)
+          this._removeEditorListeners(editor);
+      }
+    }
+  },
+
+  WillDeleteSelection: function (aSelection) {
+    let editor = this._getEditableNode(aSelection.getRangeAt(0)
+                                                 .startContainer).editor;
+    let controller = editor.selectionController;
+    let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
+
+    let selectionIndex = 0;
+    let findSelectionIndex = 0;
+    let shouldDelete = {};
+    let numberOfDeletedSelections = 0;
+    let numberOfMatches = fSelection.rangeCount;
+
+    // We need to test if any ranges in the deleted selection (aSelection)
+    // are in any of the ranges of the find selection
+    // Usually both selections will only contain one range, however
+    // either may contain more than one.
+
+    for (let fIndex = 0; fIndex < numberOfMatches; fIndex++) {
+      shouldDelete[fIndex] = false;
+      let fRange = fSelection.getRangeAt(fIndex);
+
+      for (let index = 0; index < aSelection.rangeCount; index++) {
+        if (shouldDelete[fIndex])
+          continue;
+
+        let selRange = aSelection.getRangeAt(index);
+        let doesOverlap = this._checkOverlap(selRange, fRange);
+        if (doesOverlap) {
+          shouldDelete[fIndex] = true;
+          numberOfDeletedSelections++;
+        }
+      }
+    }
+
+    // OK, so now we know what matches (if any) are in the selection
+    // that is being deleted. Time to remove them.
+    if (numberOfDeletedSelections == 0)
+      return;
+
+    for (let i = numberOfMatches - 1; i >= 0; i--) {
+      if (shouldDelete[i])
+        fSelection.removeRange(fSelection.getRangeAt(i));
+    }
+
+    // Remove listeners if no more highlights left
+    if (fSelection.rangeCount == 0)
+      this._removeEditorListeners(editor);
+  },
+
+  /*
+   * nsIDocumentStateListener logic follows
+   *
+   * When attaching nsIEditActionListeners, there are no guarantees
+   * as to whether the findbar or the documents in the browser will get
+   * destructed first. This leads to the potential to either leak, or to
+   * hold on to a reference an editable element's editor for too long,
+   * preventing it from being destructed.
+   *
+   * However, when an editor's owning node is being destroyed, the editor
+   * sends out a DocumentWillBeDestroyed notification. We can use this to
+   * clean up our references to the object, to allow it to be destroyed in a
+   * timely fashion.
+   */
+
+  /*
+   * Unhook ourselves when one of our state listeners has been called.
+   * This can happen in 4 cases:
+   *  1) The document the editor belongs to is navigated away from, and
+   *     the document is not being cached
+   *
+   *  2) The document the editor belongs to is expired from the cache
+   *
+   *  3) The tab containing the owning document is closed
+   *
+   *  4) The <input> or <textarea> that owns the editor is explicitly
+   *     removed from the DOM
+   *
+   * @param the listener that was invoked
+   */
+  _onEditorDestruction: function (aListener) {
+    // First find the index of the editor the given listener listens to.
+    // The listeners and editors arrays must always be in sync.
+    // The listener will be in our array of cached listeners, as this
+    // method could not have been called otherwise.
+    let idx = 0;
+    while (this._stateListeners[idx] != aListener)
+      idx++;
+
+    // Unhook both listeners
+    this._unhookListenersAtIndex(idx);
+  },
+
+  /*
+   * Creates a unique document state listener for an editor.
+   *
+   * It is not possible to simply have the findbar implement the
+   * listener interface itself, as it wouldn't have sufficient information
+   * to work out which editor was being destroyed. Therefore, we create new
+   * listeners on the fly, and cache them in sync with the editors they
+   * listen to.
+   */
+  _createStateListener: function () {
+    return {
+      findbar: this,
+
+      QueryInterface: function(aIID) {
+        if (aIID.equals(Ci.nsIDocumentStateListener) ||
+            aIID.equals(Ci.nsISupports))
+          return this;
+
+        throw Components.results.NS_ERROR_NO_INTERFACE;
+      },
+
+      NotifyDocumentWillBeDestroyed: function() {
+        this.findbar._onEditorDestruction(this);
+      },
+
+      // Unimplemented
+      notifyDocumentCreated: function() {},
+      notifyDocumentStateChanged: function(aDirty) {}
+    };
   },
 
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener,
diff --git a/toolkit/modules/FinderHighlighter.jsm b/toolkit/modules/FinderHighlighter.jsm
deleted file mode 100644
index 2a1b436f8080..000000000000
--- a/toolkit/modules/FinderHighlighter.jsm
+++ /dev/null
@@ -1,1062 +0,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/. */
-
-"use strict";
-
-this.EXPORTED_SYMBOLS = ["FinderHighlighter"];
-
-const { interfaces: Ci, utils: Cu } = Components;
-
-Cu.import("resource://gre/modules/Services.jsm");
-Cu.import("resource://gre/modules/Task.jsm");
-
-const kHighlightIterationSizeMax = 100;
-const kModalHighlightRepaintFreqMs = 10;
-const kModalHighlightPref = "findbar.modalHighlight";
-const kFontPropsCSS = ["font-family", "font-kerning", "font-size", "font-size-adjust",
-  "font-stretch", "font-variant", "font-weight", "letter-spacing", "text-emphasis",
-  "text-orientation", "text-transform", "word-spacing"];
-const kFontPropsCamelCase = kFontPropsCSS.map(prop => {
-  let parts = prop.split("-");
-  return parts.shift() + parts.map(part => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-});
-// This uuid is used to prefix HTML element IDs and classNames in order to make
-// them unique and hard to clash with IDs and classNames content authors come up
-// with, since the stylesheet for modal highlighting is inserted as an agent-sheet
-// in the active HTML document.
-const kModalIdPrefix = "cedee4d0-74c5-4f2d-ab43-4d37c0f9d463";
-const kModalOutlineId = kModalIdPrefix + "-findbar-modalHighlight-outline";
-const kModalStyle = `
-.findbar-modalHighlight-outline {
-  position: absolute;
-  background: linear-gradient(to bottom, #f1ee00, #edcc00);
-  border: 1px solid #f5e600;
-  border-radius: 3px;
-  box-shadow: 0px 2px 3px rgba(0,0,0,.8);
-  color: #000;
-  margin-top: -3px;
-  margin-inline-end: 0;
-  margin-bottom: 0;
-  margin-inline-start: -3px;
-  padding-top: 2px;
-  padding-inline-end: 2px;
-  padding-bottom: 0;
-  padding-inline-start: 4px;
-  pointer-events: none;
-}
-
-.findbar-modalHighlight-outline[grow] {
-  transform: scaleX(1.5) scaleY(1.5)
-}
-
-.findbar-modalHighlight-outline[hidden] {
-  opacity: 0;
-  display: -moz-box;
-}
-
-.findbar-modalHighlight-outline:not([disable-transitions]) {
-  transition-property: opacity, transform, top, left;
-  transition-duration: 50ms;
-  transition-timing-function: linear;
-}`;
-const kSVGNS = "http://www.w3.org/2000/svg";
-const kXULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
-
-/**
- * FinderHighlighter class that is used by Finder.jsm to take care of the
- * 'Highlight All' feature, which can highlight all find occurrences in a page.
- *
- * @param {Finder} finder Finder.jsm instance
- */
-function FinderHighlighter(finder) {
-  this.finder = finder;
-  this._modal = Services.prefs.getBoolPref(kModalHighlightPref);
-}
-
-FinderHighlighter.prototype = {
-  get modalStyleSheet() {
-    if (!this._modalStyleSheet) {
-      this._modalStyleSheet = kModalStyle.replace(/(\.|#)findbar-/g,
-        "$1" + kModalIdPrefix + "-findbar-");
-    }
-    return this._modalStyleSheet;
-  },
-
-  get modalStyleSheetURI() {
-    if (!this._modalStyleSheetURI) {
-      this._modalStyleSheetURI = "data:text/css;charset=utf-8," +
-        encodeURIComponent(this.modalStyleSheet.replace(/[\n]+/g, " "));
-    }
-    return this._modalStyleSheetURI;
-  },
-
-  /**
-   * Notify all registered listeners that the 'Highlight All' operation finished.
-   *
-   * @param {Boolean} highlight Whether highlighting was turned on
-   */
-  notifyFinished(highlight) {
-    for (let l of this.finder._listeners) {
-      try {
-        l.onHighlightFinished(highlight);
-      } catch (ex) {}
-    }
-  },
-
-  /**
-   * Whilst the iterator is running, it's possible to abort it. This may be useful
-   * if the word to highlight was updated in the meantime.
-   */
-  maybeAbort() {
-    this.clear();
-    if (!this._abortHighlight) {
-      return;
-    }
-    this._abortHighlight();
-  },
-
-  /**
-   * Uses the iterator in Finder.jsm to find all the words to highlight and makes
-   * sure not to block the thread whilst running.
-   *
-   * @param {String}       word    Needle to search for and highlight when found
-   * @param {nsIDOMWindow} window  Window object, whose DOM tree should be traversed
-   * @param {Function}     onFind  Callback invoked for each found occurrence
-   * @yield {Promise} that resolves once the iterator has finished
-   */
-  iterator: Task.async(function* (word, window, onFind) {
-    let count = 0;
-    for (let range of this.finder._findIterator(word, window)) {
-      onFind(range);
-      if (++count >= kHighlightIterationSizeMax) {
-        count = 0;
-        // Sleep for the rest of this cycle.
-        yield new Promise(resolve => resolve());
-      }
-    }
-  }),
-
-  /**
-   * Toggle highlighting all occurrences of a word in a page. This method will
-   * be called recursively for each (i)frame inside a page.
-   *
-   * @param {Booolean}     highlight Whether highlighting should be turned on
-   * @param {String}       word      Needle to search for and highlight when found
-   * @param {nsIDOMWindow} window    Window object, whose DOM tree should be traversed
-   * @yield {Promise} that resolves once the operation has finished
-   */
-  highlight: Task.async(function* (highlight, word, window) {
-    let finderWindow = this.finder._getWindow();
-    window = window || finderWindow;
-    let found = false;
-    for (let i = 0; window.frames && i < window.frames.length; i++) {
-      if (yield this.highlight(highlight, word, window.frames[i])) {
-        found = true;
-      }
-    }
-
-    let controller = this.finder._getSelectionController(window);
-    let doc = window.document;
-    if (!controller || !doc || !doc.documentElement) {
-      // Without the selection controller,
-      // we are unable to (un)highlight any matches
-      return found;
-    }
-
-    if (highlight) {
-      yield this.iterator(word, window, range => {
-        this.highlightRange(range, controller, finderWindow);
-        found = true;
-      });
-    } else {
-      // First, attempt to remove highlighting from main document
-      let sel = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
-      sel.removeAllRanges();
-
-      this.clear();
-
-      // Next, check our editor cache, for editors belonging to this
-      // document
-      if (this._editors) {
-        for (let x = this._editors.length - 1; x >= 0; --x) {
-          if (this._editors[x].document == doc) {
-            sel = this._editors[x].selectionController
-                                  .getSelection(Ci.nsISelectionController.SELECTION_FIND);
-            sel.removeAllRanges();
-            // We don't need to listen to this editor any more
-            this._unhookListenersAtIndex(x);
-          }
-        }
-      }
-
-      // Removing the highlighting always succeeds, so return true.
-      found = true;
-    }
-
-    return found;
-  }),
-
-  /**
-   * Add a range to the find selection, i.e. highlight it, and if it's inside an
-   * editable node, track it.
-   *
-   * @param {nsIDOMRange}            range      Range object to be highlighted
-   * @param {nsISelectionController} controller Selection controller of the
-   *                                            document that the range belongs
-   *                                            to
-   * @param {nsIDOMWindow}           window     Window object, whose DOM tree
-   *                                            is being traversed
-   */
-  highlightRange(range, controller, window) {
-    let node = range.startContainer;
-    let editableNode = this._getEditableNode(node);
-    if (editableNode) {
-      controller = editableNode.editor.selectionController;
-    }
-
-    if (this._modal) {
-      this._modalHighlight(range, controller, window);
-    } else {
-      let findSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
-      findSelection.addRange(range);
-    }
-
-    if (editableNode) {
-      // Highlighting added, so cache this editor, and hook up listeners
-      // to ensure we deal properly with edits within the highlighting
-      this._addEditorListeners(editableNode.editor);
-    }
-  },
-
-  /**
-   * If modal highlighting is enabled, show the dimmed background that will overlay
-   * the page.
-   *
-   * @param  {nsIDOMWindow} window The dimmed background will overlay this window.
-   *                               Optional, defaults to the finder window.
-   * @return {AnonymousContent}    Reference to the node inserted into the
-   *                               CanvasFrame. It'll also be stored in the
-   *                               `_modalHighlightOutline` member variable.
-   */
-  show(window = null) {
-    if (!this._modal)
-      return null;
-
-    window = window || this.finder._getWindow();
-    let anonNode = this._maybeCreateModalHighlightNodes(window);
-    this._addModalHighlightListeners(window);
-
-    return anonNode;
-  },
-
-  /**
-   * If modal highlighting is enabled and the outline + dimmed background is
-   * currently visible, both will be hidden.
-   */
-  hide(window = null) {
-    if (!this._modal)
-      return;
-
-    if (this._modalHighlightOutline)
-      this._modalHighlightOutline.setAttributeForElement(kModalOutlineId, "hidden", "true");
-
-    window = window || this.finder._getWindow();
-    this._removeHighlightAllMask(window);
-    this._removeModalHighlightListeners(window);
-  },
-
-  /**
-   * Called by the Finder after a find result comes in; update the position and
-   * content of the outline to the newly found occurrence.
-   * To make sure that the outline covers the found range completely, all the
-   * CSS styles that influence the text are copied and applied to the outline.
-   *
-   * @param {Object} data Dictionary coming from Finder that contains the
-   *                      following properties:
-   *   {Number}  result        One of the nsITypeAheadFind.FIND_* constants
-   *                           indicating the result of a search operation.
-   *   {Boolean} findBackwards If TRUE, the search was performed backwards,
-   *                           FALSE if forwards.
-   *   {Boolean} findAgain     If TRUE, the search was performed using the same
-   *                           search string as before.
-   *   {String}  linkURL       If a link was hit, this will contain a URL string.
-   *   {Rect}    rect          An object with top, left, width and height
-   *                           coordinates of the current selection.
-   *   {String}  searchString  The string the search was performed with.
-   *   {Boolean} storeResult   Indicator if the search string should be stored
-   *                           by the consumer of the Finder.
-   */
-  update(data) {
-    if (!this._modal)
-      return;
-
-    // Place the match placeholder on top of the current found range.
-    let foundRange = this.finder._fastFind.getFoundRange();
-    if (data.result == Ci.nsITypeAheadFind.FIND_NOTFOUND || !foundRange) {
-      this.hide();
-      return;
-    }
-
-    let window = this.finder._getWindow();
-    let textContent = this._getRangeContentArray(foundRange);
-    if (!textContent.length) {
-      this.hide(window);
-      return;
-    }
-
-    let rect = foundRange.getBoundingClientRect();
-    let fontStyle = this._getRangeFontStyle(foundRange);
-
-    let anonNode = this.show(window);
-
-    anonNode.setTextContentForElement(kModalOutlineId + "-text", textContent.join(" "));
-    anonNode.setAttributeForElement(kModalOutlineId + "-text", "style",
-      this._getHTMLFontStyle(fontStyle));
-
-    if (typeof anonNode.getAttributeForElement(kModalOutlineId, "hidden") == "string")
-      anonNode.removeAttributeForElement(kModalOutlineId, "hidden");
-    let { scrollX, scrollY } = this._getScrollPosition(window);
-    anonNode.setAttributeForElement(kModalOutlineId, "style",
-      `top: ${scrollY + rect.top}px; left: ${scrollX + rect.left}px`);
-
-    if (typeof anonNode.getAttributeForElement(kModalOutlineId, "grow") == "string")
-      return;
-
-    window.requestAnimationFrame(() => {
-      anonNode.setAttributeForElement(kModalOutlineId, "grow", true);
-      this._listenForOutlineEvent(kModalOutlineId, "transitionend", () => {
-        try {
-          anonNode.removeAttributeForElement(kModalOutlineId, "grow");
-        } catch (ex) {}
-      });
-    });
-  },
-
-  /**
-   * Invalidates the list by clearing the map of highglighted ranges that we
-   * keep to build the mask for.
-   */
-  clear() {
-    if (!this._modal)
-      return;
-
-    // Reset the Map, because no range references a node anymore.
-    if (this._modalHighlightRectsMap)
-      this._modalHighlightRectsMap.clear();
-  },
-
-  /**
-   * When the current page is refreshed or navigated away from, the CanvasFrame
-   * contents is not valid anymore, i.e. all anonymous content is destroyed.
-   * We need to clear the references we keep, which'll make sure we redraw
-   * everything when the user starts to find in page again.
-   */
-  onLocationChange() {
-    if (!this._modalHighlightOutline)
-      return;
-
-    try {
-      this.finder._getWindow().document
-        .removeAnonymousContent(this._modalHighlightOutline);
-    } catch(ex) {}
-
-    this._modalHighlightOutline = null;
-  },
-
-  /**
-   * When `kModalHighlightPref` pref changed during a session, this callback is
-   * invoked. When modal highlighting is turned off, we hide the CanvasFrame
-   * contents.
-   *
-   * @param {Boolean} useModalHighlight
-   */
-  onModalHighlightChange(useModalHighlight) {
-    if (this._modal && !useModalHighlight) {
-      this.hide();
-      this.clear();
-    }
-    this._modal = useModalHighlight;
-  },
-
-  /**
-   * Utility; get the nsIDOMWindowUtils for a window.
-   *
-   * @param  {nsIDOMWindow} window Optional, defaults to the finder window.
-   * @return {nsIDOMWindowUtils}
-   */
-  _getDWU(window = null) {
-    return (window || this.finder._getWindow())
-      .QueryInterface(Ci.nsIInterfaceRequestor)
-      .getInterface(Ci.nsIDOMWindowUtils);
-  },
-
-  /**
-   * Utility; wrapper around nsIDOMWindowUtils#getScrollXY.
-   *
-   * @param  {nsDOMWindow} window Optional, defaults to the finder window.
-   * @return {Object} The current scroll position.
-   */
-  _getScrollPosition(window = null) {
-    let scrollX = {};
-    let scrollY = {};
-    this._getDWU(window).getScrollXY(false, scrollX, scrollY);
-    return {
-      scrollX: scrollX.value,
-      scrollY: scrollY.value
-    };
-  },
-
-  /**
-   * Utility; fetch the full width and height of the current window, excluding
-   * scrollbars.
-   *
-   * @param  {nsiDOMWindow} window The current finder window.
-   * @return {Object} The current full page dimensions with `width` and `height`
-   *                  properties
-   */
-  _getWindowDimensions(window) {
-    let width = window.innerWidth + window.scrollMaxX - window.scrollMinX;
-    let height = window.innerHeight + window.scrollMaxY - window.scrollMinY;
-
-    let scrollbarHeight = {};
-    let scrollbarWidth = {};
-    this._getDWU(window).getScrollbarSize(false, scrollbarWidth, scrollbarHeight);
-    width -= scrollbarWidth.value;
-    height -= scrollbarHeight.value;
-
-    return { width, height };
-  },
-
-  /**
-   * Utility; fetch the current text contents of a given range.
-   *
-   * @param  {nsIDOMRange} range Range object to extract the contents from.
-   * @return {Array} Snippets of text.
-   */
-  _getRangeContentArray(range) {
-    let content = range.cloneContents();
-    let t, textContent = [];
-    for (let node of content.childNodes) {
-      t = node.textContent || node.nodeValue;
-      //if (t && t.trim())
-        textContent.push(t);
-    }
-    return textContent;
-  },
-
-  /**
-   * Utility; get all available font styles as applied to the content of a given
-   * range. The CSS properties we look for can be found in `kFontPropsCSS`.
-   *
-   * @param  {nsIDOMRange} range Range to fetch style info from.
-   * @return {Object} Dictionary consisting of the styles that were found.
-   */
-  _getRangeFontStyle(range) {
-    let node = range.startContainer;
-    while (node.nodeType != 1)
-      node = node.parentNode;
-    let style = node.ownerDocument.defaultView.getComputedStyle(node, "");
-    let props = {};
-    for (let prop of kFontPropsCamelCase) {
-      if (prop in style && style[prop])
-        props[prop] = style[prop];
-    }
-    return props;
-  },
-
-  /**
-   * Utility; transform a dictionary object as returned by `_getRangeFontStyle`
-   * above into a HTML style attribute value.
-   *
-   * @param  {Object} fontStyle
-   * @return {String}
-   */
-  _getHTMLFontStyle(fontStyle) {
-    let style = [];
-    for (let prop of Object.getOwnPropertyNames(fontStyle)) {
-      let idx = kFontPropsCamelCase.indexOf(prop);
-      if (idx == -1)
-        continue
-      style.push(`${kFontPropsCSS[idx]}: ${fontStyle[prop]};`);
-    }
-    return style.join(" ");
-  },
-
-  /**
-   * Add a range to the list of ranges to highlight on, or cut out of, the dimmed
-   * background.
-   *
-   * @param {nsIDOMRange}  range  Range object that should be inspected
-   * @param {nsIDOMWindow} window Window object, whose DOM tree is being traversed
-   */
-  _modalHighlight(range, controller, window) {
-    if (!this._getRangeContentArray(range).length)
-      return;
-
-    let rects = new Set();
-    // Absolute positions should include the viewport scroll offset.
-    let { scrollX, scrollY } = this._getScrollPosition(window);
-    // A range may consist of multiple rectangles, but since we're cutting them
-    // out using SVG we can also do these kind of precise cut-outs.
-    // range.getBoundingClientRect() returns the fully encompassing rectangle,
-    // which is too much for our purpose here.
-    for (let dims of range.getClientRects()) {
-      rects.add({
-        height: dims.bottom - dims.top,
-        width: dims.right - dims.left,
-        y: dims.top + scrollY,
-        x: dims.left + scrollX
-      });
-    }
-    range.collapse();
-
-    if (!this._modalHighlightRectsMap)
-      this._modalHighlightRectsMap = new Map();
-    this._modalHighlightRectsMap.set(range, rects);
-
-    this.show(window);
-    // We don't repaint the mask right away, but pass it off to a render loop of
-    // sorts.
-    this._scheduleRepaintOfMask(window);
-  },
-
-  /**
-   * Lazily insert the nodes we need as anonymous content into the CanvasFrame
-   * of a window.
-   *
-   * @param  {nsIDOMWindow} window Window to draw in.
-   * @return {AnonymousContent} The reference to the outline node, NOT the mask.
-   */
-  _maybeCreateModalHighlightNodes(window) {
-    if (this._modalHighlightOutline) {
-      if (!this._modalHighlightAllMask)
-        this._repaintHighlightAllMask(window);
-      return this._modalHighlightOutline;
-    }
-
-    let document = window.document;
-    // A hidden document doesn't accept insertAnonymousContent calls yet.
-    if (document.hidden) {
-      let onVisibilityChange = () => {
-        document.removeEventListener("visibilitychange", onVisibilityChange);
-        this._maybeCreateModalHighlightNodes(window);
-      };
-      document.addEventListener("visibilitychange", onVisibilityChange);
-      return null;
-    }
-
-    this._maybeInstallStyleSheet(window);
-
-    // The outline needs to be sitting inside a container, otherwise the anonymous
-    // content API won't find it by its ID later...
-    let container = document.createElement("div");
-
-    // Create the main (yellow) highlight outline box.
-    let outlineBox = document.createElement("div");
-    outlineBox.setAttribute("id", kModalOutlineId);
-    outlineBox.className = kModalOutlineId;
-    let outlineBoxText = document.createElement("span");
-    outlineBoxText.setAttribute("id", kModalOutlineId + "-text");
-    outlineBox.appendChild(outlineBoxText);
-
-    container.appendChild(outlineBox);
-
-    this._repaintHighlightAllMask(window);
-
-    this._modalHighlightOutline = document.insertAnonymousContent(container);
-    return this._modalHighlightOutline;
-  },
-
-  /**
-   * Build and draw the SVG mask that takes care of the dimmed background that
-   * overlays the current page and the mask that cuts out all the rectangles of
-   * the ranges that were found.
-   *
-   * @param {nsIDOMWindow} window Window to draw in.
-   */
-  _repaintHighlightAllMask(window) {
-    let document = window.document;
-
-    const kMaskId = kModalIdPrefix + "-findbar-modalHighlight-outlineMask";
-    let svgNode = document.createElementNS(kSVGNS, "svg");
-    // Make sure the SVG drawing takes the full width and height that's available.
-    let {width, height} = this._getWindowDimensions(window);
-    svgNode.setAttribute("viewBox", "0 0 " + width + " " + height);
-
-    // The mask functions as a sort of inverse clip-path: instead of defining
-    // what to draw where, we need to do the opposite. We want the rectangles for
-    // each found range to be cut out of the dimmed-black background. That's why
-    // the mask is a full white large rectangle with small black rectangles that
-    // specifies where to let color bleed through and how much.
-    let svgContent = [`<mask id="${kMaskId}">
-      <rect x="0" y="0" height="${height}" width="${width}" fill="white"/>`];
-
-    if (this._modalHighlightRectsMap) {
-      for (let rects of this._modalHighlightRectsMap.values()) {
-        for (let rect of rects) {
-          // The #666 stroke works to create the effect of blurred edges.
-          svgContent.push(`<rect x="${rect.x}" y="${rect.y}"
-            height="${rect.height}" width="${rect.width}"
-            style="fill: #000; stroke-width: 1; stroke: #666"/>`);
-        }
-      }
-    }
-
-    // The big black opaque rectangle to which the mask is applied.
-    svgNode.innerHTML = svgContent.join("") + `</mask>
-      <rect x="0" y="0" height="${height}" width="${width}" fill="rgba(0,0,0,.2)"
-            mask="url(#${kMaskId})"/>`;
-
-    // Always remove the current mask and insert it a-fresh, because we're not
-    // free to alter DOM nodes inside the CanvasFrame.
-    this._removeHighlightAllMask(window);
-
-    this._modalHighlightAllMask = document.insertAnonymousContent(svgNode);
-  },
-
-  /**
-   * Safely remove the mask AnoymousContent node from the CanvasFrame.
-   *
-   * @param {nsIDOMWindow} window
-   */
-  _removeHighlightAllMask(window) {
-    if (this._modalHighlightAllMask) {
-      // If the current window isn't the one the content was inserted into, this
-      // will fail, but that's fine.
-      try {
-        window.document.removeAnonymousContent(this._modalHighlightAllMask);
-      } catch(ex) {}
-      this._modalHighlightAllMask = null;
-    }
-  },
-
-  /**
-   * Doing a full repaint each time a range is delivered by the highlight iterator
-   * is way too costly, thus we pipe the frequency down to every
-   * `kModalHighlightRepaintFreqMs` milliseconds.
-   *
-   * @param {nsIDOMWindow} window
-   */
-  _scheduleRepaintOfMask(window) {
-    if (this._modalRepaintScheduler)
-      window.clearTimeout(this._modalRepaintScheduler);
-    this._modalRepaintScheduler = window.setTimeout(
-      this._repaintHighlightAllMask.bind(this, window), kModalHighlightRepaintFreqMs);
-  },
-
-  /**
-   * The outline that shows/ highlights the current found range is styled and
-   * animated using CSS. This style can be found in `kModalStyle`, but to have it
-   * applied on any DOM node we insert using the AnonymousContent API we need to
-   * inject an agent sheet into the document.
-   *
-   * @param {nsIDOMWindow} window
-   */
-  _maybeInstallStyleSheet(window) {
-    let document = window.document;
-    // The WeakMap is a cheap method to make sure we don't needlessly insert the
-    // same sheet twice.
-    if (!this._modalInstalledSheets)
-      this._modalInstalledSheets = new WeakMap();
-    if (this._modalInstalledSheets.has(document))
-      return;
-
-    let dwu = this._getDWU(window);
-    let uri = this.modalStyleSheetURI;
-    try {
-      dwu.loadSheetUsingURIString(uri, dwu.AGENT_SHEET);
-    } catch (e) {}
-    this._modalInstalledSheets.set(document, uri);
-  },
-
-  /**
-   * One can not simply listen to events on a specific AnonymousContent node.
-   * That's why we need to listen on the chromeEventHandler instead and check if
-   * the IDs match of the event target.
-   * IMPORTANT: once the event was fired on the specified element and the handler
-   *            invoked, we remove the event listener right away. That's because
-   *            we don't need more in this class.
-   *
-   * @param {String}   elementId Identifier of the element we expect the event from.
-   * @param {String}   eventName Name of the event to start listening for.
-   * @param {Function} handler   Function to invoke when we detected the event
-   *                             on the designated node.
-   */
-  _listenForOutlineEvent(elementId, eventName, handler) {
-    let target = this.finder._docShell.chromeEventHandler;
-    target.addEventListener(eventName, function onEvent(event) {
-      // Start at originalTarget, bubble through ancestors and call handlers when
-      // needed.
-      let node = event.originalTarget;
-      while (node) {
-        if (node.id == elementId) {
-          handler();
-          target.removeEventListener(eventName, onEvent);
-          break;
-        }
-        node = node.parentNode;
-      }
-    });
-  },
-
-  /**
-   * Add event listeners to the content which will cause the modal highlight
-   * AnonymousContent to be re-painted or hidden.
-   *
-   * @param {nsIDOMWindow} window
-   */
-  _addModalHighlightListeners(window) {
-    if (this._highlightListeners)
-      return;
-
-    this._highlightListeners = [
-      this._scheduleRepaintOfMask.bind(this, window),
-      this.hide.bind(this, window)
-    ];
-    window.addEventListener("DOMContentLoaded", this._highlightListeners[0]);
-    window.addEventListener("mousedown", this._highlightListeners[1]);
-    window.addEventListener("resize", this._highlightListeners[1]);
-    window.addEventListener("touchstart", this._highlightListeners[1]);
-  },
-
-  /**
-   * Remove event listeners from content.
-   *
-   * @param {nsIDOMWindow} window
-   */
-  _removeModalHighlightListeners(window) {
-    if (!this._highlightListeners)
-      return;
-
-    window.removeEventListener("DOMContentLoaded", this._highlightListeners[0]);
-    window.removeEventListener("mousedown", this._highlightListeners[1]);
-    window.removeEventListener("resize", this._highlightListeners[1]);
-    window.removeEventListener("touchstart", this._highlightListeners[1]);
-
-    this._highlightListeners = null;
-  },
-
-  /**
-   * For a given node returns its editable parent or null if there is none.
-   * It's enough to check if node is a text node and its parent's parent is
-   * instance of nsIDOMNSEditableElement.
-   *
-   * @param node the node we want to check
-   * @returns the first node in the parent chain that is editable,
-   *          null if there is no such node
-   */
-  _getEditableNode(node) {
-    if (node.nodeType === node.TEXT_NODE && node.parentNode && node.parentNode.parentNode &&
-        node.parentNode.parentNode instanceof Ci.nsIDOMNSEditableElement) {
-      return node.parentNode.parentNode;
-    }
-    return null;
-  },
-
-  /**
-   * Add ourselves as an nsIEditActionListener and nsIDocumentStateListener for
-   * a given editor
-   *
-   * @param editor the editor we'd like to listen to
-   */
-  _addEditorListeners(editor) {
-    if (!this._editors) {
-      this._editors = [];
-      this._stateListeners = [];
-    }
-
-    let existingIndex = this._editors.indexOf(editor);
-    if (existingIndex == -1) {
-      let x = this._editors.length;
-      this._editors[x] = editor;
-      this._stateListeners[x] = this._createStateListener();
-      this._editors[x].addEditActionListener(this);
-      this._editors[x].addDocumentStateListener(this._stateListeners[x]);
-    }
-  },
-
-  /**
-   * Helper method to unhook listeners, remove cached editors
-   * and keep the relevant arrays in sync
-   *
-   * @param idx the index into the array of editors/state listeners
-   *        we wish to remove
-   */
-  _unhookListenersAtIndex(idx) {
-    this._editors[idx].removeEditActionListener(this);
-    this._editors[idx]
-        .removeDocumentStateListener(this._stateListeners[idx]);
-    this._editors.splice(idx, 1);
-    this._stateListeners.splice(idx, 1);
-    if (!this._editors.length) {
-      delete this._editors;
-      delete this._stateListeners;
-    }
-  },
-
-  /**
-   * Remove ourselves as an nsIEditActionListener and
-   * nsIDocumentStateListener from a given cached editor
-   *
-   * @param editor the editor we no longer wish to listen to
-   */
-  _removeEditorListeners(editor) {
-    // editor is an editor that we listen to, so therefore must be
-    // cached. Find the index of this editor
-    let idx = this._editors.indexOf(editor);
-    if (idx == -1) {
-      return;
-    }
-    // Now unhook ourselves, and remove our cached copy
-    this._unhookListenersAtIndex(idx);
-  },
-
-  /*
-   * nsIEditActionListener logic follows
-   *
-   * We implement this interface to allow us to catch the case where
-   * the findbar found a match in a HTML <input> or <textarea>. If the
-   * user adjusts the text in some way, it will no longer match, so we
-   * want to remove the highlight, rather than have it expand/contract
-   * when letters are added or removed.
-   */
-
-  /**
-   * Helper method used to check whether a selection intersects with
-   * some highlighting
-   *
-   * @param selectionRange the range from the selection to check
-   * @param findRange the highlighted range to check against
-   * @returns true if they intersect, false otherwise
-   */
-  _checkOverlap(selectionRange, findRange) {
-    // The ranges overlap if one of the following is true:
-    // 1) At least one of the endpoints of the deleted selection
-    //    is in the find selection
-    // 2) At least one of the endpoints of the find selection
-    //    is in the deleted selection
-    if (findRange.isPointInRange(selectionRange.startContainer,
-                                 selectionRange.startOffset))
-      return true;
-    if (findRange.isPointInRange(selectionRange.endContainer,
-                                 selectionRange.endOffset))
-      return true;
-    if (selectionRange.isPointInRange(findRange.startContainer,
-                                      findRange.startOffset))
-      return true;
-    if (selectionRange.isPointInRange(findRange.endContainer,
-                                      findRange.endOffset))
-      return true;
-
-    return false;
-  },
-
-  /**
-   * Helper method to determine if an edit occurred within a highlight
-   *
-   * @param selection the selection we wish to check
-   * @param node the node we want to check is contained in selection
-   * @param offset the offset into node that we want to check
-   * @returns the range containing (node, offset) or null if no ranges
-   *          in the selection contain it
-   */
-  _findRange(selection, node, offset) {
-    let rangeCount = selection.rangeCount;
-    let rangeidx = 0;
-    let foundContainingRange = false;
-    let range = null;
-
-    // Check to see if this node is inside one of the selection's ranges
-    while (!foundContainingRange && rangeidx < rangeCount) {
-      range = selection.getRangeAt(rangeidx);
-      if (range.isPointInRange(node, offset)) {
-        foundContainingRange = true;
-        break;
-      }
-      rangeidx++;
-    }
-
-    if (foundContainingRange) {
-      return range;
-    }
-
-    return null;
-  },
-
-  // Start of nsIEditActionListener implementations
-
-  WillDeleteText(textNode, offset, length) {
-    let editor = this._getEditableNode(textNode).editor;
-    let controller = editor.selectionController;
-    let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
-    let range = this._findRange(fSelection, textNode, offset);
-
-    if (range) {
-      // Don't remove the highlighting if the deleted text is at the
-      // end of the range
-      if (textNode != range.endContainer ||
-          offset != range.endOffset) {
-        // Text within the highlight is being removed - the text can
-        // no longer be a match, so remove the highlighting
-        fSelection.removeRange(range);
-        if (fSelection.rangeCount == 0) {
-          this._removeEditorListeners(editor);
-        }
-      }
-    }
-  },
-
-  DidInsertText(textNode, offset, aString) {
-    let editor = this._getEditableNode(textNode).editor;
-    let controller = editor.selectionController;
-    let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
-    let range = this._findRange(fSelection, textNode, offset);
-
-    if (range) {
-      // If the text was inserted before the highlight
-      // adjust the highlight's bounds accordingly
-      if (textNode == range.startContainer &&
-          offset == range.startOffset) {
-        range.setStart(range.startContainer,
-                       range.startOffset+aString.length);
-      } else if (textNode != range.endContainer ||
-                 offset != range.endOffset) {
-        // The edit occurred within the highlight - any addition of text
-        // will result in the text no longer being a match,
-        // so remove the highlighting
-        fSelection.removeRange(range);
-        if (fSelection.rangeCount == 0) {
-          this._removeEditorListeners(editor);
-        }
-      }
-    }
-  },
-
-  WillDeleteSelection(selection) {
-    let editor = this._getEditableNode(selection.getRangeAt(0)
-                                                 .startContainer).editor;
-    let controller = editor.selectionController;
-    let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
-
-    let selectionIndex = 0;
-    let findSelectionIndex = 0;
-    let shouldDelete = {};
-    let numberOfDeletedSelections = 0;
-    let numberOfMatches = fSelection.rangeCount;
-
-    // We need to test if any ranges in the deleted selection (selection)
-    // are in any of the ranges of the find selection
-    // Usually both selections will only contain one range, however
-    // either may contain more than one.
-
-    for (let fIndex = 0; fIndex < numberOfMatches; fIndex++) {
-      shouldDelete[fIndex] = false;
-      let fRange = fSelection.getRangeAt(fIndex);
-
-      for (let index = 0; index < selection.rangeCount; index++) {
-        if (shouldDelete[fIndex]) {
-          continue;
-        }
-
-        let selRange = selection.getRangeAt(index);
-        let doesOverlap = this._checkOverlap(selRange, fRange);
-        if (doesOverlap) {
-          shouldDelete[fIndex] = true;
-          numberOfDeletedSelections++;
-        }
-      }
-    }
-
-    // OK, so now we know what matches (if any) are in the selection
-    // that is being deleted. Time to remove them.
-    if (!numberOfDeletedSelections) {
-      return;
-    }
-
-    for (let i = numberOfMatches - 1; i >= 0; i--) {
-      if (shouldDelete[i])
-        fSelection.removeRange(fSelection.getRangeAt(i));
-    }
-
-    // Remove listeners if no more highlights left
-    if (!fSelection.rangeCount) {
-      this._removeEditorListeners(editor);
-    }
-  },
-
-  /*
-   * nsIDocumentStateListener logic follows
-   *
-   * When attaching nsIEditActionListeners, there are no guarantees
-   * as to whether the findbar or the documents in the browser will get
-   * destructed first. This leads to the potential to either leak, or to
-   * hold on to a reference an editable element's editor for too long,
-   * preventing it from being destructed.
-   *
-   * However, when an editor's owning node is being destroyed, the editor
-   * sends out a DocumentWillBeDestroyed notification. We can use this to
-   * clean up our references to the object, to allow it to be destroyed in a
-   * timely fashion.
-   */
-
-  /**
-   * Unhook ourselves when one of our state listeners has been called.
-   * This can happen in 4 cases:
-   *  1) The document the editor belongs to is navigated away from, and
-   *     the document is not being cached
-   *
-   *  2) The document the editor belongs to is expired from the cache
-   *
-   *  3) The tab containing the owning document is closed
-   *
-   *  4) The <input> or <textarea> that owns the editor is explicitly
-   *     removed from the DOM
-   *
-   * @param the listener that was invoked
-   */
-  _onEditorDestruction(aListener) {
-    // First find the index of the editor the given listener listens to.
-    // The listeners and editors arrays must always be in sync.
-    // The listener will be in our array of cached listeners, as this
-    // method could not have been called otherwise.
-    let idx = 0;
-    while (this._stateListeners[idx] != aListener) {
-      idx++;
-    }
-
-    // Unhook both listeners
-    this._unhookListenersAtIndex(idx);
-  },
-
-  /**
-   * Creates a unique document state listener for an editor.
-   *
-   * It is not possible to simply have the findbar implement the
-   * listener interface itself, as it wouldn't have sufficient information
-   * to work out which editor was being destroyed. Therefore, we create new
-   * listeners on the fly, and cache them in sync with the editors they
-   * listen to.
-   */
-  _createStateListener() {
-    return {
-      findbar: this,
-
-      QueryInterface: function(iid) {
-        if (iid.equals(Ci.nsIDocumentStateListener) ||
-            iid.equals(Ci.nsISupports))
-          return this;
-
-        throw Components.results.NS_ERROR_NO_INTERFACE;
-      },
-
-      NotifyDocumentWillBeDestroyed: function() {
-        this.findbar._onEditorDestruction(this);
-      },
-
-      // Unimplemented
-      notifyDocumentCreated: function() {},
-      notifyDocumentStateChanged: function(aDirty) {}
-    };
-  }
-};
diff --git a/toolkit/modules/RemoteFinder.jsm b/toolkit/modules/RemoteFinder.jsm
index 3b851336279c..0d74cc2e8dca 100644
--- a/toolkit/modules/RemoteFinder.jsm
+++ b/toolkit/modules/RemoteFinder.jsm
@@ -26,18 +26,6 @@ function RemoteFinder(browser) {
 }
 
 RemoteFinder.prototype = {
-  destroy() {
-    this._browser.messageManager.sendAsyncMessage("Finder:Destroy");
-    if (this._messageManager) {
-      this._messageManager.removeMessageListener("Finder:Result", this);
-      this._messageManager.removeMessageListener("Finder:MatchesResult", this);
-      this._messageManager.removeMessageListener("Finder:CurrentSelectionResult",this);
-      this._messageManager.removeMessageListener("Finder:HighlightFinished",this);
-    }
-    this._listeners.clear();
-    this._browser = this._messageManager = null;
-  },
-
   swapBrowser: function(aBrowser) {
     if (this._messageManager) {
       this._messageManager.removeMessageListener("Finder:Result", this);
@@ -175,16 +163,6 @@ RemoteFinder.prototype = {
     this._browser.messageManager.sendAsyncMessage("Finder:FocusContent");
   },
 
-  onFindbarClose: function () {
-    this._browser.messageManager.sendAsyncMessage("Finder:FindbarClose");
-  },
-
-  onModalHighlightChange: function(aUseModalHighlight) {
-    this._browser.messageManager.sendAsyncMessage("Finder:ModalHighlightChange", {
-      useModalHighlight: aUseModalHighlight
-    });
-  },
-
   keyPress: function (aEvent) {
     this._browser.messageManager.sendAsyncMessage("Finder:KeyPress",
                                                   { keyCode: aEvent.keyCode,
@@ -216,7 +194,6 @@ function RemoteFinderListener(global) {
 RemoteFinderListener.prototype = {
   MESSAGES: [
     "Finder:CaseSensitive",
-    "Finder:Destroy",
     "Finder:FastFind",
     "Finder:FindAgain",
     "Finder:SetSearchStringToSelection",
@@ -225,10 +202,8 @@ RemoteFinderListener.prototype = {
     "Finder:EnableSelection",
     "Finder:RemoveSelection",
     "Finder:FocusContent",
-    "Finder:FindbarClose",
     "Finder:KeyPress",
-    "Finder:MatchesCount",
-    "Finder:ModalHighlightChange"
+    "Finder:MatchesCount"
   ],
 
   onFindResult: function (aData) {
@@ -249,10 +224,6 @@ RemoteFinderListener.prototype = {
     let data = aMessage.data;
 
     switch (aMessage.name) {
-      case "Finder:Destroy":
-        this._finder.destroy();
-        break;
-
       case "Finder:CaseSensitive":
         this._finder.caseSensitive = data.caseSensitive;
         break;
@@ -297,10 +268,6 @@ RemoteFinderListener.prototype = {
         this._finder.focusContent();
         break;
 
-      case "Finder:FindbarClose":
-        this._finder.onFindbarClose();
-        break;
-
       case "Finder:KeyPress":
         this._finder.keyPress(data);
         break;
@@ -308,10 +275,6 @@ RemoteFinderListener.prototype = {
       case "Finder:MatchesCount":
         this._finder.requestMatchesCount(data.searchString, data.matchLimit, data.linksOnly);
         break;
-
-      case "Finder:ModalHighlightChange":
-        this._finder.ModalHighlightChange(data.useModalHighlight);
-        break;
     }
   }
 };
diff --git a/toolkit/modules/moz.build b/toolkit/modules/moz.build
index 749cc723dee6..563b9b90035b 100644
--- a/toolkit/modules/moz.build
+++ b/toolkit/modules/moz.build
@@ -38,7 +38,6 @@ EXTRA_JS_MODULES += [
     'Deprecated.jsm',
     'FileUtils.jsm',
     'Finder.jsm',
-    'FinderHighlighter.jsm',
     'Geometry.jsm',
     'GMPInstallManager.jsm',
     'GMPUtils.jsm',
diff --git a/toolkit/modules/tests/browser/browser.ini b/toolkit/modules/tests/browser/browser.ini
index 25356454de18..04f40c4ddec7 100644
--- a/toolkit/modules/tests/browser/browser.ini
+++ b/toolkit/modules/tests/browser/browser.ini
@@ -26,8 +26,6 @@ support-files =
 [browser_Deprecated.js]
 [browser_Finder.js]
 [browser_Finder_hidden_textarea.js]
-[browser_FinderHighlighter.js]
-skip-if = debug
 [browser_Geometry.js]
 [browser_InlineSpellChecker.js]
 [browser_WebNavigation.js]
diff --git a/toolkit/modules/tests/browser/browser_FinderHighlighter.js b/toolkit/modules/tests/browser/browser_FinderHighlighter.js
deleted file mode 100644
index be318fc74134..000000000000
--- a/toolkit/modules/tests/browser/browser_FinderHighlighter.js
+++ /dev/null
@@ -1,188 +0,0 @@
-"use strict";
-
-Cu.import("resource://testing-common/BrowserTestUtils.jsm", this);
-Cu.import("resource://testing-common/ContentTask.jsm", this);
-Cu.import("resource://gre/modules/Promise.jsm", this);
-Cu.import("resource://gre/modules/Task.jsm", this);
-Cu.import("resource://gre/modules/AppConstants.jsm");
-
-const kPrefModalHighlight = "findbar.modalHighlight";
-
-function promiseOpenFindbar(findbar) {
-  findbar.onFindCommand()
-  return gFindBar._startFindDeferred && gFindBar._startFindDeferred.promise;
-}
-
-function promiseFindResult(findbar, str = null) {
-  return new Promise(resolve => {
-    let listener = {
-      onFindResult: function({ searchString }) {
-        if (str !== null && str != searchString) {
-          return;
-        }
-        findbar.browser.finder.removeResultListener(listener);
-        resolve();
-      }
-    };
-    findbar.browser.finder.addResultListener(listener);
-  });
-}
-
-function promiseEnterStringIntoFindField(findbar, str) {
-  let promise = promiseFindResult(findbar, str);
-  for (let i = 0; i < str.length; i++) {
-    let event = document.createEvent("KeyEvents");
-    event.initKeyEvent("keypress", true, true, null, false, false,
-                       false, false, 0, str.charCodeAt(i));
-    findbar._findField.inputField.dispatchEvent(event);
-  }
-  return promise;
-}
-
-function promiseTestHighlighterOutput(browser, word, expectedResult) {
-  return ContentTask.spawn(browser, { word, expectedResult }, function* ({ word, expectedResult }) {
-    let document = content.document;
-
-    return new Promise((resolve, reject) => {
-      let stubbed = [document.insertAnonymousContent,
-        document.removeAnonymousContent];
-      let callCounts = {
-        insertCalls: [],
-        removeCalls: []
-      };
-
-      // Amount of milliseconds to wait after the last time one of our stubs
-      // was called.
-      const kTimeoutMs = 500;
-      // The initial timeout may wait for a while for results to come in.
-      let timeout = content.setTimeout(finish, kTimeoutMs * 4);
-
-      function finish(ok = true, message) {
-        // Restore the functions we stubbed out.
-        document.insertAnonymousContent = stubbed[0];
-        document.removeAnonymousContent = stubbed[1];
-        content.clearTimeout(timeout);
-
-        Assert.equal(callCounts.insertCalls.length, expectedResult.insertCalls,
-          `Insert calls should match for '${word}'.`);
-        Assert.equal(callCounts.removeCalls.length, expectedResult.removeCalls,
-          `Remove calls should match for '${word}'.`);
-
-        // We reached the amount of calls we expected, so now we can check
-        // the amount of rects.
-        let lastSVGNode = callCounts.insertCalls.pop();
-        if (!lastSVGNode && expectedResult.rectCount !== 0) {
-          Assert.ok(false, `No SVG node found, but expected ${expectedResult.rectCount} rects.`);
-        }
-        if (lastSVGNode) {
-          Assert.equal(lastSVGNode.getElementsByTagName("mask")[0]
-            .getElementsByTagName("rect").length, expectedResult.rectCount,
-            `Amount of inserted rects should match for '${word}'.`);
-        }
-
-        resolve();
-      }
-
-      // Create a function that will stub the original version and collects
-      // the arguments so we can check the results later.
-      function stub(which) {
-        let prop = which + "Calls";
-        return function(node) {
-          callCounts[prop].push(node);
-          content.clearTimeout(timeout);
-          timeout = content.setTimeout(finish, kTimeoutMs);
-          return node;
-        };
-      }
-      document.insertAnonymousContent = stub("insert");
-      document.removeAnonymousContent = stub("remove");
-    });
-  });
-}
-
-add_task(function* setup() {
-  yield SpecialPowers.pushPrefEnv({ set: [
-    ["findbar.highlightAll", true],
-    ["findbar.modalHighlight", true]
-  ]});
-});
-
-// Test the results of modal highlighting, which is on by default.
-add_task(function* testModalResults() {
-  let tests = new Map([
-    ["mo", {
-      rectCount: 5,
-      insertCalls: 2,
-      removeCalls: AppConstants.platform == "linux" ? 1 : 2
-    }],
-    ["m", {
-      rectCount: 9,
-      insertCalls: 1,
-      removeCalls: 1
-    }],
-    ["new", {
-      rectCount: 2,
-      insertCalls: 1,
-      removeCalls: 1
-    }],
-    ["o", {
-      rectCount: 1218,
-      insertCalls: 1,
-      removeCalls: 1
-    }]
-  ]);
-  yield BrowserTestUtils.withNewTab("about:mozilla", function* (browser) {
-    // We're inserting 1200 additional o's at the end of the document.
-    yield ContentTask.spawn(browser, null, function* () {
-      let document = content.document;
-      document.getElementsByTagName("section")[0].innerHTML += "<p>" +
-        (new Array(1200).join(" o ")) + "</p>";
-    });
-
-    let findbar = gBrowser.getFindBar();
-
-    for (let [word, expectedResult] of tests) {
-      yield promiseOpenFindbar(findbar);
-      Assert.ok(!findbar.hidden, "Findbar should be open now.");
-
-      let promise = promiseTestHighlighterOutput(browser, word, expectedResult);
-      yield promiseEnterStringIntoFindField(findbar, word);
-      yield promise;
-
-      findbar.close();
-    }
-  });
-});
-
-// Test if runtime switching of highlight modes between modal and non-modal works
-// as expected.
-add_task(function* testModalSwitching() {
-  yield BrowserTestUtils.withNewTab("about:mozilla", function* (browser) {
-    let findbar = gBrowser.getFindBar();
-
-    yield promiseOpenFindbar(findbar);
-    Assert.ok(!findbar.hidden, "Findbar should be open now.");
-
-    let word = "mo";
-    let expectedResult = {
-      rectCount: 5,
-      insertCalls: 2,
-      removeCalls: AppConstants.platform == "linux" ? 1 : 2
-    };
-    let promise = promiseTestHighlighterOutput(browser, word, expectedResult);
-    yield promiseEnterStringIntoFindField(findbar, word);
-    yield promise;
-
-    yield SpecialPowers.pushPrefEnv({ "set": [[ kPrefModalHighlight, false ]] });
-
-    expectedResult = {
-      rectCount: 0,
-      insertCalls: 0,
-      removeCalls: 0
-    };
-    promise = promiseTestHighlighterOutput(browser, word, expectedResult);
-    findbar.clear();
-    yield promiseEnterStringIntoFindField(findbar, word);
-    yield promise;
-  });
-});
diff --git a/widget/nsXPLookAndFeel.cpp b/widget/nsXPLookAndFeel.cpp
index c714cdb5ab64..a9e542c1235a 100644
--- a/widget/nsXPLookAndFeel.cpp
+++ b/widget/nsXPLookAndFeel.cpp
@@ -247,7 +247,6 @@ int32_t nsXPLookAndFeel::sCachedColorBits[COLOR_CACHE_SIZE] = {0};
 bool nsXPLookAndFeel::sInitialized = false;
 bool nsXPLookAndFeel::sUseNativeColors = true;
 bool nsXPLookAndFeel::sUseStandinsForNativeColors = false;
-bool nsXPLookAndFeel::sFindbarModalHighlight = false;
 
 nsLookAndFeel* nsXPLookAndFeel::sInstance = nullptr;
 bool nsXPLookAndFeel::sShutdown = false;
@@ -466,9 +465,6 @@ nsXPLookAndFeel::Init()
   Preferences::AddBoolVarCache(&sUseStandinsForNativeColors,
                                "ui.use_standins_for_native_colors",
                                sUseStandinsForNativeColors);
-  Preferences::AddBoolVarCache(&sFindbarModalHighlight,
-                               "findbar.modalHighlight",
-                               sFindbarModalHighlight);
 
   if (XRE_IsContentProcess()) {
     mozilla::dom::ContentChild* cc =
@@ -777,11 +773,6 @@ nsXPLookAndFeel::GetColorImpl(ColorID aID, bool aUseStandinsForNativeColors,
   }
 
   if (aID == eColorID_TextSelectBackgroundAttention) {
-    if (sFindbarModalHighlight) {
-      aResult = NS_RGBA(0, 0, 0, 0);
-      return NS_OK;
-    }
-
     // This makes the selection stand out when typeaheadfind is on
     // Used with nsISelectionController::SELECTION_ATTENTION
     aResult = NS_RGB(0x38, 0xd8, 0x78);
diff --git a/widget/nsXPLookAndFeel.h b/widget/nsXPLookAndFeel.h
index 331363f76ba4..0b8a308fb34a 100644
--- a/widget/nsXPLookAndFeel.h
+++ b/widget/nsXPLookAndFeel.h
@@ -111,7 +111,6 @@ protected:
   static int32_t sCachedColorBits[COLOR_CACHE_SIZE];
   static bool sUseNativeColors;
   static bool sUseStandinsForNativeColors;
-  static bool sFindbarModalHighlight;
 
   static nsLookAndFeel* sInstance;
   static bool sShutdown;