Changeset 87483 in webkit


Ignore:
Timestamp:
May 27, 2011 12:56:25 AM (13 years ago)
Author:
morrita@google.com
Message:

2011-05-23 MORITA Hajime <​morrita@google.com>

Reviewed by Tony Chang.

[Refactoring] DocumentMarker should be carried around as a pointer, not value.
​https://bugs.webkit.org/show_bug.cgi?id=61262

  • Changed return value of markersInRange() from Vector<DocumentMarker> to Vector<DocumentMarker*>.
  • Introduced markersFor() that returns Vector<DocumentMarker*>
  • Removed DocumentMarkerController::setRenderedRectForMarker() which now can be replaced by RenderedDocumentMarker::setRenderedRect().
  • This change didn't remove markersForNode() beucase there is patches on review which depends markersForNode(). I'll remove its call after these patches are landed.

No new tests. No behavior change.

  • WebCore.exp.in:
  • dom/DocumentMarkerController.cpp: (WebCore::DocumentMarkerController::addTextMatchMarker): (WebCore::DocumentMarkerController::markersFor): (WebCore::DocumentMarkerController::markersInRange): (WebCore::DocumentMarkerController::hasMarkers):
  • dom/DocumentMarkerController.h:
  • dom/RenderedDocumentMarker.h: (WebCore::toRenderedDocumentMarker):
  • editing/CompositeEditCommand.cpp: (WebCore::CompositeEditCommand::replaceTextInNodePreservingMarkers):
  • editing/DeleteSelectionCommand.cpp: (WebCore::DeleteSelectionCommand::originalStringForAutocorrectionAtBeginningOfSelection):
  • editing/Editor.cpp: (WebCore::Editor::selectionStartHasMarkerFor):
  • editing/SpellingCorrectionController.cpp: (WebCore::markersHaveIdenticalDescription): (WebCore::SpellingCorrectionController::respondToChangedSelection): (WebCore::SpellingCorrectionController::recordSpellcheckerResponseForModifiedCorrection): (WebCore::SpellingCorrectionController::processMarkersOnTextToBeReplacedByResult):
  • editing/SpellingCorrectionController.h: (WebCore::SpellingCorrectionController::shouldStartTimerFor):
  • rendering/InlineTextBox.cpp: (WebCore::InlineTextBox::paintSpellingOrGrammarMarker): (WebCore::InlineTextBox::paintTextMatchMarker): (WebCore::InlineTextBox::computeRectForReplacementMarker): (WebCore::InlineTextBox::paintDocumentMarkers):
  • rendering/InlineTextBox.h:
  • rendering/svg/SVGInlineFlowBox.cpp: (WebCore::SVGInlineFlowBox::computeTextMatchMarkerRectForRenderer):
