Rename WebFrameImpl to WebLocalFrameImpl.

Source/web/TextFinder.cpp

 /*
  * 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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 #include "config.h"
 #include "TextFinder.h"
 
 #include "FindInPageCoordinates.h"
 #include "WebFindOptions.h"
 #include "WebFrameClient.h"
-#include "WebFrameImpl.h"
+#include "WebLocalFrameImpl.h"
 #include "WebViewClient.h"
 #include "WebViewImpl.h"
 #include "core/dom/DocumentMarker.h"
 #include "core/dom/DocumentMarkerController.h"
 #include "core/dom/Range.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/Editor.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/VisibleSelection.h"
 #include "core/frame/FrameView.h"
@@ skipping 41 matching lines @@
     const WebString m_searchText;
     const WebFindOptions m_options;
     const bool m_reset;
 };
 
 bool TextFinder::find(int identifier, const WebString& searchText, const WebFindOptions& options, bool wrapWithinFrame, WebRect* selectionRect)
 {
     if (!m_ownerFrame.frame() || !m_ownerFrame.frame()->page())
         return false;
 
-    WebFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
+    WebLocalFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
 
     if (!options.findNext)
         m_ownerFrame.frame()->page()->unmarkAllTextMatches();
     else
         setMarkerActive(m_activeMatch.get(), false);
 
     if (m_activeMatch && &m_activeMatch->ownerDocument() != m_ownerFrame.frame()->document())
         m_activeMatch = nullptr;
 
     // If the user has selected something since the last Find operation we want
@@ skipping 23 matching lines @@
 
         m_ownerFrame.invalidateAll();
         return false;
     }
 
 #if OS(ANDROID)
     m_ownerFrame.viewImpl()->zoomToFindInPageRect(m_ownerFrame.frameView()->contentsToWindow(enclosingIntRect(RenderObject::absoluteBoundingBoxRectForRange(m_activeMatch.get()))));
 #endif
 
     setMarkerActive(m_activeMatch.get(), true);
-    WebFrameImpl* oldActiveFrame = mainFrameImpl->ensureTextFinder().m_currentActiveMatchFrame;
+    WebLocalFrameImpl* oldActiveFrame = mainFrameImpl->ensureTextFinder().m_currentActiveMatchFrame;
     mainFrameImpl->ensureTextFinder().m_currentActiveMatchFrame = &m_ownerFrame;
 
     // Make sure no node is focused. See http://crbug.com/38700.
     m_ownerFrame.frame()->document()->setFocusedElement(nullptr);
 
     if (!options.findNext || activeSelection) {
         // This is either a Find operation or a Find-next from a new start point
         // due to a selection, so we set the flag to ask the scoping effort
         // to find the active rect for us and report it back to the UI.
         m_locatingActiveRect = true;
@@ skipping 70 matching lines @@
     }
 
     if (!shouldScopeMatches(searchText)) {
         // Note that we want to defer the final update when resetting even if shouldScopeMatches returns false.
         // This is done in order to prevent sending a final message based only on the results of the first frame
         // since m_framesScopingCount would be 0 as other frames have yet to reset.
         finishCurrentScopingEffort(identifier);
         return;
     }
 
-    WebFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
+    WebLocalFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
     RefPtrWillBeRawPtr<Range> searchRange(rangeOfContents(m_ownerFrame.frame()->document()));
 
     Node* originalEndContainer = searchRange->endContainer();
     int originalEndOffset = searchRange->endOffset();
 
     TrackExceptionState exceptionState, exceptionState2;
     if (m_resumeScopingFromRange) {
         // This is a continuation of a scoping operation that timed out and didn't
         // complete last time around, so we should start from where we left off.
         searchRange->setStart(m_resumeScopingFromRange->startContainer(), m_resumeScopingFromRange->startOffset(exceptionState2) + 1, exceptionState);
@@ skipping 111 matching lines @@
     }
 
     finishCurrentScopingEffort(identifier);
 }
 
 void TextFinder::flushCurrentScopingEffort(int identifier)
 {
     if (!m_ownerFrame.frame() || !m_ownerFrame.frame()->page())
         return;
 
-    WebFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
+    WebLocalFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
     mainFrameImpl->ensureTextFinder().decrementFramesScopingCount(identifier);
 }
 
 void TextFinder::finishCurrentScopingEffort(int identifier)
 {
     flushCurrentScopingEffort(identifier);
 
     m_scopingInProgress = false;
     m_lastFindRequestCompletedWithNoMatches = !m_lastMatchCount;
 
@@ skipping 47 matching lines @@
 {
     if (!m_findMatchesCache.isEmpty())
         m_ownerFrame.viewImpl()->mainFrameImpl()->ensureTextFinder().m_findMatchMarkersVersion++;
 
     m_findMatchesCache.clear();
     m_findMatchRectsAreValid = false;
 }
 
 bool TextFinder::isActiveMatchFrameValid() const
 {
-    WebFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
-    WebFrameImpl* activeMatchFrame = mainFrameImpl->activeMatchFrame();
+    WebLocalFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
+    WebLocalFrameImpl* activeMatchFrame = mainFrameImpl->activeMatchFrame();
     return activeMatchFrame && activeMatchFrame->activeMatch() && activeMatchFrame->frame()->tree().isDescendantOf(mainFrameImpl->frame());
 }
 
 void TextFinder::updateFindMatchRects()
 {
     IntSize currentContentsSize = m_ownerFrame.contentsSize();
     if (m_contentsSizeForCurrentFindMatchRects != currentContentsSize) {
         m_contentsSizeForCurrentFindMatchRects = currentContentsSize;
         m_findMatchRectsAreValid = false;
     }
@@ skipping 18 matching lines @@
             if (!it->m_rect.isEmpty())
                 filteredMatches.append(*it);
         }
 
         m_findMatchesCache.swap(filteredMatches);
     }
 
     // Invalidate the rects in child frames. Will be updated later during traversal.
     if (!m_findMatchRectsAreValid)
         for (WebFrame* child = m_ownerFrame.firstChild(); child; child = child->nextSibling())
-            toWebFrameImpl(child)->ensureTextFinder().m_findMatchRectsAreValid = false;
+            toWebLocalFrameImpl(child)->ensureTextFinder().m_findMatchRectsAreValid = false;
 
     m_findMatchRectsAreValid = true;
 }
 
 WebFloatRect TextFinder::activeFindMatchRect()
 {
     if (!isActiveMatchFrameValid())
         return WebFloatRect();
 
     return WebFloatRect(findInPageRectFromRange(m_currentActiveMatchFrame->activeMatch()));
 }
 
 void TextFinder::findMatchRects(WebVector<WebFloatRect>& outputRects)
 {
     Vector<WebFloatRect> matchRects;
-    for (WebFrameImpl* frame = &m_ownerFrame; frame; frame = toWebFrameImpl(frame->traverseNext(false)))
+    for (WebLocalFrameImpl* frame = &m_ownerFrame; frame; frame = toWebLocalFrameImpl(frame->traverseNext(false)))
         frame->ensureTextFinder().appendFindMatchRects(matchRects);
 
     outputRects = matchRects;
 }
 
 void TextFinder::appendFindMatchRects(Vector<WebFloatRect>& frameRects)
 {
     updateFindMatchRects();
     frameRects.reserveCapacity(frameRects.size() + m_findMatchesCache.size());
     for (Vector<FindMatch>::const_iterator it = m_findMatchesCache.begin(); it != m_findMatchesCache.end(); ++it) {
         ASSERT(!it->m_rect.isEmpty());
         frameRects.append(it->m_rect);
     }
 }
 
 int TextFinder::selectNearestFindMatch(const WebFloatPoint& point, WebRect* selectionRect)
 {
     TextFinder* bestFinder = 0;
     int indexInBestFrame = -1;
     float distanceInBestFrame = FLT_MAX;
 
-    for (WebFrameImpl* frame = &m_ownerFrame; frame; frame = toWebFrameImpl(frame->traverseNext(false))) {
+    for (WebLocalFrameImpl* frame = &m_ownerFrame; frame; frame = toWebLocalFrameImpl(frame->traverseNext(false))) {
         float distanceInFrame;
         TextFinder& finder = frame->ensureTextFinder();
         int indexInFrame = finder.nearestFindMatch(point, distanceInFrame);
         if (distanceInFrame < distanceInBestFrame) {
             bestFinder = &finder;
             indexInBestFrame = indexInFrame;
             distanceInBestFrame = distanceInFrame;
         }
     }
 
@@ skipping 26 matching lines @@
 int TextFinder::selectFindMatch(unsigned index, WebRect* selectionRect)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < m_findMatchesCache.size());
 
     RefPtrWillBeRawPtr<Range> range = m_findMatchesCache[index].m_range;
     if (!range->boundaryPointsValid() || !range->startContainer()->inDocument())
         return -1;
 
     // Check if the match is already selected.
     TextFinder& mainFrameTextFinder = m_ownerFrame.viewImpl()->mainFrameImpl()->ensureTextFinder();
-    WebFrameImpl* activeMatchFrame = mainFrameTextFinder.m_currentActiveMatchFrame;
+    WebLocalFrameImpl* activeMatchFrame = mainFrameTextFinder.m_currentActiveMatchFrame;
     if (&m_ownerFrame != activeMatchFrame || !m_activeMatch || !areRangesEqual(m_activeMatch.get(), range.get())) {
         if (isActiveMatchFrameValid())
             activeMatchFrame->ensureTextFinder().setMatchMarkerActive(false);
 
         m_activeMatchIndexInCurrentFrame = m_findMatchesCache[index].m_ordinal - 1;
 
         // Set this frame as the active frame (the one with the active highlight).
         mainFrameTextFinder.m_currentActiveMatchFrame = &m_ownerFrame;
         m_ownerFrame.viewImpl()->setFocusedFrame(&m_ownerFrame);
 
@@ skipping 20 matching lines @@
         activeMatchRect = m_ownerFrame.frameView()->contentsToWindow(activeMatchBoundingBox);
         m_ownerFrame.viewImpl()->zoomToFindInPageRect(activeMatchRect);
     }
 
     if (selectionRect)
         *selectionRect = activeMatchRect;
 
     return ordinalOfFirstMatch() + m_activeMatchIndexInCurrentFrame + 1;
 }
 
-PassOwnPtr<TextFinder> TextFinder::create(WebFrameImpl& ownerFrame)
+PassOwnPtr<TextFinder> TextFinder::create(WebLocalFrameImpl& ownerFrame)
 {
     return adoptPtr(new TextFinder(ownerFrame));
 }
 
-TextFinder::TextFinder(WebFrameImpl& ownerFrame)
+TextFinder::TextFinder(WebLocalFrameImpl& ownerFrame)
     : m_ownerFrame(ownerFrame)
     , m_currentActiveMatchFrame(0)
     , m_activeMatchIndexInCurrentFrame(-1)
     , m_resumeScopingFromRange(nullptr)
     , m_lastMatchCount(-1)
     , m_totalMatchCount(-1)
     , m_framesScopingCount(-1)
     , m_findRequestIdentifier(-1)
     , m_nextInvalidateAfter(0)
     , m_findMatchMarkersVersion(0)
@@ skipping 14 matching lines @@
     m_ownerFrame.frame()->document()->markers().addTextMatchMarker(range, activeMatch);
 }
 
 void TextFinder::setMarkerActive(Range* range, bool active)
 {
     if (!range || range->collapsed(IGNORE_EXCEPTION))
         return;
     m_ownerFrame.frame()->document()->markers().setMarkersActive(range, active);
 }
 
-int TextFinder::ordinalOfFirstMatchForFrame(WebFrameImpl* frame) const
+int TextFinder::ordinalOfFirstMatchForFrame(WebLocalFrameImpl* frame) const
 {
     int ordinal = 0;
-    WebFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
+    WebLocalFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
     // Iterate from the main frame up to (but not including) |frame| and
     // add up the number of matches found so far.
-    for (WebFrameImpl* it = mainFrameImpl; it != frame; it = toWebFrameImpl(it->traverseNext(true))) {
+    for (WebLocalFrameImpl* it = mainFrameImpl; it != frame; it = toWebLocalFrameImpl(it->traverseNext(true))) {
         TextFinder& finder = it->ensureTextFinder();
         if (finder.m_lastMatchCount > 0)
             ordinal += finder.m_lastMatchCount;
     }
     return ordinal;
 }
 
 bool TextFinder::shouldScopeMatches(const String& searchText)
 {
     // Don't scope if we can't find a frame or a view.
@@ skipping 75 matching lines @@
     if (!m_framesScopingCount)
         m_ownerFrame.increaseMatchCount(0, identifier);
 }
 
 int TextFinder::ordinalOfFirstMatch() const
 {
     return ordinalOfFirstMatchForFrame(&m_ownerFrame);
 }
 
 } // namespace blink