Rename WebCore namespace to blink in bindings and web

Source/web/TextFinder.h

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "platform/heap/Handle.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebRect.h"
 #include "public/web/WebFindOptions.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
-namespace WebCore {
+namespace blink {
 class Range;
 }
 
 namespace blink {
 class WebLocalFrameImpl;
 
 template <typename T> class WebVector;
 
 class TextFinder {
 public:
@@ skipping 14 matching lines @@
     void findMatchRects(WebVector<WebFloatRect>&);
     int selectNearestFindMatch(const WebFloatPoint&, WebRect* selectionRect);
 
     // Returns which frame has an active match. This function should only be
     // called on the main frame, as it is the only frame keeping track. Returned
     // value can be 0 if no frame has an active match.
     WebLocalFrameImpl* activeMatchFrame() const { return m_currentActiveMatchFrame; }
 
     // Returns the active match in the current frame. Could be a null range if
     // the local frame has no active match.
-    WebCore::Range* activeMatch() const { return m_activeMatch.get(); }
+    blink::Range* activeMatch() const { return m_activeMatch.get(); }
 
     void flushCurrentScoping();
 
     void resetActiveMatch() { m_activeMatch = nullptr; }
 
     int totalMatchCount() const { return m_totalMatchCount; }
     bool scopingInProgress() const { return m_scopingInProgress; }
     void increaseMarkerVersion() { ++m_findMatchMarkersVersion; }
 
     ~TextFinder();
 
     class FindMatch {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
-        RefPtrWillBeMember<WebCore::Range> m_range;
+        RefPtrWillBeMember<blink::Range> m_range;
 
         // 1-based index within this frame.
         int m_ordinal;
 
         // In find-in-page coordinates.
         // Lazily calculated by updateFindMatchRects.
-        WebCore::FloatRect m_rect;
+        blink::FloatRect m_rect;
 
-        FindMatch(PassRefPtrWillBeRawPtr<WebCore::Range>, int ordinal);
+        FindMatch(PassRefPtrWillBeRawPtr<blink::Range>, int ordinal);
 
-        void trace(WebCore::Visitor*);
+        void trace(blink::Visitor*);
     };
 
 private:
     class DeferredScopeStringMatches;
     friend class DeferredScopeStringMatches;
 
     explicit TextFinder(WebLocalFrameImpl& ownerFrame);
 
     // Notifies the delegate about a new selection rect.
     void reportFindInPageSelection(
         const WebRect& selectionRect, int activeMatchOrdinal, int identifier);
 
     // Clear the find-in-page matches cache forcing rects to be fully
     // calculated again next time updateFindMatchRects is called.
     void clearFindMatchesCache();
 
     // Check if the activeMatchFrame still exists in the frame tree.
     bool isActiveMatchFrameValid() const;
 
     // Return the index in the find-in-page cache of the match closest to the
     // provided point in find-in-page coordinates, or -1 in case of error.
     // The squared distance to the closest match is returned in the distanceSquared parameter.
-    int nearestFindMatch(const WebCore::FloatPoint&, float& distanceSquared);
+    int nearestFindMatch(const blink::FloatPoint&, float& distanceSquared);
 
     // Select a find-in-page match marker in the current frame using a cache
     // match index returned by nearestFindMatch. Returns the ordinal of the new
     // selected match or -1 in case of error. Also provides the bounding box of
     // the marker in window coordinates if selectionRect is not null.
     int selectFindMatch(unsigned index, WebRect* selectionRect);
 
     // Compute and cache the rects for FindMatches if required.
     // Rects are automatically invalidated in case of content size changes,
     // propagating the invalidation to child frames.
     void updateFindMatchRects();
 
     // Append the find-in-page match rects of the current frame to the provided vector.
     void appendFindMatchRects(Vector<WebFloatRect>& frameRects);
 
     // Add a WebKit TextMatch-highlight marker to nodes in a range.
-    void addMarker(WebCore::Range*, bool activeMatch);
+    void addMarker(blink::Range*, bool activeMatch);
 
     // Sets the markers within a range as active or inactive.
-    void setMarkerActive(WebCore::Range*, bool active);
+    void setMarkerActive(blink::Range*, bool active);
 
     // Returns the ordinal of the first match in the frame specified. This
     // function enumerates the frames, starting with the main frame and up to (but
     // not including) the frame passed in as a parameter and counts how many
     // matches have been found.
     int ordinalOfFirstMatchForFrame(WebLocalFrameImpl*) const;
 
     // Determines whether the scoping effort is required for a particular frame.
     // It is not necessary if the frame is invisible, for example, or if this
     // is a repeat search that already returned nothing last time the same prefix
@@ skipping 29 matching lines @@
     // Returns the ordinal of the first match in the owner frame.
     int ordinalOfFirstMatch() const;
 
     WebLocalFrameImpl& m_ownerFrame;
 
     // A way for the main frame to keep track of which frame has an active
     // match. Should be 0 for all other frames.
     WebLocalFrameImpl* m_currentActiveMatchFrame;
 
     // The range of the active match for the current frame.
-    RefPtrWillBePersistent<WebCore::Range> m_activeMatch;
+    RefPtrWillBePersistent<blink::Range> m_activeMatch;
 
     // The index of the active match for the current frame.
     int m_activeMatchIndexInCurrentFrame;
 
     // The scoping effort can time out and we need to keep track of where we
     // ended our last search so we can continue from where we left of.
     //
     // This range is collapsed to the start position of the last successful
     // search; the new search should start from the next adjacent position.
-    RefPtrWillBePersistent<WebCore::Range> m_resumeScopingFromRange;
+    RefPtrWillBePersistent<blink::Range> m_resumeScopingFromRange;
 
     // Keeps track of the last string this frame searched for. This is used for
     // short-circuiting searches in the following scenarios: When a frame has
     // been searched and returned 0 results, we don't need to search that frame
     // again if the user is just adding to the search (making it more specific).
     WTF::String m_lastSearchString;
 
     // Keeps track of how many matches this frame has found so far, so that we
     // don't loose count between scoping efforts, and is also used (in conjunction
     // with m_lastSearchString) to figure out if we need to search the frame again.
@@ skipping 22 matching lines @@
 
     // Version number incremented on the main frame only whenever the document
     // find-in-page match markers change. It should be 0 for all other frames.
     int m_findMatchMarkersVersion;
 
     // Local cache of the find match markers currently displayed for this frame.
     WillBePersistentHeapVector<FindMatch> m_findMatchesCache;
 
     // Contents size when find-in-page match rects were last computed for this
     // frame's cache.
-    WebCore::IntSize m_contentsSizeForCurrentFindMatchRects;
+    blink::IntSize m_contentsSizeForCurrentFindMatchRects;
 
     // This flag is used by the scoping effort to determine if we need to figure
     // out which rectangle is the active match. Once we find the active
     // rectangle we clear this flag.
     bool m_locatingActiveRect;
 
     // Keeps track of whether there is an scoping effort ongoing in the frame.
     bool m_scopingInProgress;
 
     // Keeps track of whether the last find request completed its scoping effort
     // without finding any matches in this frame.
     bool m_lastFindRequestCompletedWithNoMatches;
 
     // Determines if the rects in the find-in-page matches cache of this frame
     // are invalid and should be recomputed.
     bool m_findMatchRectsAreValid;
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::TextFinder::FindMatch);
 
 #endif