Rename WebFrameImpl to WebLocalFrameImpl.

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 30 matching lines @@
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 class Range;
 }
 
 namespace blink {
-class WebFrameImpl;
+class WebLocalFrameImpl;
 
 template <typename T> class WebVector;
 
 class TextFinder {
 public:
-    static PassOwnPtr<TextFinder> create(WebFrameImpl& ownerFrame);
+    static PassOwnPtr<TextFinder> create(WebLocalFrameImpl& ownerFrame);
 
     bool find(
         int identifier, const WebString& searchText, const WebFindOptions&,
         bool wrapWithinFrame, WebRect* selectionRect);
     void stopFindingAndClearSelection();
     void scopeStringMatches(
         int identifier, const WebString& searchText, const WebFindOptions&,
         bool reset);
     void cancelPendingScopingEffort();
     void increaseMatchCount(int identifier, int count);
     void resetMatchCount();
     int findMatchMarkersVersion() const { return m_findMatchMarkersVersion; }
     WebFloatRect activeFindMatchRect();
     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.
-    WebFrameImpl* activeMatchFrame() const { return m_currentActiveMatchFrame; }
+    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(); }
 
     void flushCurrentScoping();
 
     void resetActiveMatch() { m_activeMatch = nullptr; }
 
     int totalMatchCount() const { return m_totalMatchCount; }
@@ skipping 16 matching lines @@
 
         FindMatch(PassRefPtrWillBeRawPtr<WebCore::Range>, int ordinal);
 
         void trace(WebCore::Visitor*);
     };
 
 private:
     class DeferredScopeStringMatches;
     friend class DeferredScopeStringMatches;
 
-    explicit TextFinder(WebFrameImpl& ownerFrame);
+    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.
@@ skipping 21 matching lines @@
     // Add a WebKit TextMatch-highlight marker to nodes in a range.
     void addMarker(WebCore::Range*, bool activeMatch);
 
     // Sets the markers within a range as active or inactive.
     void setMarkerActive(WebCore::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(WebFrameImpl*) const;
+    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
     // was searched.
     bool shouldScopeMatches(const WTF::String& searchText);
 
     // Removes the current frame from the global scoping effort and triggers any
     // updates if appropriate. This method does not mark the scoping operation
     // as finished.
@@ skipping 16 matching lines @@
     void invalidateIfNecessary();
 
     // Sets the markers within a current match range as active or inactive.
     void setMatchMarkerActive(bool);
 
     void decrementFramesScopingCount(int identifier);
 
     // Returns the ordinal of the first match in the owner frame.
     int ordinalOfFirstMatch() const;
 
-    WebFrameImpl& m_ownerFrame;
+    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.
-    WebFrameImpl* m_currentActiveMatchFrame;
+    WebLocalFrameImpl* m_currentActiveMatchFrame;
 
     // The range of the active match for the current frame.
     RefPtrWillBePersistent<WebCore::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.
     RefPtrWillBePersistent<WebCore::Range> m_resumeScopingFromRange;
@@ skipping 60 matching lines @@
 
 } // namespace blink
 
 namespace WTF {
 template <> struct VectorTraits<blink::TextFinder::FindMatch> : VectorTraitsBase<blink::TextFinder::FindMatch> {
     static const bool canInitializeWithMemset = true;
 };
 }
 
 #endif