src/third_party/WebKit/Source/web/TextFinder.h

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef TextFinder_h
  32 #define TextFinder_h
  33
  34 #include "core/editing/FindOptions.h"
  35 #include "platform/geometry/FloatRect.h"
  36 #include "platform/heap/Handle.h"
  37 #include "public/platform/WebFloatPoint.h"
  38 #include "public/platform/WebFloatRect.h"
  39 #include "public/platform/WebRect.h"
  40 #include "public/web/WebFindOptions.h"
  41 #include "wtf/PassOwnPtr.h"
  42 #include "wtf/PassRefPtr.h"
  43 #include "wtf/Vector.h"
  44 #include "wtf/text/WTFString.h"
  45
  46 namespace blink {
  47
  48 class Range;
  49 class WebLocalFrameImpl;
  50
  51 template <typename T> class WebVector;
  52
  53 class TextFinder final : public NoBaseWillBeGarbageCollectedFinalized<TextFinder> {
  54 public:
  55     static PassOwnPtrWillBeRawPtr<TextFinder> create(WebLocalFrameImpl& ownerFrame);
  56
  57     bool find(
  58         int identifier, const WebString& searchText, const WebFindOptions&,
  59         bool wrapWithinFrame, WebRect* selectionRect);
  60     void stopFindingAndClearSelection();
  61     void scopeStringMatches(
  62         int identifier, const WebString& searchText, const WebFindOptions&,
  63         bool reset);
  64     void cancelPendingScopingEffort();
  65     void increaseMatchCount(int identifier, int count);
  66     void resetMatchCount();
  67     int findMatchMarkersVersion() const { return m_findMatchMarkersVersion; }
  68     WebFloatRect activeFindMatchRect();
  69     void findMatchRects(WebVector<WebFloatRect>&);
  70     int selectNearestFindMatch(const WebFloatPoint&, WebRect* selectionRect);
  71
  72     // Returns which frame has an active match. This function should only be
  73     // called on the main frame, as it is the only frame keeping track. Returned
  74     // value can be 0 if no frame has an active match.
  75     WebLocalFrameImpl* activeMatchFrame() const { return m_currentActiveMatchFrame; }
  76
  77     // Returns the active match in the current frame. Could be a null range if
  78     // the local frame has no active match.
  79     Range* activeMatch() const { return m_activeMatch.get(); }
  80
  81     void flushCurrentScoping();
  82
  83     void resetActiveMatch() { m_activeMatch = nullptr; }
  84
  85     int totalMatchCount() const { return m_totalMatchCount; }
  86     bool scopingInProgress() const { return m_scopingInProgress; }
  87     void increaseMarkerVersion() { ++m_findMatchMarkersVersion; }
  88
  89     ~TextFinder();
  90
  91     class FindMatch {
  92         ALLOW_ONLY_INLINE_ALLOCATION();
  93     public:
  94         FindMatch(PassRefPtrWillBeRawPtr<Range>, int ordinal);
  95
  96         void trace(Visitor*);
  97
  98         RefPtrWillBeMember<Range> m_range;
  99
 100         // 1-based index within this frame.
 101         int m_ordinal;
 102
 103         // In find-in-page coordinates.
 104         // Lazily calculated by updateFindMatchRects.
 105         FloatRect m_rect;
 106     };
 107
 108     void trace(Visitor*);
 109
 110 private:
 111     class DeferredScopeStringMatches;
 112     friend class DeferredScopeStringMatches;
 113
 114     explicit TextFinder(WebLocalFrameImpl& ownerFrame);
 115
 116     // Notifies the delegate about a new selection rect.
 117     void reportFindInPageSelection(
 118         const WebRect& selectionRect, int activeMatchOrdinal, int identifier);
 119
 120     void reportFindInPageResultToAccessibility(int identifier);
 121
 122     // Clear the find-in-page matches cache forcing rects to be fully
 123     // calculated again next time updateFindMatchRects is called.
 124     void clearFindMatchesCache();
 125
 126     // Check if the activeMatchFrame still exists in the frame tree.
 127     bool isActiveMatchFrameValid() const;
 128
 129     // Return the index in the find-in-page cache of the match closest to the
 130     // provided point in find-in-page coordinates, or -1 in case of error.
 131     // The squared distance to the closest match is returned in the distanceSquared parameter.
 132     int nearestFindMatch(const FloatPoint&, float& distanceSquared);
 133
 134     // Select a find-in-page match marker in the current frame using a cache
 135     // match index returned by nearestFindMatch. Returns the ordinal of the new
 136     // selected match or -1 in case of error. Also provides the bounding box of
 137     // the marker in window coordinates if selectionRect is not null.
 138     int selectFindMatch(unsigned index, WebRect* selectionRect);
 139
 140     // Compute and cache the rects for FindMatches if required.
 141     // Rects are automatically invalidated in case of content size changes,
 142     // propagating the invalidation to child frames.
 143     void updateFindMatchRects();
 144
 145     // Append the find-in-page match rects of the current frame to the provided vector.
 146     void appendFindMatchRects(Vector<WebFloatRect>& frameRects);
 147
 148     // Add a WebKit TextMatch-highlight marker to nodes in a range.
 149     void addMarker(Range*, bool activeMatch);
 150
 151     // Sets the markers within a range as active or inactive.
 152     void setMarkerActive(Range*, bool active);
 153
 154     // Returns the ordinal of the first match in the frame specified. This
 155     // function enumerates the frames, starting with the main frame and up to (but
 156     // not including) the frame passed in as a parameter and counts how many
 157     // matches have been found.
 158     int ordinalOfFirstMatchForFrame(WebLocalFrameImpl*) const;
 159
 160     // Determines whether the scoping effort is required for a particular frame.
 161     // It is not necessary if the frame is invisible, for example, or if this
 162     // is a repeat search that already returned nothing last time the same prefix
 163     // was searched.
 164     bool shouldScopeMatches(const WTF::String& searchText);
 165
 166     // Removes the current frame from the global scoping effort and triggers any
 167     // updates if appropriate. This method does not mark the scoping operation
 168     // as finished.
 169     void flushCurrentScopingEffort(int identifier);
 170
 171     // Finishes the current scoping effort and triggers any updates if appropriate.
 172     void finishCurrentScopingEffort(int identifier);
 173
 174     // Queue up a deferred call to scopeStringMatches.
 175     void scopeStringMatchesSoon(
 176         int identifier, const WebString& searchText, const WebFindOptions&,
 177         bool reset);
 178
 179     // Called by a DeferredScopeStringMatches instance.
 180     void callScopeStringMatches(
 181         DeferredScopeStringMatches*, int identifier, const WebString& searchText,
 182         const WebFindOptions&, bool reset);
 183
 184     // Determines whether to invalidate the content area and scrollbar.
 185     void invalidateIfNecessary();
 186
 187     // Sets the markers within a current match range as active or inactive.
 188     void setMatchMarkerActive(bool);
 189
 190     void decrementFramesScopingCount(int identifier);
 191
 192     WebLocalFrameImpl& ownerFrame() const
 193     {
 194         ASSERT(m_ownerFrame);
 195         return *m_ownerFrame;
 196     }
 197
 198     // Returns the ordinal of the first match in the owner frame.
 199     int ordinalOfFirstMatch() const;
 200
 201     RawPtrWillBeMember<WebLocalFrameImpl> m_ownerFrame;
 202
 203     // A way for the main frame to keep track of which frame has an active
 204     // match. Should be 0 for all other frames.
 205     RawPtrWillBeMember<WebLocalFrameImpl> m_currentActiveMatchFrame;
 206
 207     // The range of the active match for the current frame.
 208     RefPtrWillBeMember<Range> m_activeMatch;
 209
 210     // The index of the active match for the current frame.
 211     int m_activeMatchIndexInCurrentFrame;
 212
 213     // The scoping effort can time out and we need to keep track of where we
 214     // ended our last search so we can continue from where we left of.
 215     //
 216     // This range is collapsed to the end position of the last successful
 217     // search; the new search should start from this position.
 218     RefPtrWillBeMember<Range> m_resumeScopingFromRange;
 219
 220     // Keeps track of the last string this frame searched for. This is used for
 221     // short-circuiting searches in the following scenarios: When a frame has
 222     // been searched and returned 0 results, we don't need to search that frame
 223     // again if the user is just adding to the search (making it more specific).
 224     WTF::String m_lastSearchString;
 225
 226     // Keeps track of how many matches this frame has found so far, so that we
 227     // don't lose count between scoping efforts, and is also used (in conjunction
 228     // with m_lastSearchString) to figure out if we need to search the frame again.
 229     int m_lastMatchCount;
 230
 231     // This variable keeps a cumulative total of matches found so far for ALL the
 232     // frames on the page, and is only incremented by calling IncreaseMatchCount
 233     // (on the main frame only). It should be -1 for all other frames.
 234     int m_totalMatchCount;
 235
 236     // This variable keeps a cumulative total of how many frames are currently
 237     // scoping, and is incremented/decremented on the main frame only.
 238     // It should be -1 for all other frames.
 239     int m_framesScopingCount;
 240
 241     // Identifier of the latest find-in-page request. Required to be stored in
 242     // the frame in order to reply if required in case the frame is detached.
 243     int m_findRequestIdentifier;
 244
 245     // Keeps track of when the scoping effort should next invalidate the scrollbar
 246     // and the frame area.
 247     int m_nextInvalidateAfter;
 248
 249     // A list of all of the pending calls to scopeStringMatches.
 250     WillBeHeapVector<OwnPtrWillBeMember<DeferredScopeStringMatches> > m_deferredScopingWork;
 251
 252     // Version number incremented on the main frame only whenever the document
 253     // find-in-page match markers change. It should be 0 for all other frames.
 254     int m_findMatchMarkersVersion;
 255
 256     // Local cache of the find match markers currently displayed for this frame.
 257     WillBeHeapVector<FindMatch> m_findMatchesCache;
 258
 259     // Contents size when find-in-page match rects were last computed for this
 260     // frame's cache.
 261     IntSize m_contentsSizeForCurrentFindMatchRects;
 262
 263     // This flag is used by the scoping effort to determine if we need to figure
 264     // out which rectangle is the active match. Once we find the active
 265     // rectangle we clear this flag.
 266     bool m_locatingActiveRect;
 267
 268     // Keeps track of whether there is an scoping effort ongoing in the frame.
 269     bool m_scopingInProgress;
 270
 271     // Keeps track of whether the last find request completed its scoping effort
 272     // without finding any matches in this frame.
 273     bool m_lastFindRequestCompletedWithNoMatches;
 274
 275     // Determines if the rects in the find-in-page matches cache of this frame
 276     // are invalid and should be recomputed.
 277     bool m_findMatchRectsAreValid;
 278 };
 279
 280 } // namespace blink
 281
 282 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::TextFinder::FindMatch);
 283
 284 #endif // TextFinder_h