Multi-Process Find-in-Page.

third_party/WebKit/public/web/WebLocalFrame.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WebLocalFrame_h
 #define WebLocalFrame_h
 
 #include "WebFrame.h"
 #include "WebFrameLoadType.h"
 
@@ skipping 209 matching lines @@
     virtual WebSandboxFlags effectiveSandboxFlags() const = 0;
 
     // Set sandbox flags that will always be forced on this frame.  This is
     // used to inherit sandbox flags from cross-process opener frames in popups.
     //
     // TODO(dcheng): Remove this once we have WebLocalFrame::createMainFrame.
     virtual void forceSandboxFlags(WebSandboxFlags) = 0;
 
     // Find-in-page -----------------------------------------------------------
 
+    // Specifies the action to be taken at the end of a find-in-page session.
+    enum StopFindAction {
+        // No selection will be left.
+        StopFindActionClearSelection,
+
+        // The active match will remain selected.
+        StopFindActionKeepSelection,
+
+        // The active match selection will be activated.
+        StopFindActionActivateSelection
+    };
+
     // Searches a frame for a given string.
     //
     // If a match is found, this function will select it (scrolling down to
     // make it visible if needed) and fill in selectionRect with the
     // location of where the match was found (in window coordinates).
     //
     // If no match is found, this function clears all tickmarks and
     // highlighting.
     //
     // Returns true if the search string was found, false otherwise.
     virtual bool find(int identifier,
         const WebString& searchText,
         const WebFindOptions&,
         bool wrapWithinFrame,
         WebRect* selectionRect,
         bool* activeNow = nullptr) = 0;
 
     // Notifies the frame that we are no longer interested in searching.
     // This will abort any asynchronous scoping effort already under way
     // (see the function scopeStringMatches for details) and erase all
-    // tick-marks and highlighting from the previous search.  If
-    // clearSelection is true, it will also make sure the end state for the
-    // find operation does not leave a selection.  This can occur when the
-    // user clears the search string but does not close the find box.
-    virtual void stopFinding(bool clearSelection) = 0;
+    // tick-marks and highlighting from the previous search.  It will also
+    // follow the specified StopFindAction.
+    virtual void stopFinding(StopFindAction) = 0;
 
     // Counts how many times a particular string occurs within the frame.
     // It also retrieves the location of the string and updates a vector in
     // the frame so that tick-marks and highlighting can be drawn.  This
     // function does its work asynchronously, by running for a certain
     // time-slice and then scheduling itself (co-operative multitasking) to
     // be invoked later (repeating the process until all matches have been
     // found).  This allows multiple frames to be searched at the same time
     // and provides a way to cancel at any time (see
     // cancelPendingScopingEffort).  The parameter searchText specifies
@@ skipping 22 matching lines @@
     // current version. Should be called only on the main frame.
     virtual int findMatchMarkersVersion() const = 0;
 
     // Returns the bounding box of the active find-in-page match marker or an
     // empty rect if no such marker exists. The rect is returned in find-in-page
     // coordinates whatever frame the active marker is.
     // Should be called only on the main frame.
     virtual WebFloatRect activeFindMatchRect() = 0;
 
     // Swaps the contents of the provided vector with the bounding boxes of the
-    // find-in-page match markers from all frames. The bounding boxes are returned
-    // in find-in-page coordinates. This method should be called only on the main frame.
+    // find-in-page match markers from all frames. The bounding boxes are
+    // returned in find-in-page coordinates. This method should be called only
+    // on the main frame.
     virtual void findMatchRects(WebVector<WebFloatRect>&) = 0;
 
-    // Selects the find-in-page match in the appropriate frame closest to the
-    // provided point in find-in-page coordinates. Returns the ordinal of such
-    // match or -1 if none could be found. If not null, selectionRect is set to
-    // the bounding box of the selected match in window coordinates.
-    // This method should be called only on the main frame.
+    // Selects the find-in-page match closest to the provided point in
+    // find-in-page coordinates. Returns the ordinal of such match or -1 if none
+    // could be found. If not null, selectionRect is set to the bounding box of
+    // the selected match in window coordinates.  This method should be called
+    // only on the main frame.
     virtual int selectNearestFindMatch(const WebFloatPoint&,
         WebRect* selectionRect)
         = 0;
 
+    // Returns the distance (squared) to the closest find-in-page match from the
+    // provided point, in find-in-page coordinates.
+    virtual float distanceToNearestFindMatch(const WebFloatPoint&) = 0;
+
     // Set the tickmarks for the frame. This will override the default tickmarks
     // generated by find results. If this is called with an empty array, the
     // default behavior will be restored.
     virtual void setTickmarks(const WebVector<WebRect>&) = 0;
 
+    // Clears the active find match in the frame, if one exists.
+    virtual void clearActiveFindMatch() = 0;
+
     // Context menu -----------------------------------------------------------
 
     // Returns the node that the context menu opened over.
     virtual WebNode contextMenuNode() const = 0;
 
     // Returns the WebFrameWidget associated with this frame if there is one or
     // nullptr otherwise.
     virtual WebWidget* frameWidget() const = 0;
 
 protected:
     explicit WebLocalFrame(WebTreeScopeType scope) : WebFrame(scope) { }
 
     // Inherited from WebFrame, but intentionally hidden: it never makes sense
     // to call these on a WebLocalFrame.
     bool isWebLocalFrame() const override = 0;
     WebLocalFrame* toWebLocalFrame() override = 0;
     bool isWebRemoteFrame() const override = 0;
     WebRemoteFrame* toWebRemoteFrame() override = 0;
 };
 
 } // namespace blink
 
 #endif // WebLocalFrame_h