Changeset 65787 in webkit


Ignore:
Timestamp:
Aug 22, 2010 2:41:37 PM (14 years ago)
Author:
dbates@webkit.org
Message:

2010-08-22 Daniel Bates <dbates@rim.com>

Reviewed by Eric Seidel.

Encapsulate document marker management into DocumentMarkerController
https://bugs.webkit.org/show_bug.cgi?id=44383

Modify call sites in the Chromium port to use DocumentMarkerController.

No functionality was changed, so no new tests.

  • src/WebFrameImpl.cpp: (WebKit::WebFrameImpl::stopFinding): (WebKit::WebFrameImpl::addMarker): (WebKit::WebFrameImpl::setMarkerActive):

2010-08-22 Daniel Bates <dbates@rim.com>

Reviewed by Eric Seidel.

Encapsulate document marker management into DocumentMarkerController
https://bugs.webkit.org/show_bug.cgi?id=44383

Modify call sites in the Apple Windows port to use DocumentMarkerController.

No functionality was changed, so no new tests.

  • WebFrame.cpp: (WebFrame::unmarkAllMisspellings): (WebFrame::unmarkAllBadGrammar):
  • WebView.cpp: (WebView::rectsForTextMatches):

2010-08-22 Daniel Bates <dbates@rim.com>

Reviewed by Eric Seidel.

Encapsulate document marker management into DocumentMarkerController
https://bugs.webkit.org/show_bug.cgi?id=44383

Modify call sites in the Apple Mac port to use DocumentMarkerController.

No functionality was changed, so no new tests.

  • WebView/WebFrame.mm: (-[WebFrame _unmarkAllBadGrammar]): (-[WebFrame _unmarkAllMisspellings]):
  • WebView/WebHTMLView.mm: (-[WebHTMLView unmarkAllTextMatches]): (-[WebHTMLView rectsForTextMatches]):

2010-08-22 Daniel Bates <dbates@rim.com>

Reviewed by Eric Seidel.

Encapsulate document marker management into DocumentMarkerController
https://bugs.webkit.org/show_bug.cgi?id=44383

Modify call sites in the EFL port to use DocumentMarkerController.

No functionality was changed, so no new tests.

  • ewk/ewk_frame.cpp: (ewk_frame_text_matches_unmark_all):

2010-08-22 Daniel Bates <dbates@rim.com>

Reviewed by Eric Seidel.

Encapsulate document marker management into DocumentMarkerController
https://bugs.webkit.org/show_bug.cgi?id=44383

Moves the document marker management code in Document.cpp into its own
class called DocumentMarkerController.

No functionality was changed, so no new tests.

  • Android.mk: Added DocumentMarkerController.cpp
  • CMakeLists.txt: Ditto.
  • GNUmakefile.am: Added DocumentMarkerController.cpp and DocumentMarkerController.h.
  • WebCore.exp.in: Substituted symbols ZN7WebCore24DocumentMarkerController13removeMarkersENS_14DocumentMarker10MarkerTypeE and ZN7WebCore24DocumentMarkerController23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE for ZN7WebCore8Document13removeMarkersENS_14DocumentMarker10MarkerTypeE and ZN7WebCore8Document23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE, respectively.
  • WebCore.gypi: Added DocumentMarkerController.cpp and DocumentMarkerController.h.
  • WebCore.pro: Ditto.
  • WebCore.vcproj/WebCore.vcproj: Ditto.
  • WebCore.xcodeproj/project.pbxproj: Ditto.
  • dom/Document.cpp: (WebCore::Document::removedLastRef): Modified to call DocumentMarkerController::detach(). (WebCore::Document::~Document): Removed "deleteAllValues(m_markers)" as DocumentMarkerController is stored in OwnPtr; so it will be destroyed automatically on Document destruction. (WebCore::Document::textInserted): Modified to use marker controller. (WebCore::Document::textRemoved): Ditto.
  • dom/Document.h: (WebCore::Document::markers): Added.
  • dom/DocumentMarkerController.cpp: Added. (WebCore::placeholderRectForMarker): (WebCore::DocumentMarkerController::detach): (WebCore::DocumentMarkerController::addMarker): (WebCore::DocumentMarkerController::removeMarkers): (WebCore::DocumentMarkerController::copyMarkers): (WebCore::DocumentMarkerController::markerContainingPoint): (WebCore::DocumentMarkerController::markersForNode): (WebCore::DocumentMarkerController::renderedRectsForMarkers): (WebCore::DocumentMarkerController::repaintMarkers): (WebCore::DocumentMarkerController::setRenderedRectForMarker): (WebCore::DocumentMarkerController::invalidateRenderedRectsForMarkersInRect): (WebCore::DocumentMarkerController::shiftMarkers): (WebCore::DocumentMarkerController::setMarkersActive):
  • dom/DocumentMarkerController.h: Added. (WebCore::DocumentMarkerController::~DocumentMarkerController):
  • editing/Editor.cpp: (WebCore::Editor::ignoreSpelling): Modified to use marker controller. (WebCore::findFirstMisspellingInRange): Ditto. (WebCore::findFirstGrammarDetailInRange): Ditto. (WebCore::Editor::advanceToNextMisspelling): Ditto. (WebCore::Editor::markAllMisspellingsAndBadGrammarInRanges): Ditto. (WebCore::Editor::changeBackToReplacedString): Ditto.
  • editing/SplitTextNodeCommand.cpp: (WebCore::SplitTextNodeCommand::doApply): Ditto. (WebCore::SplitTextNodeCommand::doUnapply): Ditto.
  • page/Frame.cpp: (WebCore::Frame::markAllMatchesForText): Ditto. (WebCore::Frame::setMarkedTextMatchesAreHighlighted): Ditto. (WebCore::Frame::respondToChangedSelection): Ditto.
  • page/FrameView.cpp: (WebCore::FrameView::getTickmarks): Ditto. (WebCore::FrameView::paintContents): Ditto.
  • page/Page.cpp: (WebCore::Page::unmarkAllTextMatches): Ditto.
  • rendering/HitTestResult.cpp: (WebCore::HitTestResult::spellingToolTip): Ditto. (WebCore::HitTestResult::replacedString): Ditto.
  • rendering/InlineTextBox.cpp: (WebCore::InlineTextBox::paintSpellingOrGrammarMarker): Ditto. (WebCore::InlineTextBox::paintTextMatchMarker): Ditto. (WebCore::InlineTextBox::computeRectForReplacementMarker): Ditto. (WebCore::InlineTextBox::paintDocumentMarkers): Ditto.
  • rendering/SVGInlineTextBox.cpp: (WebCore::SVGInlineTextBox::computeTextMatchMarkerRect): Ditto.
