Changeset 85118 in webkit


Ignore:
Timestamp:
Apr 27, 2011 4:09:01 PM (13 years ago)
Author:
morrita@google.com
Message:

2011-04-19 MORITA Hajime <​morrita@google.com>

Reviewed by Tony Chang.

[Refactoring] DocumentMarkerController::MarkerMapVectorPair should be replaced with a list of some class.
​https://bugs.webkit.org/show_bug.cgi?id=58113

  • Introduced RenderedDocumentMarker, a subclass of DocumentMarker.
  • Eliminated Vector<IntRect> and move the IntRect into RenderedDocumentMarker
  • Now MarkerMapVectorPair is no longer used.

No new tests, No behavior change.

  • GNUmakefile.list.am:
  • WebCore.gypi:
  • WebCore.pro:
  • WebCore.vcproj/WebCore.vcproj:
  • WebCore.xcodeproj/project.pbxproj:
  • dom/DocumentMarker.h:
  • dom/DocumentMarkerController.cpp: (WebCore::DocumentMarkerController::addMarker): (WebCore::DocumentMarkerController::copyMarkers): (WebCore::DocumentMarkerController::removeMarkers): (WebCore::DocumentMarkerController::markerContainingPoint): (WebCore::DocumentMarkerController::markersForNode): (WebCore::DocumentMarkerController::renderedRectsForMarkers): (WebCore::DocumentMarkerController::removeMarkersFromList): (WebCore::DocumentMarkerController::repaintMarkers): (WebCore::DocumentMarkerController::setRenderedRectForMarker): (WebCore::DocumentMarkerController::invalidateRenderedRectsForMarkersInRect): (WebCore::DocumentMarkerController::shiftMarkers): (WebCore::DocumentMarkerController::setMarkersActive): (WebCore::DocumentMarkerController::clearDescriptionOnMarkersIntersectingRange): (WebCore::DocumentMarkerController::showMarkers):
  • dom/DocumentMarkerController.h:
  • dom/RenderedDocumentMarker.h: Added. (WebCore::RenderedDocumentMarker::RenderedDocumentMarker): (WebCore::RenderedDocumentMarker::isRendered): (WebCore::RenderedDocumentMarker::contains): (WebCore::RenderedDocumentMarker::setRenderedRect): (WebCore::RenderedDocumentMarker::renderedRect): (WebCore::RenderedDocumentMarker::invalidate): (WebCore::RenderedDocumentMarker::invalidMarkerRect):
