Changeset 86647 in webkit


Ignore:
Timestamp:
May 16, 2011 6:11:13 PM (13 years ago)
Author:
morrita@google.com
Message:

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

Reviewed by Tony Chang.

[Refactoring] Member variables of DocumentMarker should be encapsulated.
​https://bugs.webkit.org/show_bug.cgi?id=56814

  • Moved DocumentMarker's member variables to private and added getters for them.
  • Added DocumentMarker setters and constructors, which contain assertions against m_type values because description and activeMatch are used with specific type of MarkerType.
  • Moved chromium's WebKit::WebFrameImpl::addMarker() to DocumentMarkerController because it accesses DocumentMarker internals.
  • Moved a version of DMC::addMarker() to private and add alternatives that hide internals of DocumentMarker. (The internal will be renewed by upcoming change.)
  • dom/DocumentMarker.h: (WebCore::DocumentMarker::type): (WebCore::DocumentMarker::startOffset): (WebCore::DocumentMarker::endOffset): (WebCore::DocumentMarker::description): (WebCore::DocumentMarker::hasDescription): (WebCore::DocumentMarker::activeMatch): (WebCore::DocumentMarker::clearDescription): (WebCore::DocumentMarker::setStartOffset): (WebCore::DocumentMarker::setEndOffset): (WebCore::DocumentMarker::operator==): (WebCore::DocumentMarker::DocumentMarker): (WebCore::DocumentMarker::shiftOffsets): (WebCore::DocumentMarker::setActiveMatch):
  • dom/DocumentMarkerController.cpp: (WebCore::DocumentMarkerController::addMarker): (WebCore::DocumentMarkerController::addTextMatchMarker): (WebCore::DocumentMarkerController::copyMarkers): (WebCore::DocumentMarkerController::removeMarkers): (WebCore::DocumentMarkerController::markerContainingPoint): (WebCore::DocumentMarkerController::markersInRange): (WebCore::DocumentMarkerController::renderedRectsForMarkers): (WebCore::DocumentMarkerController::removeMarkersFromList): (WebCore::DocumentMarkerController::repaintMarkers): (WebCore::DocumentMarkerController::shiftMarkers): (WebCore::DocumentMarkerController::setMarkersActive): (WebCore::DocumentMarkerController::hasMarkers): (WebCore::DocumentMarkerController::clearDescriptionOnMarkersIntersectingRange): (WebCore::DocumentMarkerController::showMarkers):
  • dom/DocumentMarkerController.h:
  • editing/CompositeEditCommand.cpp: (WebCore::CompositeEditCommand::replaceTextInNodePreservingMarkers):
  • editing/DeleteSelectionCommand.cpp: (WebCore::DeleteSelectionCommand::originalStringForAutocorrectionAtBeginningOfSelection):
  • editing/Editor.cpp: (WebCore::Editor::selectionStartHasMarkerFor):
  • editing/SpellingCorrectionController.cpp: (WebCore::SpellingCorrectionController::respondToChangedSelection):
  • editing/SpellingCorrectionController.h: (WebCore::SpellingCorrectionController::shouldStartTimerFor):
  • rendering/HitTestResult.cpp: (WebCore::HitTestResult::spellingToolTip): (WebCore::HitTestResult::replacedString):
  • rendering/InlineTextBox.cpp: (WebCore::InlineTextBox::paintSpellingOrGrammarMarker): (WebCore::InlineTextBox::paintTextMatchMarker): (WebCore::InlineTextBox::computeRectForReplacementMarker): (WebCore::InlineTextBox::paintDocumentMarkers):
  • rendering/svg/SVGInlineFlowBox.cpp: (WebCore::SVGInlineFlowBox::computeTextMatchMarkerRectForRenderer):

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

Reviewed by Tony Chang.

[Refactoring] Member variables of DocumentMarker should be encapsulated.
​https://bugs.webkit.org/show_bug.cgi?id=56814

Moved addMarker() implementation to
WebCore::DocumentMarkerController::addTextMatchMarker().

  • src/WebFrameImpl.cpp: (WebKit::WebFrameImpl::addMarker):
