The Tor Browser: toolkit/modules/Finder.jsm@6474c204b198 (annotated)

toolkit/modules/Finder.jsm@6474c204b198 (annotated)

toolkit/modules/Finder.jsm

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // 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/.
 this.EXPORTED_SYMBOLS = ["Finder"];
 const Ci = Components.interfaces;
 const Cc = Components.classes;
 const Cu = Components.utils;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Geometry.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "TextToSubURIService",
                                          "@mozilla.org/intl/texttosuburi;1",
                                          "nsITextToSubURI");
 XPCOMUtils.defineLazyServiceGetter(this, "Clipboard",
                                          "@mozilla.org/widget/clipboard;1",
                                          "nsIClipboard");
 XPCOMUtils.defineLazyServiceGetter(this, "ClipboardHelper",
                                          "@mozilla.org/widget/clipboardhelper;1",
                                          "nsIClipboardHelper");
 function Finder(docShell) {
   this._fastFind = Cc["@mozilla.org/typeaheadfind;1"].createInstance(Ci.nsITypeAheadFind);
   this._fastFind.init(docShell);
   this._docShell = docShell;
   this._listeners = [];
   this._previousLink = null;
   this._searchString = null;
   docShell.QueryInterface(Ci.nsIInterfaceRequestor)
           .getInterface(Ci.nsIWebProgress)
           .addProgressListener(this, Ci.nsIWebProgress.NOTIFY_LOCATION);
 }
 Finder.prototype = {
   addResultListener: function (aListener) {
     if (this._listeners.indexOf(aListener) === -1)
       this._listeners.push(aListener);
   },
   removeResultListener: function (aListener) {
     this._listeners = this._listeners.filter(l => l != aListener);
   },
   _notify: function (aSearchString, aResult, aFindBackwards, aDrawOutline, aStoreResult = true) {
     if (aStoreResult) {
       this._searchString = aSearchString;
       this.clipboardSearchString = aSearchString
     }
     this._outlineLink(aDrawOutline);
     let foundLink = this._fastFind.foundLink;
     let linkURL = null;
     if (foundLink) {
       let docCharset = null;
       let ownerDoc = foundLink.ownerDocument;
       if (ownerDoc)
         docCharset = ownerDoc.characterSet;
       linkURL = TextToSubURIService.unEscapeURIForUI(docCharset, foundLink.href);
     }
     let data = {
       result: aResult,
       findBackwards: aFindBackwards,
       linkURL: linkURL,
       rect: this._getResultRect(),
       searchString: this._searchString,
       storeResult: aStoreResult
     };
     for (let l of this._listeners) {
       l.onFindResult(data);
     }
   },
   get searchString() {
     if (!this._searchString && this._fastFind.searchString)
       this._searchString = this._fastFind.searchString;
     return this._searchString;
   },
   get clipboardSearchString() {
     let searchString = "";
     if (!Clipboard.supportsFindClipboard())
       return searchString;
     try {
       let trans = Cc["@mozilla.org/widget/transferable;1"]
                     .createInstance(Ci.nsITransferable);
       trans.init(this._getWindow()
                      .QueryInterface(Ci.nsIInterfaceRequestor)
                      .getInterface(Ci.nsIWebNavigation)
                      .QueryInterface(Ci.nsILoadContext));
       trans.addDataFlavor("text/unicode");
       Clipboard.getData(trans, Ci.nsIClipboard.kFindClipboard);
       let data = {};
       let dataLen = {};
       trans.getTransferData("text/unicode", data, dataLen);
       if (data.value) {
         data = data.value.QueryInterface(Ci.nsISupportsString);
         searchString = data.toString();
       }
     } catch (ex) {}
     return searchString;
   },
   set clipboardSearchString(aSearchString) {
     if (!aSearchString || !Clipboard.supportsFindClipboard())
       return;
     ClipboardHelper.copyStringToClipboard(aSearchString,
                                           Ci.nsIClipboard.kFindClipboard,
                                           this._getWindow().document);
   },
   set caseSensitive(aSensitive) {
     this._fastFind.caseSensitive = aSensitive;
   },
   /**
    * Used for normal search operations, highlights the first match.
    *
    * @param aSearchString String to search for.
    * @param aLinksOnly Only consider nodes that are links for the search.
    * @param aDrawOutline Puts an outline around matched links.
    */
   fastFind: function (aSearchString, aLinksOnly, aDrawOutline) {
     let result = this._fastFind.find(aSearchString, aLinksOnly);
     let searchString = this._fastFind.searchString;
     this._notify(searchString, result, false, aDrawOutline);
   },
   /**
    * Repeat the previous search. Should only be called after a previous
    * call to Finder.fastFind.
    *
    * @param aFindBackwards Controls the search direction:
    *    true: before current match, false: after current match.
    * @param aLinksOnly Only consider nodes that are links for the search.
    * @param aDrawOutline Puts an outline around matched links.
    */
   findAgain: function (aFindBackwards, aLinksOnly, aDrawOutline) {
     let result = this._fastFind.findAgain(aFindBackwards, aLinksOnly);
     let searchString = this._fastFind.searchString;
     this._notify(searchString, result, aFindBackwards, aDrawOutline);
   },
   /**
    * Forcibly set the search string of the find clipboard to the currently
    * selected text in the window, on supported platforms (i.e. OSX).
    */
   setSearchStringToSelection: function() {
     // Find the selected text.
     let selection = this._getWindow().getSelection();
     // Don't go for empty selections.
     if (!selection.rangeCount)
       return null;
     let searchString = (selection.toString() || "").trim();
     // Empty strings are rather useless to search for.
     if (!searchString.length)
       return null;
     this.clipboardSearchString = searchString;
     return searchString;
   },
   highlight: function (aHighlight, aWord) {
     let found = this._highlight(aHighlight, aWord, null);
     if (aHighlight) {
       let result = found ? Ci.nsITypeAheadFind.FIND_FOUND
                          : Ci.nsITypeAheadFind.FIND_NOTFOUND;
       this._notify(aWord, result, false, false, false);
     }
   },
   enableSelection: function() {
     this._fastFind.setSelectionModeAndRepaint(Ci.nsISelectionController.SELECTION_ON);
     this._restoreOriginalOutline();
   },
   removeSelection: function() {
     this._fastFind.collapseSelection();
     this.enableSelection();
   },
   focusContent: function() {
     // Allow Finder listeners to cancel focusing the content.
     for (let l of this._listeners) {
       if (!l.shouldFocusContent())
         return;
     }
     let fastFind = this._fastFind;
     const fm = Cc["@mozilla.org/focus-manager;1"].getService(Ci.nsIFocusManager);
     try {
       // Try to find the best possible match that should receive focus and
       // block scrolling on focus since find already scrolls. Further
       // scrolling is due to user action, so don't override this.
       if (fastFind.foundLink) {
         fm.setFocus(fastFind.foundLink, fm.FLAG_NOSCROLL);
       } else if (fastFind.foundEditable) {
         fm.setFocus(fastFind.foundEditable, fm.FLAG_NOSCROLL);
         fastFind.collapseSelection();
       } else {
         this._getWindow().focus()
       }
     } catch (e) {}
   },
   keyPress: function (aEvent) {
     let controller = this._getSelectionController(this._getWindow());
     switch (aEvent.keyCode) {
       case Ci.nsIDOMKeyEvent.DOM_VK_RETURN:
         if (this._fastFind.foundLink) {
           let view = this._fastFind.foundLink.ownerDocument.defaultView;
           this._fastFind.foundLink.dispatchEvent(new view.MouseEvent("click", {
             view: view,
             cancelable: true,
             bubbles: true,
             ctrlKey: aEvent.ctrlKey,
             altKey: aEvent.altKey,
             shiftKey: aEvent.shiftKey,
             metaKey: aEvent.metaKey
           }));
         }
         break;
       case Ci.nsIDOMKeyEvent.DOM_VK_TAB:
         let direction = Services.focus.MOVEFOCUS_FORWARD;
         if (aEvent.shiftKey) {
           direction = Services.focus.MOVEFOCUS_BACKWARD;
         }
         Services.focus.moveFocus(this._getWindow(), null, direction, 0);
         break;
       case Ci.nsIDOMKeyEvent.DOM_VK_PAGE_UP:
         controller.scrollPage(false);
         break;
       case Ci.nsIDOMKeyEvent.DOM_VK_PAGE_DOWN:
         controller.scrollPage(true);
         break;
       case Ci.nsIDOMKeyEvent.DOM_VK_UP:
         controller.scrollLine(false);
         break;
       case Ci.nsIDOMKeyEvent.DOM_VK_DOWN:
         controller.scrollLine(true);
         break;
     }
   },
   _getWindow: function () {
     return this._docShell.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindow);
   },
   /**
    * Get the bounding selection rect in CSS px relative to the origin of the
    * top-level content document.
    */
   _getResultRect: function () {
     let topWin = this._getWindow();
     let win = this._fastFind.currentWindow;
     if (!win)
       return null;
     let selection = win.getSelection();
     if (!selection.rangeCount || selection.isCollapsed) {
       // The selection can be into an input or a textarea element.
       let nodes = win.document.querySelectorAll("input, textarea");
       for (let node of nodes) {
         if (node instanceof Ci.nsIDOMNSEditableElement && node.editor) {
           let sc = node.editor.selectionController;
           selection = sc.getSelection(Ci.nsISelectionController.SELECTION_NORMAL);
           if (selection.rangeCount && !selection.isCollapsed) {
             break;
           }
         }
       }
     }
     let utils = topWin.QueryInterface(Ci.nsIInterfaceRequestor)
                       .getInterface(Ci.nsIDOMWindowUtils);
     let scrollX = {}, scrollY = {};
     utils.getScrollXY(false, scrollX, scrollY);
     for (let frame = win; frame != topWin; frame = frame.parent) {
       let rect = frame.frameElement.getBoundingClientRect();
       let left = frame.getComputedStyle(frame.frameElement, "").borderLeftWidth;
       let top = frame.getComputedStyle(frame.frameElement, "").borderTopWidth;
       scrollX.value += rect.left + parseInt(left, 10);
       scrollY.value += rect.top + parseInt(top, 10);
     }
     let rect = Rect.fromRect(selection.getRangeAt(0).getBoundingClientRect());
     return rect.translate(scrollX.value, scrollY.value);
   },
   _outlineLink: function (aDrawOutline) {
     let foundLink = this._fastFind.foundLink;
     // Optimization: We are drawing outlines and we matched
     // the same link before, so don't duplicate work.
     if (foundLink == this._previousLink && aDrawOutline)
       return;
     this._restoreOriginalOutline();
     if (foundLink && aDrawOutline) {
       // Backup original outline
       this._tmpOutline = foundLink.style.outline;
       this._tmpOutlineOffset = foundLink.style.outlineOffset;
       // Draw pseudo focus rect
       // XXX Should we change the following style for FAYT pseudo focus?
       // XXX Shouldn't we change default design if outline is visible
       //     already?
       // Don't set the outline-color, we should always use initial value.
       foundLink.style.outline = "1px dotted";
       foundLink.style.outlineOffset = "0";
       this._previousLink = foundLink;
     }
   },
   _restoreOriginalOutline: function () {
     // Removes the outline around the last found link.
     if (this._previousLink) {
       this._previousLink.style.outline = this._tmpOutline;
       this._previousLink.style.outlineOffset = this._tmpOutlineOffset;
       this._previousLink = null;
     }
   },
   _highlight: function (aHighlight, aWord, aWindow) {
     let win = aWindow || this._getWindow();
     let found = false;
     for (let i = 0; win.frames && i < win.frames.length; i++) {
       if (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;
     }
     let body = (doc instanceof Ci.nsIDOMHTMLDocument && doc.body) ?
                doc.body : doc.documentElement;
     if (aHighlight) {
       let searchRange = doc.createRange();
       searchRange.selectNodeContents(body);
       let startPt = searchRange.cloneRange();
       startPt.collapse(true);
       let endPt = searchRange.cloneRange();
       endPt.collapse(false);
       let retRange = null;
       let finder = Cc["@mozilla.org/embedcomp/rangefind;1"]
                      .createInstance()
                      .QueryInterface(Ci.nsIFind);
       finder.caseSensitive = this._fastFind.caseSensitive;
       while ((retRange = finder.Find(aWord, searchRange,
                                      startPt, endPt))) {
         this._highlightRange(retRange, controller);
         startPt = retRange.cloneRange();
         startPt.collapse(false);
         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
     if (!aWindow.innerWidth || !aWindow.innerHeight)
       return null;
     // Yuck. See bug 138068.
     let docShell = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
                           .getInterface(Ci.nsIWebNavigation)
                           .QueryInterface(Ci.nsIDocShell);
     let controller = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
                              .getInterface(Ci.nsISelectionDisplay)
                              .QueryInterface(Ci.nsISelectionController);
     return controller;
   },
   /*
    * For a given node, walk up it's parent chain, to try and find an
    * editable node.
    *
    * @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) {
     while (aNode) {
       if (aNode instanceof Ci.nsIDOMNSEditableElement)
         return aNode.editor ? aNode : null;
       aNode = aNode.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;
   },
   // Start of nsIWebProgressListener implementation.
   onLocationChange: function(aWebProgress, aRequest, aLocation, aFlags) {
     if (!aWebProgress.isTopLevel)
       return;
     // Avoid leaking if we change the page.
     this._previousLink = null;
   },
   // 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,
                                          Ci.nsISupportsWeakReference])
 };

The Tor Browser / annotate

toolkit/modules/Finder.jsm@6474c204b198 (annotated)

toolkit/modules/Finder.jsm