Location:
trunk
Files:
2 added
29 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebCore/Android.mk

    r65645 r65787  
    124124        dom/Document.cpp \
    125125        dom/DocumentFragment.cpp \
     126        dom/DocumentMarkerController.cpp \
    126127        dom/DocumentParser.cpp \
    127128        dom/DocumentType.cpp \
  • trunk/WebCore/CMakeLists.txt

    r65763 r65787  
    811811    dom/DeviceOrientationEvent.cpp
    812812    dom/Document.cpp
     813    dom/DocumentMarkerController.cpp
    813814    dom/DocumentFragment.cpp
    814815    dom/DocumentParser.cpp
  • trunk/WebCore/ChangeLog

    r65786 r65787  
     12010-08-22  Daniel Bates  <dbates@rim.com>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Encapsulate document marker management into DocumentMarkerController
     6        https://bugs.webkit.org/show_bug.cgi?id=44383
     7
     8        Moves the document marker management code in Document.cpp into its own
     9        class called DocumentMarkerController.
     10
     11        No functionality was changed, so no new tests.
     12
     13        * Android.mk: Added DocumentMarkerController.cpp
     14        * CMakeLists.txt: Ditto.
     15        * GNUmakefile.am: Added DocumentMarkerController.cpp and DocumentMarkerController.h.
     16        * WebCore.exp.in: Substituted symbols __ZN7WebCore24DocumentMarkerController13removeMarkersENS_14DocumentMarker10MarkerTypeE
     17        and __ZN7WebCore24DocumentMarkerController23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE for
     18        __ZN7WebCore8Document13removeMarkersENS_14DocumentMarker10MarkerTypeE and
     19        __ZN7WebCore8Document23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE, respectively.
     20        * WebCore.gypi: Added DocumentMarkerController.cpp and DocumentMarkerController.h.
     21        * WebCore.pro: Ditto.
     22        * WebCore.vcproj/WebCore.vcproj: Ditto.
     23        * WebCore.xcodeproj/project.pbxproj: Ditto.
     24        * dom/Document.cpp:
     25        (WebCore::Document::removedLastRef): Modified to call DocumentMarkerController::detach().
     26        (WebCore::Document::~Document): Removed "deleteAllValues(m_markers)" as DocumentMarkerController
     27        is stored in OwnPtr; so it will be destroyed automatically on Document destruction.
     28        (WebCore::Document::textInserted): Modified to use marker controller.
     29        (WebCore::Document::textRemoved): Ditto.
     30        * dom/Document.h:
     31        (WebCore::Document::markers): Added.
     32        * dom/DocumentMarkerController.cpp: Added.
     33        (WebCore::placeholderRectForMarker):
     34        (WebCore::DocumentMarkerController::detach):
     35        (WebCore::DocumentMarkerController::addMarker):
     36        (WebCore::DocumentMarkerController::removeMarkers):
     37        (WebCore::DocumentMarkerController::copyMarkers):
     38        (WebCore::DocumentMarkerController::markerContainingPoint):
     39        (WebCore::DocumentMarkerController::markersForNode):
     40        (WebCore::DocumentMarkerController::renderedRectsForMarkers):
     41        (WebCore::DocumentMarkerController::repaintMarkers):
     42        (WebCore::DocumentMarkerController::setRenderedRectForMarker):
     43        (WebCore::DocumentMarkerController::invalidateRenderedRectsForMarkersInRect):
     44        (WebCore::DocumentMarkerController::shiftMarkers):
     45        (WebCore::DocumentMarkerController::setMarkersActive):
     46        * dom/DocumentMarkerController.h: Added.
     47        (WebCore::DocumentMarkerController::~DocumentMarkerController):
     48        * editing/Editor.cpp:
     49        (WebCore::Editor::ignoreSpelling): Modified to use marker controller.
     50        (WebCore::findFirstMisspellingInRange): Ditto.
     51        (WebCore::findFirstGrammarDetailInRange): Ditto.
     52        (WebCore::Editor::advanceToNextMisspelling): Ditto.
     53        (WebCore::Editor::markAllMisspellingsAndBadGrammarInRanges): Ditto.
     54        (WebCore::Editor::changeBackToReplacedString): Ditto.
     55        * editing/SplitTextNodeCommand.cpp:
     56        (WebCore::SplitTextNodeCommand::doApply): Ditto.
     57        (WebCore::SplitTextNodeCommand::doUnapply): Ditto.
     58        * page/Frame.cpp:
     59        (WebCore::Frame::markAllMatchesForText): Ditto.
     60        (WebCore::Frame::setMarkedTextMatchesAreHighlighted): Ditto.
     61        (WebCore::Frame::respondToChangedSelection): Ditto.
     62        * page/FrameView.cpp:
     63        (WebCore::FrameView::getTickmarks): Ditto.
     64        (WebCore::FrameView::paintContents): Ditto.
     65        * page/Page.cpp:
     66        (WebCore::Page::unmarkAllTextMatches): Ditto.
     67        * rendering/HitTestResult.cpp:
     68        (WebCore::HitTestResult::spellingToolTip): Ditto.
     69        (WebCore::HitTestResult::replacedString): Ditto.
     70        * rendering/InlineTextBox.cpp:
     71        (WebCore::InlineTextBox::paintSpellingOrGrammarMarker): Ditto.
     72        (WebCore::InlineTextBox::paintTextMatchMarker): Ditto.
     73        (WebCore::InlineTextBox::computeRectForReplacementMarker): Ditto.
     74        (WebCore::InlineTextBox::paintDocumentMarkers): Ditto.
     75        * rendering/SVGInlineTextBox.cpp:
     76        (WebCore::SVGInlineTextBox::computeTextMatchMarkerRect): Ditto.
     77
    1782010-08-22  Jian Li  <jianli@chromium.org>
    279
  • trunk/WebCore/GNUmakefile.am

    r65767 r65787  
    10431043        WebCore/dom/DeviceOrientationEvent.h \
    10441044        WebCore/dom/Document.cpp \
    1045         WebCore/dom/DocumentParser.cpp \
    10461045        WebCore/dom/Document.h \
    10471046        WebCore/dom/DocumentFragment.cpp \
    10481047        WebCore/dom/DocumentFragment.h \
    10491048        WebCore/dom/DocumentMarker.h \
     1049        WebCore/dom/DocumentMarkerController.cpp \
     1050        WebCore/dom/DocumentMarkerController.h \
     1051        WebCore/dom/DocumentParser.cpp \
    10501052        WebCore/dom/DocumentType.cpp \
    10511053        WebCore/dom/DocumentType.h \
  • trunk/WebCore/WebCore.exp.in

    r65713 r65787  
    466466__ZN7WebCore24createFragmentFromMarkupEPNS_8DocumentERKN3WTF6StringES5_NS_27FragmentScriptingPermissionE
    467467__ZN7WebCore24decodeURLEscapeSequencesERKN3WTF6StringE
     468__ZN7WebCore24DocumentMarkerController13removeMarkersENS_14DocumentMarker10MarkerTypeE
     469__ZN7WebCore24DocumentMarkerController23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE
    468470__ZN7WebCore24notifyHistoryItemChangedE
    469471__ZN7WebCore24rangeCompliantEquivalentERKNS_8PositionE
     
    661663__ZN7WebCore7nsColorERKNS_5ColorE
    662664__ZN7WebCore8Document11createRangeEv
    663 __ZN7WebCore8Document13removeMarkersENS_14DocumentMarker10MarkerTypeE
    664665__ZN7WebCore8Document13svgExtensionsEv
    665666__ZN7WebCore8Document14setFocusedNodeEN3WTF10PassRefPtrINS_4NodeEEE
     
    669670__ZN7WebCore8Document19accessSVGExtensionsEv
    670671__ZN7WebCore8Document22createDocumentFragmentEv
    671 __ZN7WebCore8Document23renderedRectsForMarkersENS_14DocumentMarker10MarkerTypeE
    672672__ZN7WebCore8Document24addMediaCanStartListenerEPNS_21MediaCanStartListenerE
    673673__ZN7WebCore8Document24setShouldCreateRenderersEb
  • trunk/WebCore/WebCore.gypi

    r65763 r65787  
    11521152            'dom/DocumentFragment.h',
    11531153            'dom/DocumentMarker.h',
     1154            'dom/DocumentMarkerController.cpp',
     1155            'dom/DocumentMarkerController.h',
    11541156            'dom/DocumentParser.cpp',
    11551157            'dom/DocumentParser.h',
  • trunk/WebCore/WebCore.pro

    r65763 r65787  
    496496    dom/Document.cpp \
    497497    dom/DocumentFragment.cpp \
     498    dom/DocumentMarkerController.cpp \
    498499    dom/DocumentParser.cpp \
    499500    dom/DocumentType.cpp \
     
    12671268    dom/default/PlatformMessagePortChannel.h \
    12681269    dom/DeviceMotionClient.h \
     1270    dom/DeviceMotionController.h \
    12691271    dom/DeviceMotionData.h \
    1270     dom/DeviceMotionController.h \
    12711272    dom/DeviceMotionEvent.h \
    12721273    dom/DeviceOrientation.h \
     
    12741275    dom/DeviceOrientationController.h \
    12751276    dom/DeviceOrientationEvent.h \
     1277    dom/Document.h \
    12761278    dom/DocumentFragment.h \
    1277     dom/Document.h \
     1279    dom/DocumentMarker.h \
     1280    dom/DocumentMarkerController.h \
    12781281    dom/DocumentType.h \
    12791282    dom/DOMImplementation.h \
  • trunk/WebCore/WebCore.vcproj/WebCore.vcproj

    r65763 r65787  
    3357433574                        </File>
    3357533575                        <File
     33576                                RelativePath="..\dom\DocumentMarkerController.cpp"
     33577                                >
     33578                        </File>
     33579                        <File
     33580                                RelativePath="..\dom\DocumentMarkerController.h"
     33581                                >
     33582                        </File>
     33583                        <File
    3357633584                                RelativePath="..\dom\DocumentParser.cpp"
    3357733585                                >
  • trunk/WebCore/WebCore.xcodeproj/project.pbxproj

    r65768 r65787  
    51045104                C6D74AE409AA290A000B0A52 /* ModifySelectionListLevel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C6D74AE309AA290A000B0A52 /* ModifySelectionListLevel.cpp */; };
    51055105                CE02F0C411E83ADD00C6684A /* ScriptControllerBase.h in Headers */ = {isa = PBXBuildFile; fileRef = CE02F0C311E83ADD00C6684A /* ScriptControllerBase.h */; settings = {ATTRIBUTES = (Private, ); }; };
     5106                CE057FA51220731100A476D5 /* DocumentMarkerController.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CE057FA31220731100A476D5 /* DocumentMarkerController.cpp */; };
     5107                CE057FA61220731100A476D5 /* DocumentMarkerController.h in Headers */ = {isa = PBXBuildFile; fileRef = CE057FA41220731100A476D5 /* DocumentMarkerController.h */; settings = {ATTRIBUTES = (Private, ); }; };
    51065108                CE172E011136E8CE0062A533 /* ZoomMode.h in Headers */ = {isa = PBXBuildFile; fileRef = CE172E001136E8CE0062A533 /* ZoomMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
    51075109                CE4C00E410F6F7BA00CA38F5 /* HTMLNoScriptElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CE4C00E310F6F7BA00CA38F5 /* HTMLNoScriptElement.cpp */; };
     
    1092010922                C6D74AE309AA290A000B0A52 /* ModifySelectionListLevel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ModifySelectionListLevel.cpp; sourceTree = "<group>"; };
    1092110923                CE02F0C311E83ADD00C6684A /* ScriptControllerBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScriptControllerBase.h; sourceTree = "<group>"; };
     10924                CE057FA31220731100A476D5 /* DocumentMarkerController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DocumentMarkerController.cpp; sourceTree = "<group>"; };
     10925                CE057FA41220731100A476D5 /* DocumentMarkerController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DocumentMarkerController.h; sourceTree = "<group>"; };
    1092210926                CE172E001136E8CE0062A533 /* ZoomMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZoomMode.h; sourceTree = "<group>"; };
    1092310927                CE4C00E310F6F7BA00CA38F5 /* HTMLNoScriptElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HTMLNoScriptElement.cpp; sourceTree = "<group>"; };
     
    1737417378                                1A494ED50A123F1A00FDAFC1 /* DocumentFragment.idl */,
    1737517379                                ED2BA83B09A24B91006C0AC4 /* DocumentMarker.h */,
     17380                                CE057FA31220731100A476D5 /* DocumentMarkerController.cpp */,
     17381                                CE057FA41220731100A476D5 /* DocumentMarkerController.h */,
    1737617382                                A8C2280D11D4A59700D5A7D3 /* DocumentParser.cpp */,
    1737717383                                BCCFBAE70B5152ED0001F1D7 /* DocumentParser.h */,
     
    2034120347                                2EF1BFF9121CB0CE00C27627 /* FileStreamClient.h in Headers */,
    2034220348                                89C0DD7B121F0C69009E17CA /* FileSystemCallbacks.h in Headers */,
     20349                                CE057FA61220731100A476D5 /* DocumentMarkerController.h in Headers */,
    2034320350                        );
    2034420351                        runOnlyForDeploymentPostprocessing = 0;
     
    2279322800                                46A26905121B6B4300C41F3A /* FileWriter.cpp in Sources */,
    2279422801                                89C0DD7A121F0C69009E17CA /* FileSystemCallbacks.cpp in Sources */,
     22802                                CE057FA51220731100A476D5 /* DocumentMarkerController.cpp in Sources */,
    2279522803                        );
    2279622804                        runOnlyForDeploymentPostprocessing = 0;
  • trunk/WebCore/dom/Document.cpp

    r65692 r65787  
    124124#include "StyleSheetList.h"
    125125#include "TextEvent.h"
    126 #include "TextIterator.h"
    127126#include "TextResourceDecoder.h"
    128127#include "Timer.h"
     
    423422
    424423    m_axObjectCache = 0;
    425    
     424
     425    m_markers = new DocumentMarkerController();
     426
    426427    m_docLoader = new DocLoader(this);
    427428
     
    496497        removeAllChildren();
    497498
    498         deleteAllValues(m_markers);
    499         m_markers.clear();
     499        m_markers->detach();
    500500
    501501        detachParser();
     
    548548    m_bindingManager.clear();
    549549#endif
    550 
    551     deleteAllValues(m_markers);
    552550
    553551    clearAXObjectCache();
     
    31903188
    31913189    // Update the markers for spelling and grammar checking.
    3192     shiftMarkers(text, offset, length);
     3190    m_markers->shiftMarkers(text, offset, length);
    31933191}
    31943192
     
    32023200
    32033201    // Update the markers for spelling and grammar checking.
    3204     removeMarkers(text, offset, length);
    3205     shiftMarkers(text, offset + length, 0 - length);
     3202    m_markers->removeMarkers(text, offset, length);
     3203    m_markers->shiftMarkers(text, offset + length, 0 - length);
    32063204}
    32073205
     
    38163814}
    38173815
    3818 static IntRect placeholderRectForMarker()
    3819 {
    3820     return IntRect(-1, -1, -1, -1);
    3821 }
    3822 
    3823 void Document::addMarker(Range* range, DocumentMarker::MarkerType type, String description)
    3824 {
    3825     // Use a TextIterator to visit the potentially multiple nodes the range covers.
    3826     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
    3827         RefPtr<Range> textPiece = markedText.range();
    3828         int exception = 0;
    3829         DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception), description, false};
    3830         addMarker(textPiece->startContainer(exception), marker);
    3831     }
    3832 }
    3833 
    3834 void Document::removeMarkers(Range* range, DocumentMarker::MarkerType markerType)
    3835 {
    3836     if (m_markers.isEmpty())
    3837         return;
    3838 
    3839     ExceptionCode ec = 0;
    3840     Node* startContainer = range->startContainer(ec);
    3841     Node* endContainer = range->endContainer(ec);
    3842 
    3843     Node* pastLastNode = range->pastLastNode();
    3844     for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
    3845         int startOffset = node == startContainer ? range->startOffset(ec) : 0;
    3846         int endOffset = node == endContainer ? range->endOffset(ec) : INT_MAX;
    3847         int length = endOffset - startOffset;
    3848         removeMarkers(node, startOffset, length, markerType);
    3849     }
    3850 }
    3851 
    3852 // Markers are stored in order sorted by their start offset.
    3853 // Markers of the same type do not overlap each other.
    3854 
    3855 void Document::addMarker(Node* node, DocumentMarker newMarker)
    3856 {
    3857     ASSERT(newMarker.endOffset >= newMarker.startOffset);
    3858     if (newMarker.endOffset == newMarker.startOffset)
    3859         return;
    3860 
    3861     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    3862 
    3863     if (!vectorPair) {
    3864         vectorPair = new MarkerMapVectorPair;
    3865         vectorPair->first.append(newMarker);
    3866         vectorPair->second.append(placeholderRectForMarker());
    3867         m_markers.set(node, vectorPair);
    3868     } else {
    3869         Vector<DocumentMarker>& markers = vectorPair->first;
    3870         Vector<IntRect>& rects = vectorPair->second;
    3871         size_t numMarkers = markers.size();
    3872         ASSERT(numMarkers == rects.size());
    3873         size_t i;
    3874         // Iterate over all markers whose start offset is less than or equal to the new marker's.
    3875         // If one of them is of the same type as the new marker and touches it or intersects with it
    3876         // (there is at most one), remove it and adjust the new marker's start offset to encompass it.
    3877         for (i = 0; i < numMarkers; ++i) {
    3878             DocumentMarker marker = markers[i];
    3879             if (marker.startOffset > newMarker.startOffset)
    3880                 break;
    3881             if (marker.type == newMarker.type && marker.endOffset >= newMarker.startOffset) {
    3882                 newMarker.startOffset = marker.startOffset;
    3883                 markers.remove(i);
    3884                 rects.remove(i);
    3885                 numMarkers--;
    3886                 break;
    3887             }
    3888         }
    3889         size_t j = i;
    3890         // Iterate over all markers whose end offset is less than or equal to the new marker's,
    3891         // removing markers of the same type as the new marker which touch it or intersect with it,
    3892         // adjusting the new marker's end offset to cover them if necessary.
    3893         while (j < numMarkers) {
    3894             DocumentMarker marker = markers[j];
    3895             if (marker.startOffset > newMarker.endOffset)
    3896                 break;
    3897             if (marker.type == newMarker.type) {
    3898                 markers.remove(j);
    3899                 rects.remove(j);
    3900                 if (newMarker.endOffset <= marker.endOffset) {
    3901                     newMarker.endOffset = marker.endOffset;
    3902                     break;
    3903                 }
    3904                 numMarkers--;
    3905             } else
    3906                 j++;
    3907         }
    3908         // At this point i points to the node before which we want to insert.
    3909         markers.insert(i, newMarker);
    3910         rects.insert(i, placeholderRectForMarker());
    3911     }
    3912    
    3913     // repaint the affected node
    3914     if (node->renderer())
    3915         node->renderer()->repaint();
    3916 }
    3917 
    3918 // copies markers from srcNode to dstNode, applying the specified shift delta to the copies.  The shift is
    3919 // useful if, e.g., the caller has created the dstNode from a non-prefix substring of the srcNode.
    3920 void Document::copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta, DocumentMarker::MarkerType markerType)
    3921 {
    3922     if (length <= 0)
    3923         return;
    3924    
    3925     MarkerMapVectorPair* vectorPair = m_markers.get(srcNode);
    3926     if (!vectorPair)
    3927         return;
    3928 
    3929     ASSERT(vectorPair->first.size() == vectorPair->second.size());
    3930 
    3931     bool docDirty = false;
    3932     unsigned endOffset = startOffset + length - 1;
    3933     Vector<DocumentMarker>& markers = vectorPair->first;
    3934     for (size_t i = 0; i != markers.size(); ++i) {
    3935         DocumentMarker marker = markers[i];
    3936 
    3937         // stop if we are now past the specified range
    3938         if (marker.startOffset > endOffset)
    3939             break;
    3940        
    3941         // skip marker that is before the specified range or is the wrong type
    3942         if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers))
    3943             continue;
    3944 
    3945         // pin the marker to the specified range and apply the shift delta
    3946         docDirty = true;
    3947         if (marker.startOffset < startOffset)
    3948             marker.startOffset = startOffset;
    3949         if (marker.endOffset > endOffset)
    3950             marker.endOffset = endOffset;
    3951         marker.startOffset += delta;
    3952         marker.endOffset += delta;
    3953        
    3954         addMarker(dstNode, marker);
    3955     }
    3956    
    3957     // repaint the affected node
    3958     if (docDirty && dstNode->renderer())
    3959         dstNode->renderer()->repaint();
    3960 }
    3961 
    3962 void Document::removeMarkers(Node* node, unsigned startOffset, int length, DocumentMarker::MarkerType markerType)
    3963 {
    3964     if (length <= 0)
    3965         return;
    3966 
    3967     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    3968     if (!vectorPair)
    3969         return;
    3970 
    3971     Vector<DocumentMarker>& markers = vectorPair->first;
    3972     Vector<IntRect>& rects = vectorPair->second;
    3973     ASSERT(markers.size() == rects.size());
    3974     bool docDirty = false;
    3975     unsigned endOffset = startOffset + length;
    3976     for (size_t i = 0; i < markers.size();) {
    3977         DocumentMarker marker = markers[i];
    3978 
    3979         // markers are returned in order, so stop if we are now past the specified range
    3980         if (marker.startOffset >= endOffset)
    3981             break;
    3982        
    3983         // skip marker that is wrong type or before target
    3984         if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers)) {
    3985             i++;
    3986             continue;
    3987         }
    3988 
    3989         // at this point we know that marker and target intersect in some way
    3990         docDirty = true;
    3991 
    3992         // pitch the old marker and any associated rect
    3993         markers.remove(i);
    3994         rects.remove(i);
    3995        
    3996         // add either of the resulting slices that are left after removing target
    3997         if (startOffset > marker.startOffset) {
    3998             DocumentMarker newLeft = marker;
    3999             newLeft.endOffset = startOffset;
    4000             markers.insert(i, newLeft);
    4001             rects.insert(i, placeholderRectForMarker());
    4002             // i now points to the newly-inserted node, but we want to skip that one
    4003             i++;
    4004         }
    4005         if (marker.endOffset > endOffset) {
    4006             DocumentMarker newRight = marker;
    4007             newRight.startOffset = endOffset;
    4008             markers.insert(i, newRight);
    4009             rects.insert(i, placeholderRectForMarker());
    4010             // i now points to the newly-inserted node, but we want to skip that one
    4011             i++;
    4012         }
    4013     }
    4014 
    4015     if (markers.isEmpty()) {
    4016         ASSERT(rects.isEmpty());
    4017         m_markers.remove(node);
    4018         delete vectorPair;
    4019     }
    4020 
    4021     // repaint the affected node
    4022     if (docDirty && node->renderer())
    4023         node->renderer()->repaint();
    4024 }
    4025 
    4026 DocumentMarker* Document::markerContainingPoint(const IntPoint& point, DocumentMarker::MarkerType markerType)
    4027 {
    4028     // outer loop: process each node that contains any markers
    4029     MarkerMap::iterator end = m_markers.end();
    4030     for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
    4031         // inner loop; process each marker in this node
    4032         MarkerMapVectorPair* vectorPair = nodeIterator->second;
    4033         Vector<DocumentMarker>& markers = vectorPair->first;
    4034         Vector<IntRect>& rects = vectorPair->second;
    4035         ASSERT(markers.size() == rects.size());
    4036         unsigned markerCount = markers.size();
    4037         for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    4038             DocumentMarker& marker = markers[markerIndex];
    4039            
    4040             // skip marker that is wrong type
    4041             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers)
    4042                 continue;
    4043            
    4044             IntRect& r = rects[markerIndex];
    4045            
    4046             // skip placeholder rects
    4047             if (r == placeholderRectForMarker())
    4048                 continue;
    4049            
    4050             if (r.contains(point))
    4051                 return &marker;
    4052         }
    4053     }
    4054    
    4055     return 0;
    4056 }
    4057 
    4058 Vector<DocumentMarker> Document::markersForNode(Node* node)
    4059 {
    4060     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    4061     if (vectorPair)
    4062         return vectorPair->first;
    4063     return Vector<DocumentMarker>();
    4064 }
    4065 
    4066 Vector<IntRect> Document::renderedRectsForMarkers(DocumentMarker::MarkerType markerType)
    4067 {
    4068     Vector<IntRect> result;
    4069    
    4070     // outer loop: process each node
    4071     MarkerMap::iterator end = m_markers.end();
    4072     for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
    4073         // inner loop; process each marker in this node
    4074         MarkerMapVectorPair* vectorPair = nodeIterator->second;
    4075         Vector<DocumentMarker>& markers = vectorPair->first;
    4076         Vector<IntRect>& rects = vectorPair->second;
    4077         ASSERT(markers.size() == rects.size());
    4078         unsigned markerCount = markers.size();
    4079         for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    4080             DocumentMarker marker = markers[markerIndex];
    4081            
    4082             // skip marker that is wrong type
    4083             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers)
    4084                 continue;
    4085            
    4086             IntRect r = rects[markerIndex];
    4087             // skip placeholder rects
    4088             if (r == placeholderRectForMarker())
    4089                 continue;
    4090 
    4091             result.append(r);
    4092         }
    4093     }
    4094    
    4095     return result;
    4096 }
    4097 
    4098 void Document::removeMarkers(Node* node)
    4099 {
    4100     MarkerMap::iterator i = m_markers.find(node);
    4101     if (i != m_markers.end()) {
    4102         delete i->second;
    4103         m_markers.remove(i);
    4104         if (RenderObject* renderer = node->renderer())
    4105             renderer->repaint();
    4106     }
    4107 }
    4108 
    4109 void Document::removeMarkers(DocumentMarker::MarkerType markerType)
    4110 {
    4111     // outer loop: process each markered node in the document
    4112     MarkerMap markerMapCopy = m_markers;
    4113     MarkerMap::iterator end = markerMapCopy.end();
    4114     for (MarkerMap::iterator i = markerMapCopy.begin(); i != end; ++i) {
    4115         Node* node = i->first.get();
    4116         bool nodeNeedsRepaint = false;
    4117 
    4118         // inner loop: process each marker in the current node
    4119         MarkerMapVectorPair* vectorPair = i->second;
    4120         Vector<DocumentMarker>& markers = vectorPair->first;
    4121         Vector<IntRect>& rects = vectorPair->second;
    4122         ASSERT(markers.size() == rects.size());
    4123         for (size_t i = 0; i != markers.size();) {
    4124             DocumentMarker marker = markers[i];
    4125 
    4126             // skip nodes that are not of the specified type
    4127             if (marker.type != markerType && markerType != DocumentMarker::AllMarkers) {
    4128                 ++i;
    4129                 continue;
    4130             }
    4131 
    4132             // pitch the old marker
    4133             markers.remove(i);
    4134             rects.remove(i);
    4135             nodeNeedsRepaint = true;
    4136             // markerIterator now points to the next node
    4137         }
    4138 
    4139         // Redraw the node if it changed. Do this before the node is removed from m_markers, since
    4140         // m_markers might contain the last reference to the node.
    4141         if (nodeNeedsRepaint) {
    4142             RenderObject* renderer = node->renderer();
    4143             if (renderer)
    4144                 renderer->repaint();
    4145         }
    4146 
    4147         // delete the node's list if it is now empty
    4148         if (markers.isEmpty()) {
    4149             ASSERT(rects.isEmpty());
    4150             m_markers.remove(node);
    4151             delete vectorPair;
    4152         }
    4153     }
    4154 }
    4155 
    4156 void Document::repaintMarkers(DocumentMarker::MarkerType markerType)
    4157 {
    4158     // outer loop: process each markered node in the document
    4159     MarkerMap::iterator end = m_markers.end();
    4160     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
    4161         Node* node = i->first.get();
    4162        
    4163         // inner loop: process each marker in the current node
    4164         MarkerMapVectorPair* vectorPair = i->second;
    4165         Vector<DocumentMarker>& markers = vectorPair->first;
    4166         bool nodeNeedsRepaint = false;
    4167         for (size_t i = 0; i != markers.size(); ++i) {
    4168             DocumentMarker marker = markers[i];
    4169            
    4170             // skip nodes that are not of the specified type
    4171             if (marker.type == markerType || markerType == DocumentMarker::AllMarkers) {
    4172                 nodeNeedsRepaint = true;
    4173                 break;
    4174             }
    4175         }
    4176        
    4177         if (!nodeNeedsRepaint)
    4178             continue;
    4179        
    4180         // cause the node to be redrawn
    4181         if (RenderObject* renderer = node->renderer())
    4182             renderer->repaint();
    4183     }
    4184 }
    4185 
    4186 void Document::setRenderedRectForMarker(Node* node, const DocumentMarker& marker, const IntRect& r)
    4187 {
    4188     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    4189     if (!vectorPair) {
    4190         ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
    4191         return;
    4192     }
    4193    
    4194     Vector<DocumentMarker>& markers = vectorPair->first;
    4195     ASSERT(markers.size() == vectorPair->second.size());
    4196     unsigned markerCount = markers.size();
    4197     for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
    4198         DocumentMarker m = markers[markerIndex];
    4199         if (m == marker) {
    4200             vectorPair->second[markerIndex] = r;
    4201             return;
    4202         }
    4203     }
    4204    
    4205     ASSERT_NOT_REACHED(); // shouldn't be trying to set the rect for a marker we don't already know about
    4206 }
    4207 
    4208 void Document::invalidateRenderedRectsForMarkersInRect(const IntRect& r)
    4209 {
    4210     // outer loop: process each markered node in the document
    4211     MarkerMap::iterator end = m_markers.end();
    4212     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
    4213        
    4214         // inner loop: process each rect in the current node
    4215         MarkerMapVectorPair* vectorPair = i->second;
    4216         Vector<IntRect>& rects = vectorPair->second;
    4217        
    4218         unsigned rectCount = rects.size();
    4219         for (unsigned rectIndex = 0; rectIndex < rectCount; ++rectIndex)
    4220             if (rects[rectIndex].intersects(r))
    4221                 rects[rectIndex] = placeholderRectForMarker();
    4222     }
    4223 }
    4224 
    4225 void Document::shiftMarkers(Node* node, unsigned startOffset, int delta, DocumentMarker::MarkerType markerType)
    4226 {
    4227     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    4228     if (!vectorPair)
    4229         return;
    4230    
    4231     Vector<DocumentMarker>& markers = vectorPair->first;
    4232     Vector<IntRect>& rects = vectorPair->second;
    4233     ASSERT(markers.size() == rects.size());
    4234    
    4235     bool docDirty = false;
    4236     for (size_t i = 0; i != markers.size(); ++i) {
    4237         DocumentMarker& marker = markers[i];
    4238         if (marker.startOffset >= startOffset && (markerType == DocumentMarker::AllMarkers || marker.type == markerType)) {
    4239             ASSERT((int)marker.startOffset + delta >= 0);
    4240             marker.startOffset += delta;
    4241             marker.endOffset += delta;
    4242             docDirty = true;
    4243            
    4244             // Marker moved, so previously-computed rendered rectangle is now invalid
    4245             rects[i] = placeholderRectForMarker();
    4246         }
    4247     }
    4248    
    4249     // repaint the affected node
    4250     if (docDirty && node->renderer())
    4251         node->renderer()->repaint();
    4252 }
    4253 
    4254 void Document::setMarkersActive(Range* range, bool active)
    4255 {
    4256     if (m_markers.isEmpty())
    4257         return;
    4258 
    4259     ExceptionCode ec = 0;
    4260     Node* startContainer = range->startContainer(ec);
    4261     Node* endContainer = range->endContainer(ec);
    4262 
    4263     Node* pastLastNode = range->pastLastNode();
    4264     for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
    4265         int startOffset = node == startContainer ? range->startOffset(ec) : 0;
    4266         int endOffset = node == endContainer ? range->endOffset(ec) : INT_MAX;
    4267         setMarkersActive(node, startOffset, endOffset, active);
    4268     }
    4269 }
    4270 
    4271 void Document::setMarkersActive(Node* node, unsigned startOffset, unsigned endOffset, bool active)
    4272 {
    4273     MarkerMapVectorPair* vectorPair = m_markers.get(node);
    4274     if (!vectorPair)
    4275         return;
    4276 
    4277     Vector<DocumentMarker>& markers = vectorPair->first;
    4278     ASSERT(markers.size() == vectorPair->second.size());
    4279 
    4280     bool docDirty = false;
    4281     for (size_t i = 0; i != markers.size(); ++i) {
    4282         DocumentMarker& marker = markers[i];
    4283 
    4284         // Markers are returned in order, so stop if we are now past the specified range.
    4285         if (marker.startOffset >= endOffset)
    4286             break;
    4287 
    4288         // Skip marker that is wrong type or before target.
    4289         if (marker.endOffset < startOffset || marker.type != DocumentMarker::TextMatch)
    4290             continue;
    4291 
    4292         marker.activeMatch = active;
    4293         docDirty = true;
    4294     }
    4295 
    4296     // repaint the affected node
    4297     if (docDirty && node->renderer())
    4298         node->renderer()->repaint();
    4299 }
    4300 
    43013816#if ENABLE(XSLT)
    43023817
  • trunk/WebCore/dom/Document.h

    r65692 r65787  
    3333#include "Color.h"
    3434#include "ContainerNode.h"
    35 #include "DocumentMarker.h"
     35#include "DocumentMarkerController.h"
    3636#include "QualifiedName.h"
    3737#include "ScriptExecutionContext.h"
     
    812812    HTMLHeadElement* head();
    813813
     814    DocumentMarkerController* markers() const { return m_markers.get(); }
     815
    814816    bool execCommand(const String& command, bool userInterface = false, const String& value = String());
    815817    bool queryCommandEnabled(const String& command);
     
    818820    bool queryCommandSupported(const String& command);
    819821    String queryCommandValue(const String& command);
    820    
    821     void addMarker(Range*, DocumentMarker::MarkerType, String description = String());
    822     void addMarker(Node*, DocumentMarker);
    823     void copyMarkers(Node *srcNode, unsigned startOffset, int length, Node *dstNode, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    824     void removeMarkers(Range*, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    825     void removeMarkers(Node*, unsigned startOffset, int length, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    826     void removeMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    827     void removeMarkers(Node*);
    828     void repaintMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    829     void setRenderedRectForMarker(Node*, const DocumentMarker&, const IntRect&);
    830     void invalidateRenderedRectsForMarkersInRect(const IntRect&);
    831     void shiftMarkers(Node*, unsigned startOffset, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    832     void setMarkersActive(Range*, bool);
    833     void setMarkersActive(Node*, unsigned startOffset, unsigned endOffset, bool);
    834 
    835     DocumentMarker* markerContainingPoint(const IntPoint&, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    836     Vector<DocumentMarker> markersForNode(Node*);
    837     Vector<IntRect> renderedRectsForMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
    838822   
    839823    // designMode support
     
    11861170    OwnPtr<RenderArena> m_renderArena;
    11871171
    1188     typedef std::pair<Vector<DocumentMarker>, Vector<IntRect> > MarkerMapVectorPair;
    1189     typedef HashMap<RefPtr<Node>, MarkerMapVectorPair*> MarkerMap;
    1190     MarkerMap m_markers;
    1191 
    11921172    mutable AXObjectCache* m_axObjectCache;
     1173    OwnPtr<DocumentMarkerController> m_markers;
    11931174   
    11941175    Timer<Document> m_updateFocusAppearanceTimer;
  • trunk/WebCore/editing/Editor.cpp

    r65395 r65787  
    15641564    RefPtr<Range> selectedRange = frame()->selection()->toNormalizedRange();
    15651565    if (selectedRange)
    1566         frame()->document()->removeMarkers(selectedRange.get(), DocumentMarker::Spelling);
     1566        frame()->document()->markers()->removeMarkers(selectedRange.get(), DocumentMarker::Spelling);
    15671567
    15681568    String text = frame()->selectedText();
     
    16301630                // Store marker for misspelled word.
    16311631                ExceptionCode ec = 0;
    1632                 misspellingRange->startContainer(ec)->document()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
     1632                misspellingRange->startContainer(ec)->document()->markers()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
    16331633                ASSERT(!ec);
    16341634
     
    16931693            RefPtr<Range> badGrammarRange = TextIterator::subrange(searchRange, badGrammarPhraseLocation - startOffset + detail->location, detail->length);
    16941694            ExceptionCode ec = 0;
    1695             badGrammarRange->startContainer(ec)->document()->addMarker(badGrammarRange.get(), DocumentMarker::Grammar, detail->userDescription);
     1695            badGrammarRange->startContainer(ec)->document()->markers()->addMarker(badGrammarRange.get(), DocumentMarker::Grammar, detail->userDescription);
    16961696            ASSERT(!ec);
    16971697        }
     
    20642064       
    20652065        client()->updateSpellingUIWithGrammarString(badGrammarPhrase, grammarDetail);
    2066         frame()->document()->addMarker(badGrammarRange.get(), DocumentMarker::Grammar, grammarDetail.userDescription);
     2066        frame()->document()->markers()->addMarker(badGrammarRange.get(), DocumentMarker::Grammar, grammarDetail.userDescription);
    20672067#endif       
    20682068    } else if (!misspelledWord.isEmpty()) {
     
    20752075       
    20762076        client()->updateSpellingUIWithMisspelledWord(misspelledWord);
    2077         frame()->document()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
     2077        frame()->document()->markers()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
    20782078    }
    20792079}
     
    25442544            ASSERT(resultLength > 0 && resultLocation >= 0);
    25452545            RefPtr<Range> misspellingRange = TextIterator::subrange(spellingRange, resultLocation - spellingRangeStartOffset, resultLength);
    2546             misspellingRange->startContainer(ec)->document()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
     2546            misspellingRange->startContainer(ec)->document()->markers()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
    25472547        } else if (markGrammar && result->type == TextCheckingTypeGrammar && resultLocation < grammarRangeEndOffset && resultLocation + resultLength > grammarRangeStartOffset) {
    25482548            ASSERT(resultLength > 0 && resultLocation >= 0);
     
    25522552                if (resultLocation + detail->location >= grammarRangeStartOffset && resultLocation + detail->location + detail->length <= grammarRangeEndOffset) {
    25532553                    RefPtr<Range> badGrammarRange = TextIterator::subrange(grammarRange, resultLocation + detail->location - grammarRangeStartOffset, detail->length);
    2554                     grammarRange->startContainer(ec)->document()->addMarker(badGrammarRange.get(), DocumentMarker::Grammar, detail->userDescription);
     2554                    grammarRange->startContainer(ec)->document()->markers()->addMarker(badGrammarRange.get(), DocumentMarker::Grammar, detail->userDescription);
    25552555                }
    25562556            }
     
    25822582                int startOffset = rangeToReplace->startOffset();
    25832583                int endOffset = startOffset + replacementLength;
    2584                 Vector<DocumentMarker> markers = node->document()->markersForNode(node);
     2584                Vector<DocumentMarker> markers = node->document()->markers()->markersForNode(node);
    25852585                size_t markerCount = markers.size();
    25862586                for (size_t i = 0; i < markerCount; ++i) {
     
    26192619                        // Add a marker so that corrections can easily be undone and won't be re-corrected.
    26202620                        RefPtr<Range> replacedRange = TextIterator::subrange(paragraphRange.get(), resultLocation, replacementLength);
    2621                         replacedRange->startContainer()->document()->addMarker(replacedRange.get(), DocumentMarker::Replacement, replacedString);
     2621                        replacedRange->startContainer()->document()->markers()->addMarker(replacedRange.get(), DocumentMarker::Replacement, replacedString);
    26222622                    }
    26232623                }
     
    26572657    replaceSelectionWithText(replacedString, false, false);
    26582658    RefPtr<Range> changedRange = TextIterator::subrange(paragraphRange.get(), selectionOffset, replacedString.length());
    2659     changedRange->startContainer()->document()->addMarker(changedRange.get(), DocumentMarker::Replacement, String());
     2659    changedRange->startContainer()->document()->markers()->addMarker(changedRange.get(), DocumentMarker::Replacement, String());
    26602660}
    26612661
  • trunk/WebCore/editing/SplitTextNodeCommand.cpp

    r64034 r65787  
    6161    m_text1 = Text::create(document(), prefixText);
    6262    ASSERT(m_text1);
    63     document()->copyMarkers(m_text2.get(), 0, m_offset, m_text1.get(), 0);
     63    document()->markers()->copyMarkers(m_text2.get(), 0, m_offset, m_text1.get(), 0);
    6464
    6565    insertText1AndTrimText2();
     
    7979    ASSERT(!ec);
    8080
    81     document()->copyMarkers(m_text1.get(), 0, prefixText.length(), m_text2.get(), 0);
     81    document()->markers()->copyMarkers(m_text1.get(), 0, prefixText.length(), m_text2.get(), 0);
    8282    m_text1->remove(ec);
    8383}
  • trunk/WebCore/page/Frame.cpp

    r64735 r65787  
    12781278        if (editor()->insideVisibleArea(resultRange.get())) {
    12791279            ++matchCount;
    1280             document()->addMarker(resultRange.get(), DocumentMarker::TextMatch);
     1280            document()->markers()->addMarker(resultRange.get(), DocumentMarker::TextMatch);
    12811281        }
    12821282
     
    13181318
    13191319    m_highlightTextMatches = flag;
    1320     document()->repaintMarkers(DocumentMarker::TextMatch);
     1320    document()->markers()->repaintMarkers(DocumentMarker::TextMatch);
    13211321}
    13221322
     
    14641464        // Perhaps peculiar, but it matches AppKit.
    14651465        if (RefPtr<Range> wordRange = newAdjacentWords.toNormalizedRange())
    1466             document()->removeMarkers(wordRange.get(), DocumentMarker::Spelling);
     1466            document()->markers()->removeMarkers(wordRange.get(), DocumentMarker::Spelling);
    14671467        if (RefPtr<Range> sentenceRange = newSelectedSentence.toNormalizedRange())
    1468             document()->removeMarkers(sentenceRange.get(), DocumentMarker::Grammar);
     1468            document()->markers()->removeMarkers(sentenceRange.get(), DocumentMarker::Grammar);
    14691469    }
    14701470
    14711471    // When continuous spell checking is off, existing markers disappear after the selection changes.
    14721472    if (!isContinuousSpellCheckingEnabled)
    1473         document()->removeMarkers(DocumentMarker::Spelling);
     1473        document()->markers()->removeMarkers(DocumentMarker::Spelling);
    14741474    if (!isContinuousGrammarCheckingEnabled)
    1475         document()->removeMarkers(DocumentMarker::Grammar);
     1475        document()->markers()->removeMarkers(DocumentMarker::Grammar);
    14761476
    14771477    editor()->respondToChangedSelection(oldSelection);
  • trunk/WebCore/page/FrameView.cpp

    r65716 r65787  
    17441744void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
    17451745{
    1746     tickmarks = frame()->document()->renderedRectsForMarkers(DocumentMarker::TextMatch);
     1746    tickmarks = frame()->document()->markers()->renderedRectsForMarkers(DocumentMarker::TextMatch);
    17471747}
    17481748
     
    19511951    PaintBehavior oldPaintBehavior = m_paintBehavior;
    19521952    if (m_paintBehavior == PaintBehaviorNormal)
    1953         document->invalidateRenderedRectsForMarkersInRect(rect);
     1953        document->markers()->invalidateRenderedRectsForMarkersInRect(rect);
    19541954
    19551955    if (document->printing())
  • trunk/WebCore/page/Page.cpp

    r65566 r65787  
    541541    Frame* frame = mainFrame();
    542542    do {
    543         frame->document()->removeMarkers(DocumentMarker::TextMatch);
     543        frame->document()->markers()->removeMarkers(DocumentMarker::TextMatch);
    544544        frame = incrementFrame(frame, true, false);
    545545    } while (frame);
  • trunk/WebCore/rendering/HitTestResult.cpp

    r64272 r65787  
    167167        return String();
    168168   
    169     DocumentMarker* marker = m_innerNonSharedNode->document()->markerContainingPoint(m_point, DocumentMarker::Grammar);
     169    DocumentMarker* marker = m_innerNonSharedNode->document()->markers()->markerContainingPoint(m_point, DocumentMarker::Grammar);
    170170    if (!marker)
    171171        return String();
     
    183183        return String();
    184184   
    185     DocumentMarker* marker = m_innerNonSharedNode->document()->markerContainingPoint(m_point, DocumentMarker::Replacement);
     185    DocumentMarker* marker = m_innerNonSharedNode->document()->markers()->markerContainingPoint(m_point, DocumentMarker::Replacement);
    186186    if (!marker)
    187187        return String();
  • trunk/WebCore/rendering/InlineTextBox.cpp

    r64272 r65787  
    811811            markerRect.move(-tx, -ty);
    812812            markerRect = renderer()->localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
    813             renderer()->document()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
     813            renderer()->document()->markers()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
    814814        }
    815815    }
     
    849849    IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, IntPoint(m_x, y), h, sPos, ePos));
    850850    markerRect = renderer()->localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
    851     renderer()->document()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
     851    renderer()->document()->markers()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
    852852     
    853853    // Optionally highlight the text
     
    878878    IntRect markerRect = enclosingIntRect(font.selectionRectForText(run, startPoint, h, sPos, ePos));
    879879    markerRect = renderer()->localToAbsoluteQuad(FloatRect(markerRect)).enclosingBoundingBox();
    880     renderer()->document()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
     880    renderer()->document()->markers()->setRenderedRectForMarker(renderer()->node(), marker, markerRect);
    881881}
    882882   
     
    886886        return;
    887887
    888     Vector<DocumentMarker> markers = renderer()->document()->markersForNode(renderer()->node());
     888    Vector<DocumentMarker> markers = renderer()->document()->markers()->markersForNode(renderer()->node());
    889889    Vector<DocumentMarker>::iterator markerIt = markers.begin();
    890890
  • trunk/WebCore/rendering/SVGInlineTextBox.cpp

    r64830 r65787  
    409409
    410410    Document* document = renderer()->document();
    411     Vector<DocumentMarker> markers = document->markersForNode(renderer()->node());
     411    Vector<DocumentMarker> markers = document->markers()->markersForNode(renderer()->node());
    412412
    413413    Vector<DocumentMarker>::iterator markerEnd = markers.end();
     
    431431            markerRect = m_chunkTransformation.mapRect(markerRect);
    432432
    433         document->setRenderedRectForMarker(node, marker, renderer()->localToAbsoluteQuad(markerRect).enclosingBoundingBox());
     433        document->markers()->setRenderedRectForMarker(node, marker, renderer()->localToAbsoluteQuad(markerRect).enclosingBoundingBox());
    434434    }
    435435}
  • trunk/WebKit/chromium/ChangeLog

    r65786 r65787  
     12010-08-22  Daniel Bates  <dbates@rim.com>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Encapsulate document marker management into DocumentMarkerController
     6        https://bugs.webkit.org/show_bug.cgi?id=44383
     7
     8        Modify call sites in the Chromium port to use DocumentMarkerController.
     9
     10        No functionality was changed, so no new tests.
     11
     12        * src/WebFrameImpl.cpp:
     13        (WebKit::WebFrameImpl::stopFinding):
     14        (WebKit::WebFrameImpl::addMarker):
     15        (WebKit::WebFrameImpl::setMarkerActive):
     16
    1172010-08-22  Jian Li  <jianli@chromium.org>
    218
  • trunk/WebKit/chromium/src/WebFrameImpl.cpp

    r65536 r65787  
    14301430
    14311431    // Remove all markers for matches found and turn off the highlighting.
    1432     frame()->document()->removeMarkers(DocumentMarker::TextMatch);
     1432    frame()->document()->markers()->removeMarkers(DocumentMarker::TextMatch);
    14331433    frame()->setMarkedTextMatchesAreHighlighted(false);
    14341434
     
    20612061            // Find the node to add a marker to and add it.
    20622062            Node* node = textPiece->startContainer(exception);
    2063             frame()->document()->addMarker(node, marker);
     2063            frame()->document()->markers()->addMarker(node, marker);
    20642064
    20652065            // Rendered rects for markers in WebKit are not populated until each time
     
    20672067            // the whole purpose of tickmarks on the scrollbar is to show where
    20682068            // matches off-screen are (that haven't been painted yet).
    2069             Vector<DocumentMarker> markers = frame()->document()->markersForNode(node);
    2070             frame()->document()->setRenderedRectForMarker(
     2069            Vector<DocumentMarker> markers = frame()->document()->markers()->markersForNode(node);
     2070            frame()->document()->markers()->setRenderedRectForMarker(
    20712071                textPiece->startContainer(exception),
    20722072                markers[markers.size() - 1],
     
    20822082        return;
    20832083
    2084     frame()->document()->setMarkersActive(range, active);
     2084    frame()->document()->markers()->setMarkersActive(range, active);
    20852085}
    20862086
  • trunk/WebKit/efl/ChangeLog

    r65744 r65787  
     12010-08-22  Daniel Bates  <dbates@rim.com>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Encapsulate document marker management into DocumentMarkerController
     6        https://bugs.webkit.org/show_bug.cgi?id=44383
     7
     8        Modify call sites in the EFL port to use DocumentMarkerController.
     9
     10        No functionality was changed, so no new tests.
     11
     12        * ewk/ewk_frame.cpp:
     13        (ewk_frame_text_matches_unmark_all):
     14
    1152010-08-20  Leandro Pereira  <leandro@profusion.mobi>
    216
  • trunk/WebKit/efl/ewk/ewk_frame.cpp

    r65122 r65787  
    787787    EINA_SAFETY_ON_NULL_RETURN_VAL(sd->frame, EINA_FALSE);
    788788
    789     sd->frame->document()->removeMarkers(WebCore::DocumentMarker::TextMatch);
     789    sd->frame->document()->markers()->removeMarkers(WebCore::DocumentMarker::TextMatch);
    790790    return EINA_TRUE;
    791791}
  • trunk/WebKit/mac/ChangeLog

    r65697 r65787  
     12010-08-22  Daniel Bates  <dbates@rim.com>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Encapsulate document marker management into DocumentMarkerController
     6        https://bugs.webkit.org/show_bug.cgi?id=44383
     7
     8        Modify call sites in the Apple Mac port to use DocumentMarkerController.
     9
     10        No functionality was changed, so no new tests.
     11
     12        * WebView/WebFrame.mm:
     13        (-[WebFrame _unmarkAllBadGrammar]):
     14        (-[WebFrame _unmarkAllMisspellings]):
     15        * WebView/WebHTMLView.mm:
     16        (-[WebHTMLView unmarkAllTextMatches]):
     17        (-[WebHTMLView rectsForTextMatches]):
     18
    1192010-08-19  David Kilzer  <ddkilzer@apple.com>
    220
  • trunk/WebKit/mac/WebView/WebFrame.mm

    r65107 r65787  
    396396    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {
    397397        if (Document* document = frame->document())
    398             document->removeMarkers(DocumentMarker::Grammar);
     398            document->markers()->removeMarkers(DocumentMarker::Grammar);
    399399    }
    400400}
     
    406406    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {
    407407        if (Document* document = frame->document())
    408             document->removeMarkers(DocumentMarker::Spelling);
     408            document->markers()->removeMarkers(DocumentMarker::Spelling);
    409409    }
    410410}
  • trunk/WebKit/mac/WebView/WebHTMLView.mm

    r65697 r65787  
    62316231    if (!document)
    62326232        return;
    6233     document->removeMarkers(DocumentMarker::TextMatch);
     6233    document->markers()->removeMarkers(DocumentMarker::TextMatch);
    62346234}
    62356235
     
    62436243        return [NSArray array];
    62446244
    6245     Vector<IntRect> rects = document->renderedRectsForMarkers(DocumentMarker::TextMatch);
     6245    Vector<IntRect> rects = document->markers()->renderedRectsForMarkers(DocumentMarker::TextMatch);
    62466246    unsigned count = rects.size();
    62476247    NSMutableArray *result = [NSMutableArray arrayWithCapacity:count];
  • trunk/WebKit/win/ChangeLog

    r65618 r65787  
     12010-08-22  Daniel Bates  <dbates@rim.com>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Encapsulate document marker management into DocumentMarkerController
     6        https://bugs.webkit.org/show_bug.cgi?id=44383
     7
     8        Modify call sites in the Apple Windows port to use DocumentMarkerController.
     9
     10        No functionality was changed, so no new tests.
     11
     12        * WebFrame.cpp:
     13        (WebFrame::unmarkAllMisspellings):
     14        (WebFrame::unmarkAllBadGrammar):
     15        * WebView.cpp:
     16        (WebView::rectsForTextMatches):
     17
    1182010-08-18  Jessie Berlin  <jberlin@apple.com>
    219
  • trunk/WebKit/win/WebFrame.cpp

    r65112 r65787  
    25652565            return;
    25662566
    2567         doc->removeMarkers(DocumentMarker::Spelling);
     2567        doc->markers()->removeMarkers(DocumentMarker::Spelling);
    25682568    }
    25692569}
     
    25772577            return;
    25782578
    2579         doc->removeMarkers(DocumentMarker::Grammar);
     2579        doc->markers()->removeMarkers(DocumentMarker::Grammar);
    25802580    }
    25812581}
  • trunk/WebKit/win/WebView.cpp

    r65618 r65787  
    33633363        if (Document* document = frame->document()) {
    33643364            IntRect visibleRect = frame->view()->visibleContentRect();
    3365             Vector<IntRect> frameRects = document->renderedRectsForMarkers(DocumentMarker::TextMatch);
     3365            Vector<IntRect> frameRects = document->markers()->renderedRectsForMarkers(DocumentMarker::TextMatch);
    33663366            IntPoint frameOffset(-frame->view()->scrollOffset().width(), -frame->view()->scrollOffset().height());
    33673367            frameOffset = frame->view()->convertToContainingWindow(frameOffset);
Note: See TracChangeset for help on using the changeset viewer.