Location:
trunk/Source
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r86646 r86647  
     12011-05-16  MORITA Hajime  <morrita@google.com>
     2
     3        Reviewed by Tony Chang.
     4
     5        [Refactoring] Member variables of DocumentMarker should be encapsulated.       
     6        https://bugs.webkit.org/show_bug.cgi?id=56814
     7
     8        - Moved DocumentMarker's member variables to private and added getters for them.
     9        - Added DocumentMarker setters and constructors, which contain assertions against m_type values
     10          because description and activeMatch are used with specific type of MarkerType.
     11        - Moved chromium's WebKit::WebFrameImpl::addMarker() to DocumentMarkerController because
     12          it accesses DocumentMarker internals.
     13        - Moved a version of DMC::addMarker() to private and add alternatives that hide
     14          internals of DocumentMarker. (The internal will be renewed by upcoming change.)
     15       
     16        * dom/DocumentMarker.h:
     17        (WebCore::DocumentMarker::type):
     18        (WebCore::DocumentMarker::startOffset):
     19        (WebCore::DocumentMarker::endOffset):
     20        (WebCore::DocumentMarker::description):
     21        (WebCore::DocumentMarker::hasDescription):
     22        (WebCore::DocumentMarker::activeMatch):
     23        (WebCore::DocumentMarker::clearDescription):
     24        (WebCore::DocumentMarker::setStartOffset):
     25        (WebCore::DocumentMarker::setEndOffset):
     26        (WebCore::DocumentMarker::operator==):
     27        (WebCore::DocumentMarker::DocumentMarker):
     28        (WebCore::DocumentMarker::shiftOffsets):
     29        (WebCore::DocumentMarker::setActiveMatch):
     30        * dom/DocumentMarkerController.cpp:
     31        (WebCore::DocumentMarkerController::addMarker):
     32        (WebCore::DocumentMarkerController::addTextMatchMarker):
     33        (WebCore::DocumentMarkerController::copyMarkers):
     34        (WebCore::DocumentMarkerController::removeMarkers):
     35        (WebCore::DocumentMarkerController::markerContainingPoint):
     36        (WebCore::DocumentMarkerController::markersInRange):
     37        (WebCore::DocumentMarkerController::renderedRectsForMarkers):
     38        (WebCore::DocumentMarkerController::removeMarkersFromList):
     39        (WebCore::DocumentMarkerController::repaintMarkers):
     40        (WebCore::DocumentMarkerController::shiftMarkers):
     41        (WebCore::DocumentMarkerController::setMarkersActive):
     42        (WebCore::DocumentMarkerController::hasMarkers):
     43        (WebCore::DocumentMarkerController::clearDescriptionOnMarkersIntersectingRange):
     44        (WebCore::DocumentMarkerController::showMarkers):
     45        * dom/DocumentMarkerController.h:
     46        * editing/CompositeEditCommand.cpp:
     47        (WebCore::CompositeEditCommand::replaceTextInNodePreservingMarkers):
     48        * editing/DeleteSelectionCommand.cpp:
     49        (WebCore::DeleteSelectionCommand::originalStringForAutocorrectionAtBeginningOfSelection):
     50        * editing/Editor.cpp:
     51        (WebCore::Editor::selectionStartHasMarkerFor):
     52        * editing/SpellingCorrectionController.cpp:
     53        (WebCore::SpellingCorrectionController::respondToChangedSelection):
     54        * editing/SpellingCorrectionController.h:
     55        (WebCore::SpellingCorrectionController::shouldStartTimerFor):
     56        * rendering/HitTestResult.cpp:
     57        (WebCore::HitTestResult::spellingToolTip):
     58        (WebCore::HitTestResult::replacedString):
     59        * rendering/InlineTextBox.cpp:
     60        (WebCore::InlineTextBox::paintSpellingOrGrammarMarker):
     61        (WebCore::InlineTextBox::paintTextMatchMarker):
     62        (WebCore::InlineTextBox::computeRectForReplacementMarker):
     63        (WebCore::InlineTextBox::paintDocumentMarkers):
     64        * rendering/svg/SVGInlineFlowBox.cpp:
     65        (WebCore::SVGInlineFlowBox::computeTextMatchMarkerRectForRenderer):
     66
    1672011-05-16  Martin Robinson  <mrobinson@igalia.com>
    268

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

    r86295 r86647  
    8585        }
    8686    };
    87    
    88     MarkerType type;
    89     unsigned startOffset;
    90     unsigned endOffset;
    91     String description;
    92     bool activeMatch;
     87
     88
     89    DocumentMarker();
     90    DocumentMarker(MarkerType, unsigned startOffset, unsigned endOffset);
     91    DocumentMarker(MarkerType, unsigned startOffset, unsigned endOffset, const String& description);
     92    DocumentMarker(unsigned startOffset, unsigned endOffset, bool activeMatch);
     93
     94    MarkerType type() const { return m_type; }
     95    unsigned startOffset() const { return m_startOffset; }
     96    unsigned endOffset() const { return m_endOffset; }
     97    const String& description() const { return m_description; }
     98    bool hasDescription() const { return !m_description.isEmpty(); }
     99    bool activeMatch() const { return m_activeMatch; }
     100
     101    void setActiveMatch(bool);
     102    void clearDescription() { m_description = String(); }
     103
     104    // Offset modifications are done by DocumentMarkerController.
     105    // Other classes should not call following setters.
     106    void setStartOffset(unsigned offset) { m_startOffset = offset; }
     107    void setEndOffset(unsigned offset) { m_endOffset = offset; }
     108    void shiftOffsets(int delta);
    93109
    94110    bool operator==(const DocumentMarker& o) const
    95111    {
    96         return type == o.type && startOffset == o.startOffset && endOffset == o.endOffset;
     112        return type() == o.type() && startOffset() == o.startOffset() && endOffset() == o.endOffset();
    97113    }
    98114
    … …  
    101117        return !(*this == o);
    102118    }
     119
     120private:   
     121    MarkerType m_type;
     122    unsigned m_startOffset;
     123    unsigned m_endOffset;
     124    String m_description;
     125    bool m_activeMatch;
    103126};
     127
     128inline DocumentMarker::DocumentMarker()
     129    : m_type(Spelling), m_startOffset(0), m_endOffset(0), m_activeMatch(false)
     130{
     131}
     132
     133inline DocumentMarker::DocumentMarker(MarkerType type, unsigned startOffset, unsigned endOffset)
     134    : m_type(type), m_startOffset(startOffset), m_endOffset(endOffset), m_activeMatch(false)
     135{
     136}
     137
     138inline DocumentMarker::DocumentMarker(MarkerType type, unsigned startOffset, unsigned endOffset, const String& description)
     139    : m_type(type), m_startOffset(startOffset), m_endOffset(endOffset), m_description(description), m_activeMatch(false)
     140{
     141    ASSERT(type == DocumentMarker::Grammar || DocumentMarker::Autocorrected);
     142}
     143
     144inline DocumentMarker::DocumentMarker(unsigned startOffset, unsigned endOffset, bool activeMatch)
     145    : m_type(DocumentMarker::TextMatch), m_startOffset(startOffset), m_endOffset(endOffset), m_activeMatch(activeMatch)
     146{
     147}
     148
     149inline void DocumentMarker::shiftOffsets(int delta)
     150{
     151    m_startOffset += delta;
     152    m_endOffset +=  delta;
     153}
     154
     155inline void DocumentMarker::setActiveMatch(bool active)
     156{
     157    ASSERT(m_type == DocumentMarker::TextMatch);
     158    m_activeMatch = active;
     159}
    104160
    105161} // namespace WebCore

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

    r86325 r86647  
    5555}
    5656
    57 void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type, String description)
     57void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type, const String& description)
    5858{
    5959    // Use a TextIterator to visit the potentially multiple nodes the range covers.
    … …  
    6161        RefPtr<Range> textPiece = markedText.range();
    6262        int exception = 0;
    63         DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception), description, false};
    64         addMarker(textPiece->startContainer(exception), marker);
     63        addMarker(textPiece->startContainer(exception),
     64                  DocumentMarker(type, textPiece->startOffset(exception), textPiece->endOffset(exception), description));
     65    }
     66}
     67
     68void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type)
     69{
     70    // Use a TextIterator to visit the potentially multiple nodes the range covers.
     71    for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
     72        RefPtr<Range> textPiece = markedText.range();
     73        int exception = 0;
     74        addMarker(textPiece->startContainer(exception),
     75                  DocumentMarker(type, textPiece->startOffset(exception), textPiece->endOffset(exception)));
     76    }
     77
     78}
     79
     80
     81void DocumentMarkerController::addTextMatchMarker(Range* range, bool activeMatch)
     82{
     83    // Use a TextIterator to visit the potentially multiple nodes the range covers.
     84    for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
     85        RefPtr<Range> textPiece = markedText.range();
     86        int exception = 0;
     87        unsigned startOffset = textPiece->startOffset(exception);
     88        unsigned endOffset = textPiece->endOffset(exception);
     89        addMarker(textPiece->startContainer(exception), DocumentMarker(activeMatch, startOffset, endOffset));
     90        if (endOffset > startOffset) {
     91            // Rendered rects for markers in WebKit are not populated until each time
     92            // the markers are painted. However, we need it to happen sooner, because
     93            // the whole purpose of tickmarks on the scrollbar is to show where
     94            // matches off-screen are (that haven't been painted yet).
     95            Node* node = textPiece->startContainer(exception);
     96            Vector<DocumentMarker> markers = markersForNode(node);
     97            setRenderedRectForMarker(textPiece->startContainer(exception),
     98                                     markers[markers.size() - 1],
     99                                     range->boundingBox());
     100        }
    65101    }
    66102}
    … …  
    85121void DocumentMarkerController::addMarker(Node* node, const DocumentMarker& newMarker)
    86122{
    87     ASSERT(newMarker.endOffset >= newMarker.startOffset);
    88     if (newMarker.endOffset == newMarker.startOffset)
    89         return;
    90 
    91     m_possiblyExistingMarkerTypes.add(newMarker.type);
     123    ASSERT(newMarker.endOffset() >= newMarker.startOffset());
     124    if (newMarker.endOffset() == newMarker.startOffset())
     125        return;
     126
     127    m_possiblyExistingMarkerTypes.add(newMarker.type());
    92128
    93129    MarkerList* list = m_markers.get(node);
    … …  
    106142        for (i = 0; i < numMarkers; ++i) {
    107143            DocumentMarker marker = list->at(i);
    108             if (marker.startOffset > toInsert.startOffset)
     144            if (marker.startOffset() > toInsert.startOffset())
    109145                break;
    110             if (marker.type == toInsert.type && marker.endOffset >= toInsert.startOffset) {
    111                 toInsert.startOffset = marker.startOffset;
     146            if (marker.type() == toInsert.type() && marker.endOffset() >= toInsert.startOffset()) {
     147                toInsert.setStartOffset(marker.startOffset());
    112148                list->remove(i);
    113149                numMarkers--;
    … …  
    121157        while (j < numMarkers) {
    122158            DocumentMarker marker = list->at(j);
    123             if (marker.startOffset > toInsert.endOffset)
     159            if (marker.startOffset() > toInsert.endOffset())
    124160                break;
    125             if (marker.type == toInsert.type) {
     161            if (marker.type() == toInsert.type()) {
    126162                list->remove(j);
    127                 if (toInsert.endOffset <= marker.endOffset) {
    128                     toInsert.endOffset = marker.endOffset;
     163                if (toInsert.endOffset() <= marker.endOffset()) {
     164                    toInsert.setEndOffset(marker.endOffset());
    129165                    break;
    130166                }
    … …  
    163199
    164200        // stop if we are now past the specified range
    165         if (marker.startOffset > endOffset)
     201        if (marker.startOffset() > endOffset)
    166202            break;
    167203
    168204        // skip marker that is before the specified range or is the wrong type
    169         if (marker.endOffset < startOffset)
     205        if (marker.endOffset() < startOffset)
    170206            continue;
    171207
    172208        // pin the marker to the specified range and apply the shift delta
    173209        docDirty = true;
    174         if (marker.startOffset < startOffset)
    175             marker.startOffset = startOffset;
    176         if (marker.endOffset > endOffset)
    177             marker.endOffset = endOffset;
    178         marker.startOffset += delta;
    179         marker.endOffset += delta;
     210        if (marker.startOffset() < startOffset)
     211            marker.setStartOffset(startOffset);
     212        if (marker.endOffset() > endOffset)
     213            marker.setEndOffset(endOffset);
     214        marker.shiftOffsets(delta);
    180215
    181216        addMarker(dstNode, marker);
    … …  
    206241
    207242        // markers are returned in order, so stop if we are now past the specified range
    208         if (marker.startOffset >= endOffset)
     243        if (marker.startOffset() >= endOffset)
    209244            break;
    210245
    211246        // skip marker that is wrong type or before target
    212         if (marker.endOffset <= startOffset || !markerTypes.contains(marker.type)) {
     247        if (marker.endOffset() <= startOffset || !markerTypes.contains(marker.type())) {
    213248            i++;
    214249            continue;
    … …  
    226261
    227262        // add either of the resulting slices that are left after removing target
    228         if (startOffset > marker.startOffset) {
     263        if (startOffset > marker.startOffset()) {
    229264            DocumentMarker newLeft = marker;
    230             newLeft.endOffset = startOffset;
     265            newLeft.setEndOffset(startOffset);
    231266            list->insert(i, RenderedDocumentMarker(newLeft));
    232267            // i now points to the newly-inserted node, but we want to skip that one
    233268            i++;
    234269        }
    235         if (marker.endOffset > endOffset) {
     270        if (marker.endOffset() > endOffset) {
    236271            DocumentMarker newRight = marker;
    237             newRight.startOffset = endOffset;
     272            newRight.setStartOffset(endOffset);
    238273            list->insert(i, RenderedDocumentMarker(newRight));
    239274            // i now points to the newly-inserted node, but we want to skip that one
    … …  
    271306
    272307            // skip marker that is wrong type
    273             if (marker.type != markerType)
     308            if (marker.type() != markerType)
    274309                continue;
    275310
    … …  
    312347        Vector<DocumentMarker>::const_iterator end = markers.end();
    313348        for (Vector<DocumentMarker>::const_iterator it = markers.begin(); it != end; ++it) {
    314             if (!markerTypes.contains(it->type))
    315                 continue;
    316             if (node == startContainer && it->endOffset <= static_cast<unsigned>(range->startOffset()))
    317                 continue;
    318             if (node == endContainer && it->startOffset >= static_cast<unsigned>(range->endOffset()))
     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()))
    319354                continue;
    320355            foundMarkers.append(*it);
    … …  
    342377
    343378            // skip marker that is wrong type
    344             if (marker.type != markerType)
     379            if (marker.type() != markerType)
    345380                continue;
    346381
    … …  
    394429
    395430            // skip nodes that are not of the specified type
    396             if (!markerTypes.contains(marker.type)) {
     431            if (!markerTypes.contains(marker.type())) {
    397432                ++i;
    398433                continue;
    … …  
    441476
    442477            // skip nodes that are not of the specified type
    443             if (markerTypes.contains(marker.type)) {
     478            if (markerTypes.contains(marker.type())) {
    444479                nodeNeedsRepaint = true;
    445480                break;
    … …  
    502537    for (size_t i = 0; i != list->size(); ++i) {
    503538        RenderedDocumentMarker& marker = list->at(i);
    504         if (marker.startOffset >= startOffset) {
    505             ASSERT((int)marker.startOffset + delta >= 0);
    506             marker.startOffset += delta;
    507             marker.endOffset += delta;
     539        if (marker.startOffset() >= startOffset) {
     540            ASSERT((int)marker.startOffset() + delta >= 0);
     541            marker.shiftOffsets(delta);
    508542            docDirty = true;
    509543
    … …  
    547581
    548582        // Markers are returned in order, so stop if we are now past the specified range.
    549         if (marker.startOffset >= endOffset)
     583        if (marker.startOffset() >= endOffset)
    550584            break;
    551585
    552586        // Skip marker that is wrong type or before target.
    553         if (marker.endOffset < startOffset || marker.type != DocumentMarker::TextMatch)
     587        if (marker.endOffset() < startOffset || marker.type() != DocumentMarker::TextMatch)
    554588            continue;
    555589
    556         marker.activeMatch = active;
     590        marker.setActiveMatch(active);
    557591        docDirty = true;
    558592    }
    … …  
    579613        Vector<DocumentMarker>::const_iterator end = markers.end();
    580614        for (Vector<DocumentMarker>::const_iterator it = markers.begin(); it != end; ++it) {
    581             if (!markerTypes.contains(it->type))
    582                 continue;
    583             if (node == startContainer && it->endOffset <= static_cast<unsigned>(range->startOffset()))
    584                 continue;
    585             if (node == endContainer && it->startOffset >= static_cast<unsigned>(range->endOffset()))
     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()))
    586620                continue;
    587621            return true;
    … …  
    612646
    613647            // markers are returned in order, so stop if we are now past the specified range
    614             if (marker.startOffset >= endOffset)
     648            if (marker.startOffset() >= endOffset)
    615649                break;
    616650
    617651            // skip marker that is wrong type or before target
    618             if (marker.endOffset <= startOffset || !markerTypes.contains(marker.type)) {
     652            if (marker.endOffset() <= startOffset || !markerTypes.contains(marker.type())) {
    619653                i++;
    620654                continue;
    621655            }
    622656
    623             marker.description = String();
     657            marker.clearDescription();
    624658        }
    625659    }
    … …  
    635669        fprintf(stderr, "%p", node);
    636670        MarkerList* list = nodeIterator->second;
    637         for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex)
    638             fprintf(stderr, " %d:[%d:%d](%d)", list->at(markerIndex).type, list->at(markerIndex).startOffset, list->at(markerIndex).endOffset, list->at(markerIndex).activeMatch);
     671        for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex) {
     672            const DocumentMarker& marker = list->at(markerIndex);
     673            fprintf(stderr, " %d:[%d:%d](%d)", marker.type(), marker.startOffset(), marker.endOffset(), marker.activeMatch());
     674        }
     675
    639676        fprintf(stderr, "\n");
    640677    }

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

    r86295 r86647  
    4848
    4949    void detach();
    50     void addMarker(Range*, DocumentMarker::MarkerType, String description = String());
    51     void addMarker(Node*, const DocumentMarker&);
     50    void addMarker(Range*, DocumentMarker::MarkerType);
     51    void addMarker(Range*, DocumentMarker::MarkerType, const String& description);
     52    void addTextMatchMarker(Range*, bool activeMatch);
     53
    5254    void copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta);
    5355    bool hasMarkers(Range*, DocumentMarker::MarkerTypes = DocumentMarker::AllMarkers());
    … …  
    8082
    8183private:
     84    void addMarker(Node*, const DocumentMarker&);
     85
    8286    typedef Vector<RenderedDocumentMarker> MarkerList;
    8387    typedef HashMap<RefPtr<Node>, MarkerList*> MarkerMap;

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

    r86295 r86647  
    349349    replaceTextInNode(node, offset, count, replacementText);
    350350    RefPtr<Range> newRange = Range::create(document(), node, offset, node, offset + replacementText.length());
    351     for (size_t i = 0; i < markers.size(); ++i)
    352         markerController->addMarker(newRange.get(), markers[i].type, markers[i].description);
     351    for (size_t i = 0; i < markers.size(); ++i) {
     352        if (markers[i].hasDescription())
     353            markerController->addMarker(newRange.get(), markers[i].type(), markers[i].description());
     354        else
     355            markerController->addMarker(newRange.get(), markers[i].type());
     356    }
    353357}
    354358

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

    r86339 r86647  
    763763    for (size_t i = 0; i < markers.size(); ++i) {
    764764        const DocumentMarker& marker = markers[i];
    765         int startOffset = marker.startOffset;
     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

    r86601 r86647  
    32203220    for (size_t i = 0; i < markers.size(); ++i) {
    32213221        DocumentMarker marker = markers[i];
    3222         if (marker.startOffset <= startOffset && endOffset <= marker.endOffset && marker.type == markerType)
     3222        if (marker.startOffset() <= startOffset && endOffset <= marker.endOffset() && marker.type() == markerType)
    32233223            return true;
    32243224    }

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

    r86525 r86647  
    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        }

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

    r86337 r86647  
    129129    bool shouldStartTimerFor(const DocumentMarker& marker, int endOffset) const
    130130    {
    131         return (((marker.type == DocumentMarker::Replacement && !marker.description.isNull())
    132                  || marker.type == DocumentMarker::Spelling) && static_cast<int>(marker.endOffset) == endOffset);
     131        return (((marker.type() == DocumentMarker::Replacement && !marker.description().isNull())
     132                 || marker.type() == DocumentMarker::Spelling) && static_cast<int>(marker.endOffset()) == endOffset);
    133133    }
    134134

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

    r85864 r86647  
    202202    if (RenderObject* renderer = m_innerNonSharedNode->renderer())
    203203        dir = renderer->style()->direction();
    204     return marker->description;
     204    return marker->description();
    205205}
    206206
    … …  
    216216        return String();
    217217   
    218     return marker->description;
     218    return marker->description();
    219219}   
    220220   

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

    r86197 r86647  
    993993    // Determine whether we need to measure text
    994994    bool markerSpansWholeBox = true;
    995     if (m_start <= (int)marker.startOffset)
     995    if (m_start <= (int)marker.startOffset())
    996996        markerSpansWholeBox = false;
    997     if ((end() + 1) != marker.endOffset)      // end points at the last char, not past it
     997    if ((end() + 1) != marker.endOffset()) // end points at the last char, not past it
    998998        markerSpansWholeBox = false;
    999999    if (m_truncation != cNoTruncation)
    … …  
    10011001
    10021002    if (!markerSpansWholeBox || grammar) {
    1003         int startPosition = max<int>(marker.startOffset - m_start, 0);
    1004         int endPosition = min<int>(marker.endOffset - m_start, m_len);
     1003        int startPosition = max<int>(marker.startOffset() - m_start, 0);
     1004        int endPosition = min<int>(marker.endOffset() - m_start, m_len);
    10051005       
    10061006        if (m_truncation != cNoTruncation)
    … …  
    10441044        underlineOffset = baseline + 2;
    10451045    }
    1046     pt->drawLineForTextChecking(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, textCheckingLineStyleForMarkerType(marker.type));
     1046    pt->drawLineForTextChecking(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, textCheckingLineStyleForMarkerType(marker.type()));
    10471047}
    10481048
    … …  
    10541054    int selHeight = selectionHeight();
    10551055
    1056     int sPos = max(marker.startOffset - m_start, (unsigned)0);
    1057     int ePos = min(marker.endOffset - m_start, (unsigned)m_len);   
     1056    int sPos = max(marker.startOffset() - m_start, (unsigned)0);
     1057    int ePos = min(marker.endOffset() - m_start, (unsigned)m_len);   
    10581058    TextRun run(textRenderer()->text()->characters() + m_start, m_len, textRenderer()->allowTabs(), textPos(), m_expansion, expansionBehavior(), direction(), m_dirOverride || style->visuallyOrdered());
    10591059   
    … …  
    10651065    // Optionally highlight the text
    10661066    if (renderer()->frame()->editor()->markedTextMatchesAreHighlighted()) {
    1067         Color color = marker.activeMatch ?
     1067        Color color = marker.activeMatch() ?
    10681068            renderer()->theme()->platformActiveTextSearchHighlightColor() :
    10691069            renderer()->theme()->platformInactiveTextSearchHighlightColor();
    … …  
    10811081    int h = selectionHeight();
    10821082   
    1083     int sPos = max(marker.startOffset - m_start, (unsigned)0);
    1084     int ePos = min(marker.endOffset - m_start, (unsigned)m_len);   
     1083    int sPos = max(marker.startOffset() - m_start, (unsigned)0);
     1084    int ePos = min(marker.endOffset() - m_start, (unsigned)m_len);   
    10851085    TextRun run(textRenderer()->text()->characters() + m_start, m_len, textRenderer()->allowTabs(), textPos(), m_expansion, expansionBehavior(), direction(), m_dirOverride || style->visuallyOrdered());
    10861086    IntPoint startPoint = IntPoint(m_x, y);
    … …  
    11061106       
    11071107        // Paint either the background markers or the foreground markers, but not both
    1108         switch (marker.type) {
     1108        switch (marker.type()) {
    11091109            case DocumentMarker::Grammar:
    11101110            case DocumentMarker::Spelling:
    … …  
    11221122        }
    11231123
    1124         if (marker.endOffset <= start())
     1124        if (marker.endOffset() <= start())
    11251125            // marker is completely before this run.  This might be a marker that sits before the
    11261126            // first run we draw, or markers that were within runs we skipped due to truncation.
    11271127            continue;
    11281128       
    1129         if (marker.startOffset > end())
     1129        if (marker.startOffset() > end())
    11301130            // marker is completely after this run, bail.  A later run will paint it.
    11311131            break;
    11321132       
    11331133        // marker intersects this run.  Paint it.
    1134         switch (marker.type) {
     1134        switch (marker.type()) {
    11351135            case DocumentMarker::Spelling:
    11361136                paintSpellingOrGrammarMarker(pt, boxOrigin, marker, style, font, false);

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

    r84504 r86647  
    100100
    101101        // SVG is only interessted in the TextMatch marker, for now.
    102         if (marker.type != DocumentMarker::TextMatch)
     102        if (marker.type() != DocumentMarker::TextMatch)
    103103            continue;
    104104
    … …  
    110110            SVGInlineTextBox* textBox = static_cast<SVGInlineTextBox*>(box);
    111111
    112             int markerStartPosition = max<int>(marker.startOffset - textBox->start(), 0);
    113             int markerEndPosition = min<int>(marker.endOffset - textBox->start(), textBox->len());
     112            int markerStartPosition = max<int>(marker.startOffset() - textBox->start(), 0);
     113            int markerEndPosition = min<int>(marker.endOffset() - textBox->start(), textBox->len());
    114114
    115115            if (markerStartPosition >= markerEndPosition)

  • trunk/Source/WebKit/chromium/ChangeLog

    r86640 r86647  
     12011-05-16  MORITA Hajime  <morrita@google.com>
     2
     3        Reviewed by Tony Chang.
     4
     5        [Refactoring] Member variables of DocumentMarker should be encapsulated.       
     6        https://bugs.webkit.org/show_bug.cgi?id=56814
     7
     8        Moved addMarker() implementation to
     9        WebCore::DocumentMarkerController::addTextMatchMarker().
     10       
     11        * src/WebFrameImpl.cpp:
     12        (WebKit::WebFrameImpl::addMarker):
     13
    1142011-05-16  Andrew Wilson  <atwilson@chromium.org>
    215

  • trunk/Source/WebKit/chromium/src/WebFrameImpl.cpp

    r86452 r86647  
    22412241void WebFrameImpl::addMarker(Range* range, bool activeMatch)
    22422242{
    2243     // Use a TextIterator to visit the potentially multiple nodes the range
    2244     // covers.
    2245     TextIterator markedText(range);
    2246     for (; !markedText.atEnd(); markedText.advance()) {
    2247         RefPtr<Range> textPiece = markedText.range();
    2248         int exception = 0;
    2249 
    2250         DocumentMarker marker = {
    2251             DocumentMarker::TextMatch,
    2252             textPiece->startOffset(exception),
    2253             textPiece->endOffset(exception),
    2254             "",
    2255             activeMatch
    2256         };
    2257 
    2258         if (marker.endOffset > marker.startOffset) {
    2259             // Find the node to add a marker to and add it.
    2260             Node* node = textPiece->startContainer(exception);
    2261             frame()->document()->markers()->addMarker(node, marker);
    2262 
    2263             // Rendered rects for markers in WebKit are not populated until each time
    2264             // the markers are painted. However, we need it to happen sooner, because
    2265             // the whole purpose of tickmarks on the scrollbar is to show where
    2266             // matches off-screen are (that haven't been painted yet).
    2267             Vector<DocumentMarker> markers = frame()->document()->markers()->markersForNode(node);
    2268             frame()->document()->markers()->setRenderedRectForMarker(
    2269                 textPiece->startContainer(exception),
    2270                 markers[markers.size() - 1],
    2271                 range->boundingBox());
    2272         }
    2273     }
     2243    frame()->document()->markers()->addTextMatchMarker(range, activeMatch);
    22742244}
    22752245
Note: See TracChangeset for help on using the changeset viewer.