Location:
trunk/Source/WebCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r87480 r87483  
     12011-05-23  MORITA Hajime  <morrita@google.com>
     2
     3        Reviewed by Tony Chang.
     4
     5        [Refactoring] DocumentMarker should be carried around as a pointer, not value.
     6        https://bugs.webkit.org/show_bug.cgi?id=61262
     7
     8        - Changed return value of markersInRange() from Vector<DocumentMarker> to Vector<DocumentMarker*>.
     9        - Introduced markersFor() that returns Vector<DocumentMarker*>
     10        - Removed DocumentMarkerController::setRenderedRectForMarker() which now can be replaced by
     11          RenderedDocumentMarker::setRenderedRect().
     12        - This change didn't remove markersForNode() beucase there is patches on review which depends
     13          markersForNode(). I'll remove its call after these patches are landed.
     14       
     15        No new tests. No behavior change.
     16
     17        * WebCore.exp.in:
     18        * dom/DocumentMarkerController.cpp:
     19        (WebCore::DocumentMarkerController::addTextMatchMarker):
     20        (WebCore::DocumentMarkerController::markersFor):
     21        (WebCore::DocumentMarkerController::markersInRange):
     22        (WebCore::DocumentMarkerController::hasMarkers):
     23        * dom/DocumentMarkerController.h:
     24        * dom/RenderedDocumentMarker.h:
     25        (WebCore::toRenderedDocumentMarker):
     26        * editing/CompositeEditCommand.cpp:
     27        (WebCore::CompositeEditCommand::replaceTextInNodePreservingMarkers):
     28        * editing/DeleteSelectionCommand.cpp:
     29        (WebCore::DeleteSelectionCommand::originalStringForAutocorrectionAtBeginningOfSelection):
     30        * editing/Editor.cpp:
     31        (WebCore::Editor::selectionStartHasMarkerFor):
     32        * editing/SpellingCorrectionController.cpp:
     33        (WebCore::markersHaveIdenticalDescription):
     34        (WebCore::SpellingCorrectionController::respondToChangedSelection):
     35        (WebCore::SpellingCorrectionController::recordSpellcheckerResponseForModifiedCorrection):
     36        (WebCore::SpellingCorrectionController::processMarkersOnTextToBeReplacedByResult):
     37        * editing/SpellingCorrectionController.h:
     38        (WebCore::SpellingCorrectionController::shouldStartTimerFor):
     39        * rendering/InlineTextBox.cpp:
     40        (WebCore::InlineTextBox::paintSpellingOrGrammarMarker):
     41        (WebCore::InlineTextBox::paintTextMatchMarker):
     42        (WebCore::InlineTextBox::computeRectForReplacementMarker):
     43        (WebCore::InlineTextBox::paintDocumentMarkers):
     44        * rendering/InlineTextBox.h:
     45        * rendering/svg/SVGInlineFlowBox.cpp:
     46        (WebCore::SVGInlineFlowBox::computeTextMatchMarkerRectForRenderer):
     47
    1482011-05-26  MORITA Hajime  <morrita@google.com>
    249

  • trunk/Source/WebCore/WebCore.exp.in

    r87335 r87483  
    584584__ZN7WebCore24CachedResourceHandleBase11setResourceEPNS_14CachedResourceE
    585585__ZN7WebCore24DocumentMarkerController13removeMarkersENS_14DocumentMarker11MarkerTypesE
    586 __ZN7WebCore24DocumentMarkerController14markersForNodeEPNS_4NodeE
    587 __ZN7WebCore24DocumentMarkerController14markersForNodeEPNS_4NodeE
    588586__ZN7WebCore24DocumentMarkerController23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE
    589587__ZN7WebCore24contextMenuItemTagItalicEv

  • trunk/Source/WebCore/dom/DocumentMarkerController.cpp

    r86813 r87483  
    9494            // matches off-screen are (that haven't been painted yet).
    9595            Node* node = textPiece->startContainer(exception);
    96             Vector<DocumentMarker> markers = markersForNode(node);
    97             setRenderedRectForMarker(textPiece->startContainer(exception),
    98                                      markers[markers.size() - 1],
    99                                      range->boundingBox());
     96            Vector<DocumentMarker*> markers = markersFor(node);
     97            static_cast<RenderedDocumentMarker*>(markers[markers.size() - 1])->setRenderedRect(range->boundingBox());
    10098        }
    10199    }
    … …  
    317315}
    318316
     317Vector<DocumentMarker*> DocumentMarkerController::markersFor(Node* node)
     318{
     319    Vector<DocumentMarker*> result;
     320    MarkerList* list = m_markers.get(node);
     321    if (!list)
     322        return result;
     323
     324    for (size_t i = 0; i < list->size(); ++i)
     325        result.append(&(list->at(i)));
     326
     327    return result;
     328}
     329
     330// FIXME: Should be removed after all relevant patches are landed
    319331Vector<DocumentMarker> DocumentMarkerController::markersForNode(Node* node)
    320332{
    … …  
    330342}
    331343
    332 Vector<DocumentMarker> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
     344Vector<DocumentMarker*> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
    333345{
    334346    if (!possiblyHasMarkers(markerTypes))
    335         return Vector<DocumentMarker>();
    336 
    337     Vector<DocumentMarker> foundMarkers;
     347        return Vector<DocumentMarker*>();
     348
     349    Vector<DocumentMarker*> foundMarkers;
    338350
    339351    Node* startContainer = range->startContainer();
    … …  
    344356    Node* pastLastNode = range->pastLastNode();
    345357    for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
    346         Vector<DocumentMarker> markers = markersForNode(node);
    347         Vector<DocumentMarker>::const_iterator end = markers.end();
    348         for (Vector<DocumentMarker>::const_iterator it = markers.begin(); it != end; ++it) {
    349             if (!markerTypes.contains(it->type()))
    350                 continue;
    351             if (node == startContainer && it->endOffset() <= static_cast<unsigned>(range->startOffset()))
    352                 continue;
    353             if (node == endContainer && it->startOffset() >= static_cast<unsigned>(range->endOffset()))
    354                 continue;
    355             foundMarkers.append(*it);
     358        Vector<DocumentMarker*> markers = markersFor(node);
     359        Vector<DocumentMarker*>::const_iterator end = markers.end();
     360        for (Vector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
     361            DocumentMarker* marker = *it;
     362            if (!markerTypes.contains(marker->type()))
     363                continue;
     364            if (node == startContainer && marker->endOffset() <= static_cast<unsigned>(range->startOffset()))
     365                continue;
     366            if (node == endContainer && marker->startOffset() >= static_cast<unsigned>(range->endOffset()))
     367                continue;
     368            foundMarkers.append(marker);
    356369        }
    357370    }
    … …  
    491504}
    492505
    493 void DocumentMarkerController::setRenderedRectForMarker(Node* node, const DocumentMarker& marker, const IntRect& r)
    494 {
    495     MarkerList* list = m_markers.get(node);
    496     if (!list) {
    497         ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
    498         return;
    499     }
    500 
    501     size_t markerCount = list->size();
    502     for (size_t markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    503         RenderedDocumentMarker& m = list->at(markerIndex);
    504         if (m == marker) {
    505             m.setRenderedRect(r);
    506             return;
    507         }
    508     }
    509 
    510     ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
    511 }
    512 
    513506void DocumentMarkerController::invalidateRenderedRectsForMarkersInRect(const IntRect& r)
    514507{
    … …  
    610603    Node* pastLastNode = range->pastLastNode();
    611604    for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
    612         Vector<DocumentMarker> markers = markersForNode(node);
    613         Vector<DocumentMarker>::const_iterator end = markers.end();
    614         for (Vector<DocumentMarker>::const_iterator it = markers.begin(); it != end; ++it) {
    615             if (!markerTypes.contains(it->type()))
    616                 continue;
    617             if (node == startContainer && it->endOffset() <= static_cast<unsigned>(range->startOffset()))
    618                 continue;
    619             if (node == endContainer && it->startOffset() >= static_cast<unsigned>(range->endOffset()))
     605        Vector<DocumentMarker*> markers = markersFor(node);
     606        Vector<DocumentMarker*>::const_iterator end = markers.end();
     607        for (Vector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
     608            DocumentMarker* marker = *it;
     609            if (!markerTypes.contains(marker->type()))
     610                continue;
     611            if (node == startContainer && marker->endOffset() <= static_cast<unsigned>(range->startOffset()))
     612                continue;
     613            if (node == endContainer && marker->startOffset() >= static_cast<unsigned>(range->endOffset()))
    620614                continue;
    621615            return true;

  • trunk/Source/WebCore/dom/DocumentMarkerController.h

    r86813 r87483  
    6565    void removeMarkers(Node*, DocumentMarker::MarkerTypes = DocumentMarker::AllMarkers());
    6666    void repaintMarkers(DocumentMarker::MarkerTypes = DocumentMarker::AllMarkers());
    67     void setRenderedRectForMarker(Node*, const DocumentMarker&, const IntRect&);
    6867    void invalidateRenderedRectsForMarkersInRect(const IntRect&);
    6968    void shiftMarkers(Node*, unsigned startOffset, int delta);
    … …  
    7271
    7372    DocumentMarker* markerContainingPoint(const IntPoint&, DocumentMarker::MarkerType);
     73    Vector<DocumentMarker*> markersFor(Node*);
     74    Vector<DocumentMarker*> markersInRange(Range*, DocumentMarker::MarkerTypes);
    7475    Vector<DocumentMarker> markersForNode(Node*);
    75     Vector<DocumentMarker> markersInRange(Range*, DocumentMarker::MarkerTypes);
    7676    Vector<IntRect> renderedRectsForMarkers(DocumentMarker::MarkerType);
    7777    void clearDescriptionOnMarkersIntersectingRange(Range*, DocumentMarker::MarkerTypes);

  • trunk/Source/WebCore/dom/RenderedDocumentMarker.h

    r85118 r87483  
    6363}
    6464
     65inline RenderedDocumentMarker* toRenderedDocumentMarker(DocumentMarker* marker)
     66{
     67    return static_cast<RenderedDocumentMarker*>(marker);
     68}
     69
    6570} // namespace
    6671

  • trunk/Source/WebCore/editing/CompositeEditCommand.cpp

    r87067 r87483  
    343343    RefPtr<Text> node(prpNode);
    344344    DocumentMarkerController* markerController = document()->markers();
    345     Vector<DocumentMarker> markers = markerController->markersInRange(Range::create(document(), node, offset, node, offset + count).get(), DocumentMarker::AllMarkers());
     345    Vector<DocumentMarker*> markers = markerController->markersInRange(Range::create(document(), node, offset, node, offset + count).get(), DocumentMarker::AllMarkers());
    346346    replaceTextInNode(node, offset, count, replacementText);
    347347    RefPtr<Range> newRange = Range::create(document(), node, offset, node, offset + replacementText.length());
    348348    for (size_t i = 0; i < markers.size(); ++i) {
    349         if (markers[i].hasDescription())
    350             markerController->addMarker(newRange.get(), markers[i].type(), markers[i].description());
     349        if (markers[i]->hasDescription())
     350            markerController->addMarker(newRange.get(), markers[i]->type(), markers[i]->description());
    351351        else
    352             markerController->addMarker(newRange.get(), markers[i].type());
     352            markerController->addMarker(newRange.get(), markers[i]->type());
    353353    }
    354354}

  • trunk/Source/WebCore/editing/DeleteSelectionCommand.cpp

    r86813 r87483  
    760760
    761761    RefPtr<Range> rangeOfFirstCharacter = Range::create(document(), startOfSelection.deepEquivalent(), nextPosition.deepEquivalent());
    762     Vector<DocumentMarker> markers = document()->markers()->markersInRange(rangeOfFirstCharacter.get(), DocumentMarker::Autocorrected);
     762    Vector<DocumentMarker*> markers = document()->markers()->markersInRange(rangeOfFirstCharacter.get(), DocumentMarker::Autocorrected);
    763763    for (size_t i = 0; i < markers.size(); ++i) {
    764         const DocumentMarker& marker = markers[i];
    765         int startOffset = marker.startOffset();
     764        const DocumentMarker* marker = markers[i];
     765        int startOffset = marker->startOffset();
    766766        if (startOffset == startOfSelection.deepEquivalent().offsetInContainerNode())
    767             return marker.description();
     767            return marker->description();
    768768    }
    769769    return String();

  • trunk/Source/WebCore/editing/Editor.cpp

    r87117 r87483  
    32003200    unsigned int startOffset = static_cast<unsigned int>(from);
    32013201    unsigned int endOffset = static_cast<unsigned int>(from + length);
    3202     Vector<DocumentMarker> markers = m_frame->document()->markers()->markersForNode(node);
     3202    Vector<DocumentMarker*> markers = m_frame->document()->markers()->markersFor(node);
    32033203    for (size_t i = 0; i < markers.size(); ++i) {
    3204         DocumentMarker marker = markers[i];
    3205         if (marker.startOffset() <= startOffset && endOffset <= marker.endOffset() && marker.type() == markerType)
     3204        DocumentMarker* marker = markers[i];
     3205        if (marker->startOffset() <= startOffset && endOffset <= marker->endOffset() && marker->type() == markerType)
    32063206            return true;
    32073207    }

  • trunk/Source/WebCore/editing/SpellingCorrectionController.cpp

    r87117 r87483  
    7373}
    7474
    75 static bool markersHaveIdenticalDescription(const Vector<DocumentMarker>& markers)
     75static bool markersHaveIdenticalDescription(const Vector<DocumentMarker*>& markers)
    7676{
    7777    if (markers.isEmpty())
    7878        return true;
    7979
    80     const String& description = markers[0].description();
     80    const String& description = markers[0]->description();
    8181    for (size_t i = 1; i < markers.size(); ++i) {
    82         if (description != markers[i].description())
     82        if (description != markers[i]->description())
    8383            return false;
    8484    }
    … …  
    404404    Node* node = position.containerNode();
    405405    int endOffset = position.offsetInContainerNode();
    406     Vector<DocumentMarker> markers = node->document()->markers()->markersForNode(node);
     406    Vector<DocumentMarker*> markers = node->document()->markers()->markersFor(node);
    407407    size_t markerCount = markers.size();
    408408    for (size_t i = 0; i < markerCount; ++i) {
    409         const DocumentMarker& marker = markers[i];
     409        const DocumentMarker* marker = markers[i];
    410410        if (!shouldStartTimerFor(marker, endOffset))
    411411            continue;
    412         RefPtr<Range> wordRange = Range::create(m_frame->document(), node, marker.startOffset(), node, marker.endOffset());
     412        RefPtr<Range> wordRange = Range::create(m_frame->document(), node, marker->startOffset(), node, marker->endOffset());
    413413        String currentWord = plainText(wordRange.get());
    414414        if (!currentWord.length())
    … …  
    417417        m_correctionPanelInfo.rangeToBeReplaced = wordRange;
    418418        m_correctionPanelInfo.replacedString = currentWord;
    419         if (marker.type() == DocumentMarker::Spelling)
     419        if (marker->type() == DocumentMarker::Spelling)
    420420            startCorrectionPanelTimer(CorrectionPanelInfo::PanelTypeSpellingSuggestions);
    421421        else {
    422             m_correctionPanelInfo.replacementString = marker.description();
     422            m_correctionPanelInfo.replacementString = marker->description();
    423423            startCorrectionPanelTimer(CorrectionPanelInfo::PanelTypeReversion);
    424424        }
    … …  
    495495        return;
    496496    DocumentMarkerController* markers = rangeOfCorrection->startContainer()->document()->markers();
    497     Vector<DocumentMarker> correctedOnceMarkers = markers->markersInRange(rangeOfCorrection, DocumentMarker::Autocorrected);
     497    Vector<DocumentMarker*> correctedOnceMarkers = markers->markersInRange(rangeOfCorrection, DocumentMarker::Autocorrected);
    498498    if (correctedOnceMarkers.isEmpty())
    499499        return;
    … …  
    501501    // Spelling corrected text has been edited. We need to determine whether user has reverted it to original text or
    502502    // edited it to something else, and notify spellchecker accordingly.
    503     if (markersHaveIdenticalDescription(correctedOnceMarkers) && correctedOnceMarkers[0].description() == corrected)
     503    if (markersHaveIdenticalDescription(correctedOnceMarkers) && correctedOnceMarkers[0]->description() == corrected)
    504504        client()->recordAutocorrectionResponse(EditorClient::AutocorrectionReverted, corrected, correction);
    505505    else
    … …  
    551551    RefPtr<Range> precedingCharacterRange = Range::create(m_frame->document(), precedingCharacterPosition, beginningOfRange);
    552552
    553     Vector<DocumentMarker> markers = markerController->markersInRange(precedingCharacterRange.get(), DocumentMarker::DeletedAutocorrection);
     553    Vector<DocumentMarker*> markers = markerController->markersInRange(precedingCharacterRange.get(), DocumentMarker::DeletedAutocorrection);
    554554
    555555    for (size_t i = 0; i < markers.size(); ++i) {
    556         if (markers[i].description() == stringToBeReplaced)
     556        if (markers[i]->description() == stringToBeReplaced)
    557557            return false;
    558558    }

  • trunk/Source/WebCore/editing/SpellingCorrectionController.h

    r87122 r87483  
    117117    void recordAutocorrectionResponseReversed(const String& replacedString, const String& replacementString);
    118118
    119     bool shouldStartTimerFor(const DocumentMarker& marker, int endOffset) const
     119    bool shouldStartTimerFor(const DocumentMarker* marker, int endOffset) const
    120120    {
    121         return (((marker.type() == DocumentMarker::Replacement && !marker.description().isNull())
    122                  || marker.type() == DocumentMarker::Spelling) && static_cast<int>(marker.endOffset()) == endOffset);
     121        return (((marker->type() == DocumentMarker::Replacement && !marker->description().isNull())
     122                 || marker->type() == DocumentMarker::Spelling) && static_cast<int>(marker->endOffset()) == endOffset);
    123123    }
    124124

  • trunk/Source/WebCore/rendering/InlineTextBox.cpp

    r87152 r87483  
    3535#include "Page.h"
    3636#include "PaintInfo.h"
     37#include "RenderedDocumentMarker.h"
    3738#include "RenderArena.h"
    3839#include "RenderBR.h"
    … …  
    970971}
    971972
    972 void InlineTextBox::paintSpellingOrGrammarMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, const DocumentMarker& marker, RenderStyle* style, const Font& font, bool grammar)
     973void InlineTextBox::paintSpellingOrGrammarMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, RenderStyle* style, const Font& font, bool grammar)
    973974{
    974975    // Never print spelling/grammar markers (5327887)
    … …  
    984985    // Determine whether we need to measure text
    985986    bool markerSpansWholeBox = true;
    986     if (m_start <= (int)marker.startOffset())
     987    if (m_start <= (int)marker->startOffset())
    987988        markerSpansWholeBox = false;
    988     if ((end() + 1) != marker.endOffset()) // end points at the last char, not past it
     989    if ((end() + 1) != marker->endOffset()) // end points at the last char, not past it
    989990        markerSpansWholeBox = false;
    990991    if (m_truncation != cNoTruncation)
    … …  
    992993
    993994    if (!markerSpansWholeBox || grammar) {
    994         int startPosition = max<int>(marker.startOffset() - m_start, 0);
    995         int endPosition = min<int>(marker.endOffset() - m_start, m_len);
     995        int startPosition = max<int>(marker->startOffset() - m_start, 0);
     996        int endPosition = min<int>(marker->endOffset() - m_start, m_len);
    996997       
    997998        if (m_truncation != cNoTruncation)
    … …  
    10141015            markerRect.move(-boxOrigin.x(), -boxOrigin.y());
    10151016            markerRect = renderer()->localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
    1016             renderer()->document()->markers()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
     1017            toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
    10171018        }
    10181019    }
    … …  
    10351036        underlineOffset = baseline + 2;
    10361037    }
    1037     pt->drawLineForTextChecking(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, textCheckingLineStyleForMarkerType(marker.type()));
    1038 }
    1039 
    1040 void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, const DocumentMarker& marker, RenderStyle* style, const Font& font)
     1038    pt->drawLineForTextChecking(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, textCheckingLineStyleForMarkerType(marker->type()));
     1039}
     1040
     1041void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const FloatPoint& boxOrigin, DocumentMarker* marker, RenderStyle* style, const Font& font)
    10411042{
    10421043    // Use same y positioning and height as for selection, so that when the selection and this highlight are on
    … …  
    10451046    int selHeight = selectionHeight();
    10461047
    1047     int sPos = max(marker.startOffset() - m_start, (unsigned)0);
    1048     int ePos = min(marker.endOffset() - m_start, (unsigned)m_len);
     1048    int sPos = max(marker->startOffset() - m_start, (unsigned)0);
     1049    int ePos = min(marker->endOffset() - m_start, (unsigned)m_len);
    10491050    TextRun run = constructTextRun(style, font);
     1051
    10501052    // Always compute and store the rect associated with this marker. The computed rect is in absolute coordinates.
    10511053    IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, IntPoint(m_x, selectionTop()), selHeight, sPos, ePos));
    10521054    markerRect = renderer()->localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
    1053     renderer()->document()->markers()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
     1055    toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
    10541056   
    10551057    // Optionally highlight the text
    10561058    if (renderer()->frame()->editor()->markedTextMatchesAreHighlighted()) {
    1057         Color color = marker.activeMatch() ?
     1059        Color color = marker->activeMatch() ?
    10581060            renderer()->theme()->platformActiveTextSearchHighlightColor() :
    10591061            renderer()->theme()->platformInactiveTextSearchHighlightColor();
    … …  
    10651067}
    10661068
    1067 void InlineTextBox::computeRectForReplacementMarker(const DocumentMarker& marker, RenderStyle* style, const Font& font)
     1069void InlineTextBox::computeRectForReplacementMarker(DocumentMarker* marker, RenderStyle* style, const Font& font)
    10681070{
    10691071    // Replacement markers are not actually drawn, but their rects need to be computed for hit testing.
    … …  
    10711073    int h = selectionHeight();
    10721074   
    1073 
    1074     int sPos = max(marker.startOffset() - m_start, (unsigned)0);
    1075     int ePos = min(marker.endOffset() - m_start, (unsigned)m_len);
     1075    int sPos = max(marker->startOffset() - m_start, (unsigned)0);
     1076    int ePos = min(marker->endOffset() - m_start, (unsigned)m_len);
    10761077    TextRun run = constructTextRun(style, font);
    10771078    IntPoint startPoint = IntPoint(m_x, y);
    … …  
    10801081    IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, h, sPos, ePos));
    10811082    markerRect = renderer()->localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
    1082     renderer()->document()->markers()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
     1083    toRenderedDocumentMarker(marker)->setRenderedRect(markerRect);
    10831084}
    10841085   
    … …  
    10881089        return;
    10891090
    1090     Vector<DocumentMarker> markers = renderer()->document()->markers()->markersForNode(renderer()->node());
    1091     Vector<DocumentMarker>::iterator markerIt = markers.begin();
     1091    Vector<DocumentMarker*> markers = renderer()->document()->markers()->markersFor(renderer()->node());
     1092    Vector<DocumentMarker*>::const_iterator markerIt = markers.begin();
    10921093
    10931094    // Give any document markers that touch this run a chance to draw before the text has been drawn.
    10941095    // Note end() points at the last char, not one past it like endOffset and ranges do.
    10951096    for ( ; markerIt != markers.end(); markerIt++) {
    1096         const DocumentMarker& marker = *markerIt;
     1097        DocumentMarker* marker = *markerIt;
    10971098       
    10981099        // Paint either the background markers or the foreground markers, but not both
    1099         switch (marker.type()) {
     1100        switch (marker->type()) {
    11001101            case DocumentMarker::Grammar:
    11011102            case DocumentMarker::Spelling:
    … …  
    11131114        }
    11141115
    1115         if (marker.endOffset() <= start())
     1116        if (marker->endOffset() <= start())
    11161117            // marker is completely before this run.  This might be a marker that sits before the
    11171118            // first run we draw, or markers that were within runs we skipped due to truncation.
    11181119            continue;
    11191120       
    1120         if (marker.startOffset() > end())
     1121        if (marker->startOffset() > end())
    11211122            // marker is completely after this run, bail.  A later run will paint it.
    11221123            break;
    11231124       
    11241125        // marker intersects this run.  Paint it.
    1125         switch (marker.type()) {
     1126        switch (marker->type()) {
    11261127            case DocumentMarker::Spelling:
    11271128                paintSpellingOrGrammarMarker(pt, boxOrigin, marker, style, font, false);

  • trunk/Source/WebCore/rendering/InlineTextBox.h

    r87152 r87483  
    176176    void paintDecoration(GraphicsContext*, const FloatPoint& boxOrigin, int decoration, const ShadowData*);
    177177    void paintSelection(GraphicsContext*, const FloatPoint& boxOrigin, RenderStyle*, const Font&);
    178     void paintSpellingOrGrammarMarker(GraphicsContext*, const FloatPoint& boxOrigin, const DocumentMarker&, RenderStyle*, const Font&, bool grammar);
    179     void paintTextMatchMarker(GraphicsContext*, const FloatPoint& boxOrigin, const DocumentMarker&, RenderStyle*, const Font&);
    180     void computeRectForReplacementMarker(const DocumentMarker&, RenderStyle*, const Font&);
     178    void paintSpellingOrGrammarMarker(GraphicsContext*, const FloatPoint& boxOrigin, DocumentMarker*, RenderStyle*, const Font&, bool grammar);
     179    void paintTextMatchMarker(GraphicsContext*, const FloatPoint& boxOrigin, DocumentMarker*, RenderStyle*, const Font&);
     180    void computeRectForReplacementMarker(DocumentMarker*, RenderStyle*, const Font&);
    181181
    182182    TextRun::ExpansionBehavior expansionBehavior() const

  • trunk/Source/WebCore/rendering/svg/SVGInlineFlowBox.cpp

    r86813 r87483  
    2828#include "GraphicsContext.h"
    2929#include "RenderSVGInlineText.h"
     30#include "RenderedDocumentMarker.h"
    3031#include "SVGInlineTextBox.h"
    3132#include "SVGRenderSupport.h"
    … …  
    9394    AffineTransform fragmentTransform;
    9495    Document* document = textRenderer->document();
    95     Vector<DocumentMarker> markers = document->markers()->markersForNode(textRenderer->node());
     96    Vector<DocumentMarker*> markers = document->markers()->markersFor(textRenderer->node());
    9697
    97     Vector<DocumentMarker>::iterator markerEnd = markers.end();
    98     for (Vector<DocumentMarker>::iterator markerIt = markers.begin(); markerIt != markerEnd; ++markerIt) {
    99         const DocumentMarker& marker = *markerIt;
     98    Vector<DocumentMarker*>::iterator markerEnd = markers.end();
     99    for (Vector<DocumentMarker*>::iterator markerIt = markers.begin(); markerIt != markerEnd; ++markerIt) {
     100        DocumentMarker* marker = *markerIt;
    100101
    101102        // SVG is only interessted in the TextMatch marker, for now.
    102         if (marker.type() != DocumentMarker::TextMatch)
     103        if (marker->type() != DocumentMarker::TextMatch)
    103104            continue;
    104105
    … …  
    110111            SVGInlineTextBox* textBox = static_cast<SVGInlineTextBox*>(box);
    111112
    112             int markerStartPosition = max<int>(marker.startOffset() - textBox->start(), 0);
    113             int markerEndPosition = min<int>(marker.endOffset() - textBox->start(), textBox->len());
     113            int markerStartPosition = max<int>(marker->startOffset() - textBox->start(), 0);
     114            int markerEndPosition = min<int>(marker->endOffset() - textBox->start(), textBox->len());
    114115
    115116            if (markerStartPosition >= markerEndPosition)
    … …  
    138139        }
    139140
    140         document->markers()->setRenderedRectForMarker(node, marker, textRenderer->localToAbsoluteQuad(markerRect).enclosingBoundingBox());
     141        toRenderedDocumentMarker(marker)->setRenderedRect(textRenderer->localToAbsoluteQuad(markerRect).enclosingBoundingBox());
    141142    }
    142143}
Note: See TracChangeset for help on using the changeset viewer.