Location:
trunk/Source/WebCore
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r85116 r85118  
     12011-04-19  MORITA Hajime  <morrita@google.com>
     2
     3        Reviewed by Tony Chang.
     4
     5        [Refactoring] DocumentMarkerController::MarkerMapVectorPair should be replaced with a list of some class.
     6        https://bugs.webkit.org/show_bug.cgi?id=58113
     7
     8        * Introduced RenderedDocumentMarker, a subclass of DocumentMarker.
     9        * Eliminated Vector<IntRect> and move the IntRect into RenderedDocumentMarker
     10        * Now MarkerMapVectorPair is no longer used.
     11       
     12        No new tests, No behavior change.
     13
     14        * GNUmakefile.list.am:
     15        * WebCore.gypi:
     16        * WebCore.pro:
     17        * WebCore.vcproj/WebCore.vcproj:
     18        * WebCore.xcodeproj/project.pbxproj:
     19        * dom/DocumentMarker.h:
     20        * dom/DocumentMarkerController.cpp:
     21        (WebCore::DocumentMarkerController::addMarker):
     22        (WebCore::DocumentMarkerController::copyMarkers):
     23        (WebCore::DocumentMarkerController::removeMarkers):
     24        (WebCore::DocumentMarkerController::markerContainingPoint):
     25        (WebCore::DocumentMarkerController::markersForNode):
     26        (WebCore::DocumentMarkerController::renderedRectsForMarkers):
     27        (WebCore::DocumentMarkerController::removeMarkersFromList):
     28        (WebCore::DocumentMarkerController::repaintMarkers):
     29        (WebCore::DocumentMarkerController::setRenderedRectForMarker):
     30        (WebCore::DocumentMarkerController::invalidateRenderedRectsForMarkersInRect):
     31        (WebCore::DocumentMarkerController::shiftMarkers):
     32        (WebCore::DocumentMarkerController::setMarkersActive):
     33        (WebCore::DocumentMarkerController::clearDescriptionOnMarkersIntersectingRange):
     34        (WebCore::DocumentMarkerController::showMarkers):
     35        * dom/DocumentMarkerController.h:
     36        * dom/RenderedDocumentMarker.h: Added.
     37        (WebCore::RenderedDocumentMarker::RenderedDocumentMarker):
     38        (WebCore::RenderedDocumentMarker::isRendered):
     39        (WebCore::RenderedDocumentMarker::contains):
     40        (WebCore::RenderedDocumentMarker::setRenderedRect):
     41        (WebCore::RenderedDocumentMarker::renderedRect):
     42        (WebCore::RenderedDocumentMarker::invalidate):
     43        (WebCore::RenderedDocumentMarker::invalidMarkerRect):
     44
    1452011-04-27  James Robinson  <jamesr@chromium.org>
    246

  • trunk/Source/WebCore/GNUmakefile.list.am

    r85045 r85118  
    12191219        Source/WebCore/dom/RegisteredEventListener.cpp \
    12201220        Source/WebCore/dom/RegisteredEventListener.h \
     1221        Source/WebCore/dom/RenderedDocumentMarker.h \
    12211222        Source/WebCore/dom/ScopedEventQueue.cpp \
    12221223        Source/WebCore/dom/ScopedEventQueue.h \

  • trunk/Source/WebCore/WebCore.gypi

    r85045 r85118  
    546546            'dom/RangeBoundaryPoint.h',
    547547            'dom/RegisteredEventListener.h',
     548            'dom/RenderedDocumentMarker.h',
    548549            'dom/ScriptExecutionContext.h',
    549550            'dom/ScriptRunner.h',

  • trunk/Source/WebCore/WebCore.pro

    r84991 r85118  
    14961496    dom/Range.h \
    14971497    dom/RegisteredEventListener.h \
     1498    dom/RenderedDocumentMarker.h \
    14981499    dom/ScriptElement.h \
    14991500    dom/ScriptExecutionContext.h \

  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r84991 r85118  
    4603546035                        </File>
    4603646036                        <File
     46037                                RelativePath="..\dom\RenderedDocumentMarker.h"
     46038                                >
     46039                        </File>
     46040                        <File
    4603746041                                RelativePath="..\dom\ScopedEventQueue.cpp"
    4603846042                                >

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r85114 r85118  
    32633263                A75E8B8E0E1DE2D6007F2481 /* FEComposite.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A75E8B860E1DE2D6007F2481 /* FEComposite.cpp */; };
    32643264                A75E8B8F0E1DE2D6007F2481 /* FEComposite.h in Headers */ = {isa = PBXBuildFile; fileRef = A75E8B870E1DE2D6007F2481 /* FEComposite.h */; };
     3265                A76E5F7F135E0DCF00A69837 /* RenderedDocumentMarker.h in Headers */ = {isa = PBXBuildFile; fileRef = A76E5F7E135E0DCF00A69837 /* RenderedDocumentMarker.h */; };
    32653266                A77979190D6B9D0C003851B9 /* ImageData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A77979130D6B9D0C003851B9 /* ImageData.cpp */; };
    32663267                A779791A0D6B9D0C003851B9 /* ImageData.h in Headers */ = {isa = PBXBuildFile; fileRef = A77979140D6B9D0C003851B9 /* ImageData.h */; };
    … …  
    98249825                A75E8B860E1DE2D6007F2481 /* FEComposite.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FEComposite.cpp; path = filters/FEComposite.cpp; sourceTree = "<group>"; };
    98259826                A75E8B870E1DE2D6007F2481 /* FEComposite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FEComposite.h; path = filters/FEComposite.h; sourceTree = "<group>"; };
     9827                A76E5F7E135E0DCF00A69837 /* RenderedDocumentMarker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderedDocumentMarker.h; sourceTree = "<group>"; };
    98269828                A77979130D6B9D0C003851B9 /* ImageData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageData.cpp; sourceTree = "<group>"; };
    98279829                A77979140D6B9D0C003851B9 /* ImageData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageData.h; sourceTree = "<group>"; };
    … …  
    1952319525                                85031B350A44EFC700F992E0 /* RegisteredEventListener.cpp */,
    1952419526                                85031B360A44EFC700F992E0 /* RegisteredEventListener.h */,
     19527                                A76E5F7E135E0DCF00A69837 /* RenderedDocumentMarker.h */,
    1952519528                                9BD0BF9212A42BF50072FD43 /* ScopedEventQueue.cpp */,
    1952619529                                9BD0BF9112A42BF50072FD43 /* ScopedEventQueue.h */,
    … …  
    2214122144                                93309E05099E64920056E581 /* RemoveNodeCommand.h in Headers */,
    2214222145                                93309E07099E64920056E581 /* RemoveNodePreservingChildrenCommand.h in Headers */,
     22146                                A76E5F7F135E0DCF00A69837 /* RenderedDocumentMarker.h in Headers */,
    2214322147                                BCEA485C097D93020094C9E4 /* RenderApplet.h in Headers */,
    2214422148                                BCEA485E097D93020094C9E4 /* RenderArena.h in Headers */,

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

    r83991 r85118  
    2626#include "PlatformString.h"
    2727#include <wtf/Forward.h>
     28
    2829
    2930namespace WebCore {

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

    r83991 r85118  
    3030#include "Node.h"
    3131#include "Range.h"
     32#include "RenderedDocumentMarker.h"
    3233#include "TextIterator.h"
    3334
    3435namespace WebCore {
    35 
    36 static IntRect placeholderRectForMarker()
    37 {
    38     return IntRect(-1, -1, -1, -1);
    39 }
    4036
    4137inline bool DocumentMarkerController::possiblyHasMarkers(DocumentMarker::MarkerTypes types)
    … …  
    8682// Markers of the same type do not overlap each other.
    8783
    88 void DocumentMarkerController::addMarker(Node* node, DocumentMarker newMarker)
     84void DocumentMarkerController::addMarker(Node* node, const DocumentMarker& newMarker)
    8985{
    9086    ASSERT(newMarker.endOffset >= newMarker.startOffset);
    … …  
    9490    m_possiblyExistingMarkerTypes.add(newMarker.type);
    9591
    96     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    97 
    98     if (!vectorPair) {
    99         vectorPair = new MarkerMapVectorPair;
    100         vectorPair->first.append(newMarker);
    101         vectorPair->second.append(placeholderRectForMarker());
    102         m_markers.set(node, vectorPair);
     92    MarkerList* list = m_markers.get(node);
     93
     94    if (!list) {
     95        list = new MarkerList;
     96        list->append(RenderedDocumentMarker(newMarker));
     97        m_markers.set(node, list);
    10398    } else {
    104         Vector<DocumentMarker>& markers = vectorPair->first;
    105         Vector<IntRect>& rects = vectorPair->second;
    106         size_t numMarkers = markers.size();
    107         ASSERT(numMarkers == rects.size());
     99        RenderedDocumentMarker toInsert(newMarker);
     100        size_t numMarkers = list->size();
    108101        size_t i;
    109102        // Iterate over all markers whose start offset is less than or equal to the new marker's.
    … …  
    111104        // (there is at most one), remove it and adjust the new marker's start offset to encompass it.
    112105        for (i = 0; i < numMarkers; ++i) {
    113             DocumentMarker marker = markers[i];
    114             if (marker.startOffset > newMarker.startOffset)
     106            DocumentMarker marker = list->at(i);
     107            if (marker.startOffset > toInsert.startOffset)
    115108                break;
    116             if (marker.type == newMarker.type && marker.endOffset >= newMarker.startOffset) {
    117                 newMarker.startOffset = marker.startOffset;
    118                 markers.remove(i);
    119                 rects.remove(i);
     109            if (marker.type == toInsert.type && marker.endOffset >= toInsert.startOffset) {
     110                toInsert.startOffset = marker.startOffset;
     111                list->remove(i);
    120112                numMarkers--;
    121113                break;
    … …  
    127119        // adjusting the new marker's end offset to cover them if necessary.
    128120        while (j < numMarkers) {
    129             DocumentMarker marker = markers[j];
    130             if (marker.startOffset > newMarker.endOffset)
     121            DocumentMarker marker = list->at(j);
     122            if (marker.startOffset > toInsert.endOffset)
    131123                break;
    132             if (marker.type == newMarker.type) {
    133                 markers.remove(j);
    134                 rects.remove(j);
    135                 if (newMarker.endOffset <= marker.endOffset) {
    136                     newMarker.endOffset = marker.endOffset;
     124            if (marker.type == toInsert.type) {
     125                list->remove(j);
     126                if (toInsert.endOffset <= marker.endOffset) {
     127                    toInsert.endOffset = marker.endOffset;
    137128                    break;
    138129                }
    … …  
    142133        }
    143134        // At this point i points to the node before which we want to insert.
    144         markers.insert(i, newMarker);
    145         rects.insert(i, placeholderRectForMarker());
     135        list->insert(i, RenderedDocumentMarker(toInsert));
    146136    }
    147137
    … …  
    162152    ASSERT(!m_markers.isEmpty());
    163153
    164     MarkerMapVectorPair* vectorPair = m_markers.get(srcNode);
    165     if (!vectorPair)
    166         return;
    167 
    168     ASSERT(vectorPair->first.size() == vectorPair->second.size());
     154    MarkerList* list = m_markers.get(srcNode);
     155    if (!list)
     156        return;
    169157
    170158    bool docDirty = false;
    171159    unsigned endOffset = startOffset + length - 1;
    172     Vector<DocumentMarker>& markers = vectorPair->first;
    173     for (size_t i = 0; i != markers.size(); ++i) {
    174         DocumentMarker marker = markers[i];
     160    for (size_t i = 0; i != list->size(); ++i) {
     161        DocumentMarker marker = list->at(i);
    175162
    176163        // stop if we are now past the specified range
    … …  
    208195    ASSERT(!(m_markers.isEmpty()));
    209196
    210     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    211     if (!vectorPair)
    212         return;
    213 
    214     Vector<DocumentMarker>& markers = vectorPair->first;
    215     Vector<IntRect>& rects = vectorPair->second;
    216     ASSERT(markers.size() == rects.size());
     197    MarkerList* list = m_markers.get(node);
     198    if (!list)
     199        return;
     200
    217201    bool docDirty = false;
    218202    unsigned endOffset = startOffset + length;
    219     for (size_t i = 0; i < markers.size();) {
    220         DocumentMarker marker = markers[i];
     203    for (size_t i = 0; i < list->size();) {
     204        DocumentMarker marker = list->at(i);
    221205
    222206        // markers are returned in order, so stop if we are now past the specified range
    … …  
    233217        docDirty = true;
    234218
    235         // pitch the old marker and any associated rect
    236         markers.remove(i);
    237         rects.remove(i);
     219        // pitch the old marker
     220        list->remove(i);
    238221
    239222        if (shouldRemovePartiallyOverlappingMarker)
    … …  
    245228            DocumentMarker newLeft = marker;
    246229            newLeft.endOffset = startOffset;
    247             markers.insert(i, newLeft);
    248             rects.insert(i, placeholderRectForMarker());
     230            list->insert(i, RenderedDocumentMarker(newLeft));
    249231            // i now points to the newly-inserted node, but we want to skip that one
    250232            i++;
    … …  
    253235            DocumentMarker newRight = marker;
    254236            newRight.startOffset = endOffset;
    255             markers.insert(i, newRight);
    256             rects.insert(i, placeholderRectForMarker());
     237            list->insert(i, RenderedDocumentMarker(newRight));
    257238            // i now points to the newly-inserted node, but we want to skip that one
    258239            i++;
    … …  
    260241    }
    261242
    262     if (markers.isEmpty()) {
    263         ASSERT(rects.isEmpty());
     243    if (list->isEmpty()) {
    264244        m_markers.remove(node);
    265         delete vectorPair;
     245        delete list;
    266246    }
    267247   
    … …  
    284264    for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
    285265        // inner loop; process each marker in this node
    286         MarkerMapVectorPair* vectorPair = nodeIterator->second;
    287         Vector<DocumentMarker>& markers = vectorPair->first;
    288         Vector<IntRect>& rects = vectorPair->second;
    289         ASSERT(markers.size() == rects.size());
    290         unsigned markerCount = markers.size();
     266        MarkerList* list = nodeIterator->second;
     267        unsigned markerCount = list->size();
    291268        for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    292             DocumentMarker& marker = markers[markerIndex];
     269            RenderedDocumentMarker& marker = list->at(markerIndex);
    293270
    294271            // skip marker that is wrong type
    … …  
    296273                continue;
    297274
    298             IntRect& r = rects[markerIndex];
    299 
    300             // skip placeholder rects
    301             if (r == placeholderRectForMarker())
    302                 continue;
    303 
    304             if (r.contains(point))
     275            if (marker.contains(point))
    305276                return &marker;
    306277        }
    … …  
    312283Vector<DocumentMarker> DocumentMarkerController::markersForNode(Node* node)
    313284{
    314     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    315     if (vectorPair)
    316         return vectorPair->first;
    317     return Vector<DocumentMarker>();
     285    Vector<DocumentMarker> result;
     286    MarkerList* list = m_markers.get(node);
     287    if (!list)
     288        return result;
     289
     290    for (size_t i = 0; i < list->size(); ++i)
     291        result.append(list->at(i));
     292
     293    return result;
    318294}
    319295
    … …  
    359335    for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
    360336        // inner loop; process each marker in this node
    361         MarkerMapVectorPair* vectorPair = nodeIterator->second;
    362         Vector<DocumentMarker>& markers = vectorPair->first;
    363         Vector<IntRect>& rects = vectorPair->second;
    364         ASSERT(markers.size() == rects.size());
    365         unsigned markerCount = markers.size();
     337        MarkerList* list = nodeIterator->second;
     338        unsigned markerCount = list->size();
    366339        for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    367             DocumentMarker marker = markers[markerIndex];
     340            const RenderedDocumentMarker& marker = list->at(markerIndex);
    368341
    369342            // skip marker that is wrong type
    … …  
    371344                continue;
    372345
    373             IntRect r = rects[markerIndex];
    374             // skip placeholder rects
    375             if (r == placeholderRectForMarker())
    376                 continue;
    377 
    378             result.append(r);
     346            if (!marker.isRendered())
     347                continue;
     348
     349            result.append(marker.renderedRect());
    379350        }
    380351    }
    … …  
    391362    MarkerMap::iterator iterator = m_markers.find(node);
    392363    if (iterator != m_markers.end())
    393         removeMarkersFromMarkerMapVectorPair(node, iterator->second, markerTypes);
     364        removeMarkersFromList(node, iterator->second, markerTypes);
    394365}
    395366
    … …  
    403374    MarkerMap markerMapCopy = m_markers;
    404375    MarkerMap::iterator end = markerMapCopy.end();
    405     for (MarkerMap::iterator i = markerMapCopy.begin(); i != end; ++i) {
    406         Node* node = i->first.get();
    407         MarkerMapVectorPair* vectorPair = i->second;
    408         removeMarkersFromMarkerMapVectorPair(node, vectorPair, markerTypes);
    409     }
    410 
     376    for (MarkerMap::iterator i = markerMapCopy.begin(); i != end; ++i)
     377        removeMarkersFromList(i->first.get(), i->second, markerTypes);
    411378    m_possiblyExistingMarkerTypes.remove(markerTypes);
    412379}
    413380
    414381// This function may release node and vectorPair.
    415 void DocumentMarkerController::removeMarkersFromMarkerMapVectorPair(Node* node, MarkerMapVectorPair* vectorPair, DocumentMarker::MarkerTypes markerTypes)
     382void DocumentMarkerController::removeMarkersFromList(Node* node, MarkerList* list, DocumentMarker::MarkerTypes markerTypes)
    416383{
    417384    if (markerTypes == DocumentMarker::AllMarkers()) {
    418         delete vectorPair;
     385        delete list;
    419386        m_markers.remove(node);
    420387        if (RenderObject* renderer = node->renderer())
    … …  
    422389    } else {
    423390        bool needsRepaint = false;
    424         Vector<DocumentMarker>& markers = vectorPair->first;
    425         Vector<IntRect>& rects = vectorPair->second;
    426         ASSERT(markers.size() == rects.size());
    427         for (size_t i = 0; i != markers.size();) {
    428             DocumentMarker marker = markers[i];
     391        for (size_t i = 0; i != list->size();) {
     392            DocumentMarker marker = list->at(i);
    429393
    430394            // skip nodes that are not of the specified type
    … …  
    435399
    436400            // pitch the old marker
    437             markers.remove(i);
    438             rects.remove(i);
     401            list->remove(i);
    439402            needsRepaint = true;
    440403            // i now is the index of the next marker
    … …  
    450413
    451414        // delete the node's list if it is now empty
    452         if (markers.isEmpty()) {
    453             ASSERT(rects.isEmpty());
     415        if (list->isEmpty()) {
    454416            m_markers.remove(node);
    455             delete vectorPair;
     417            delete list;
    456418        }
    457419    }
    … …  
    472434
    473435        // inner loop: process each marker in the current node
    474         MarkerMapVectorPair* vectorPair = i->second;
    475         Vector<DocumentMarker>& markers = vectorPair->first;
     436        MarkerList* list = i->second;
    476437        bool nodeNeedsRepaint = false;
    477         for (size_t i = 0; i != markers.size(); ++i) {
    478             DocumentMarker marker = markers[i];
     438        for (size_t i = 0; i != list->size(); ++i) {
     439            DocumentMarker marker = list->at(i);
    479440
    480441            // skip nodes that are not of the specified type
    … …  
    496457void DocumentMarkerController::setRenderedRectForMarker(Node* node, const DocumentMarker& marker, const IntRect& r)
    497458{
    498     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    499     if (!vectorPair) {
     459    MarkerList* list = m_markers.get(node);
     460    if (!list) {
    500461        ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
    501462        return;
    502463    }
    503464
    504     Vector<DocumentMarker>& markers = vectorPair->first;
    505     ASSERT(markers.size() == vectorPair->second.size());
    506     unsigned markerCount = markers.size();
    507     for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    508         DocumentMarker m = markers[markerIndex];
     465    size_t markerCount = list->size();
     466    for (size_t markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
     467        RenderedDocumentMarker& m = list->at(markerIndex);
    509468        if (m == marker) {
    510             vectorPair->second[markerIndex] = r;
     469            m.setRenderedRect(r);
    511470            return;
    512471        }
    … …  
    523482
    524483        // inner loop: process each rect in the current node
    525         MarkerMapVectorPair* vectorPair = i->second;
    526         Vector<IntRect>& rects = vectorPair->second;
    527 
    528         unsigned rectCount = rects.size();
    529         for (unsigned rectIndex = 0; rectIndex < rectCount; ++rectIndex)
    530             if (rects[rectIndex].intersects(r))
    531                 rects[rectIndex] = placeholderRectForMarker();
     484        MarkerList* list = i->second;
     485        for (size_t listIndex = 0; listIndex < list->size(); ++listIndex)
     486            list->at(listIndex).invalidate(r);
    532487    }
    533488}
    … …  
    539494    ASSERT(!m_markers.isEmpty());
    540495
    541     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    542     if (!vectorPair)
    543         return;
    544 
    545     Vector<DocumentMarker>& markers = vectorPair->first;
    546     Vector<IntRect>& rects = vectorPair->second;
    547     ASSERT(markers.size() == rects.size());
     496    MarkerList* list = m_markers.get(node);
     497    if (!list)
     498        return;
    548499
    549500    bool docDirty = false;
    550     for (size_t i = 0; i != markers.size(); ++i) {
    551         DocumentMarker& marker = markers[i];
     501    for (size_t i = 0; i != list->size(); ++i) {
     502        RenderedDocumentMarker& marker = list->at(i);
    552503        if (marker.startOffset >= startOffset) {
    553504            ASSERT((int)marker.startOffset + delta >= 0);
    … …  
    557508
    558509            // Marker moved, so previously-computed rendered rectangle is now invalid
    559             rects[i] = placeholderRectForMarker();
     510            marker.invalidate();
    560511        }
    561512    }
    … …  
    586537void DocumentMarkerController::setMarkersActive(Node* node, unsigned startOffset, unsigned endOffset, bool active)
    587538{
    588     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    589     if (!vectorPair)
    590         return;
    591 
    592     Vector<DocumentMarker>& markers = vectorPair->first;
    593     ASSERT(markers.size() == vectorPair->second.size());
     539    MarkerList* list = m_markers.get(node);
     540    if (!list)
     541        return;
    594542
    595543    bool docDirty = false;
    596     for (size_t i = 0; i != markers.size(); ++i) {
    597         DocumentMarker& marker = markers[i];
     544    for (size_t i = 0; i != list->size(); ++i) {
     545        DocumentMarker& marker = list->at(i);
    598546
    599547        // Markers are returned in order, so stop if we are now past the specified range.
    … …  
    655603        unsigned startOffset = node == startContainer ? range->startOffset() : 0;
    656604        unsigned endOffset = node == endContainer ? static_cast<unsigned>(range->endOffset()) : std::numeric_limits<unsigned>::max();
    657         MarkerMapVectorPair* vectorPair = m_markers.get(node);
    658         if (!vectorPair)
     605        MarkerList* list = m_markers.get(node);
     606        if (!list)
    659607            continue;
    660608
    661         Vector<DocumentMarker>& markers = vectorPair->first;
    662         for (size_t i = 0; i < markers.size(); ++i) {
    663             DocumentMarker& marker = markers[i];
     609        for (size_t i = 0; i < list->size(); ++i) {
     610            DocumentMarker& marker = list->at(i);
    664611
    665612            // markers are returned in order, so stop if we are now past the specified range
    … …  
    686633        Node* node = nodeIterator->first.get();
    687634        fprintf(stderr, "%p", node);
    688         MarkerMapVectorPair* vectorPair = nodeIterator->second;
    689         Vector<DocumentMarker>& markers = vectorPair->first;
    690         unsigned markerCount = markers.size();
    691         for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex)
    692             fprintf(stderr, " %d:[%d:%d](%d)", markers[markerIndex].type, markers[markerIndex].startOffset, markers[markerIndex].endOffset, markers[markerIndex].activeMatch);
     635        MarkerList* list = nodeIterator->second;
     636        for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex)
     637            fprintf(stderr, " %d:[%d:%d](%d)", list->at(markerIndex).type, list->at(markerIndex).startOffset, list->at(markerIndex).endOffset, list->at(markerIndex).activeMatch);
    693638        fprintf(stderr, "\n");
    694639    }

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

    r83991 r85118  
    3838class Node;
    3939class Range;
     40class RenderedDocumentMarker;
    4041
    4142class DocumentMarkerController {
    4243    WTF_MAKE_NONCOPYABLE(DocumentMarkerController); WTF_MAKE_FAST_ALLOCATED;
    4344public:
     45
    4446    DocumentMarkerController();
    4547    ~DocumentMarkerController() { detach(); }
    … …  
    4749    void detach();
    4850    void addMarker(Range*, DocumentMarker::MarkerType, String description = String());
    49     void addMarker(Node*, DocumentMarker);
     51    void addMarker(Node*, const DocumentMarker&);
    5052    void copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta);
    5153    bool hasMarkers(Range*, DocumentMarker::MarkerTypes = DocumentMarker::AllMarkers());
    … …  
    7880
    7981private:
    80     typedef std::pair<Vector<DocumentMarker>, Vector<IntRect> > MarkerMapVectorPair;
    81     typedef HashMap<RefPtr<Node>, MarkerMapVectorPair*> MarkerMap;
     82    typedef Vector<RenderedDocumentMarker> MarkerList;
     83    typedef HashMap<RefPtr<Node>, MarkerList*> MarkerMap;
    8284    bool possiblyHasMarkers(DocumentMarker::MarkerTypes);
    83     void removeMarkersFromMarkerMapVectorPair(Node*, MarkerMapVectorPair*, DocumentMarker::MarkerTypes);
     85    void removeMarkersFromList(Node*, MarkerList*, DocumentMarker::MarkerTypes);
    8486
    8587    MarkerMap m_markers;
Note: See TracChangeset for help on using the changeset viewer.