#include "core/dom/NodeTraversal.h"
#include "core/dom/Range.h"
#include "core/dom/RenderedDocumentMarker.h"
+#include "core/dom/Text.h"
#include "core/editing/TextIterator.h"
#include "core/rendering/RenderObject.h"
#include <stdio.h>
#endif
-namespace WebCore {
+namespace blink {
+
+MarkerRemoverPredicate::MarkerRemoverPredicate(const Vector<String>& words)
+ : m_words(words)
+{
+}
+
+bool MarkerRemoverPredicate::operator()(const DocumentMarker& documentMarker, const Text& textNode) const
+{
+ unsigned start = documentMarker.startOffset();
+ unsigned length = documentMarker.endOffset() - documentMarker.startOffset();
+
+ String markerText = textNode.data().substring(start, length);
+ return m_words.contains(markerText);
+}
namespace {
{
}
-DocumentMarkerController::~DocumentMarkerController()
-{
-}
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(DocumentMarkerController);
-void DocumentMarkerController::detach()
+void DocumentMarkerController::clear()
{
m_markers.clear();
m_possiblyExistingMarkerTypes = 0;
{
// Use a TextIterator to visit the potentially multiple nodes the range covers.
for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
- RefPtr<Range> textPiece = markedText.range();
- addMarker(textPiece->startContainer(), DocumentMarker(type, textPiece->startOffset(), textPiece->endOffset(), description, hash));
+ addMarker(markedText.startContainer(), DocumentMarker(type, markedText.startOffset(), markedText.endOffset(), description, hash));
}
}
-void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type, const String& description)
+void DocumentMarkerController::addMarker(const Position& start, const Position& end, DocumentMarker::MarkerType type, const String& description, uint32_t hash)
{
// Use a TextIterator to visit the potentially multiple nodes the range covers.
- for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
- RefPtr<Range> textPiece = markedText.range();
- addMarker(textPiece->startContainer(), DocumentMarker(type, textPiece->startOffset(), textPiece->endOffset(), description));
+ for (TextIterator markedText(start, end); !markedText.atEnd(); markedText.advance()) {
+ addMarker(markedText.startContainer(), DocumentMarker(type, markedText.startOffset(), markedText.endOffset(), description, hash));
}
}
-void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type)
-{
- // Use a TextIterator to visit the potentially multiple nodes the range covers.
- for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
- RefPtr<Range> textPiece = markedText.range();
- addMarker(textPiece->startContainer(), DocumentMarker(type, textPiece->startOffset(), textPiece->endOffset()));
- }
-
-}
-
-void DocumentMarkerController::addMarkerToNode(Node* node, unsigned startOffset, unsigned length, DocumentMarker::MarkerType type)
-{
- addMarker(node, DocumentMarker(type, startOffset, startOffset + length));
-}
-
-void DocumentMarkerController::addMarkerToNode(Node* node, unsigned startOffset, unsigned length, DocumentMarker::MarkerType type, PassRefPtr<DocumentMarkerDetails> details)
-{
- addMarker(node, DocumentMarker(type, startOffset, startOffset + length, details));
-}
-
-
void DocumentMarkerController::addTextMatchMarker(const Range* range, bool activeMatch)
{
// Use a TextIterator to visit the potentially multiple nodes the range covers.
for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
- RefPtr<Range> textPiece = markedText.range();
- unsigned startOffset = textPiece->startOffset();
- unsigned endOffset = textPiece->endOffset();
- addMarker(textPiece->startContainer(), DocumentMarker(startOffset, endOffset, activeMatch));
+ unsigned startOffset = markedText.startOffset();
+ unsigned endOffset = markedText.endOffset();
+ addMarker(markedText.startContainer(), DocumentMarker(startOffset, endOffset, activeMatch));
if (endOffset > startOffset) {
// Rendered rects for markers in WebKit are not populated until each time
// the markers are painted. However, we need it to happen sooner, because
// the whole purpose of tickmarks on the scrollbar is to show where
// matches off-screen are (that haven't been painted yet).
- Node* node = textPiece->startContainer();
- Vector<DocumentMarker*> markers = markersFor(node);
+ Node* node = markedText.startContainer();
+ DocumentMarkerVector markers = markersFor(node);
toRenderedDocumentMarker(markers[markers.size() - 1])->setRenderedRect(range->boundingBox());
}
}
}
-void DocumentMarkerController::removeMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
+void DocumentMarkerController::prepareForDestruction()
{
- for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
+ clear();
+}
+
+void DocumentMarkerController::removeMarkers(TextIterator& markedText, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
+{
+ for (; !markedText.atEnd(); markedText.advance()) {
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
- RefPtr<Range> textPiece = markedText.range();
- int startOffset = textPiece->startOffset();
- int endOffset = textPiece->endOffset();
- removeMarkers(textPiece->startContainer(), startOffset, endOffset - startOffset, markerTypes, shouldRemovePartiallyOverlappingMarker);
+ int startOffset = markedText.startOffset();
+ int endOffset = markedText.endOffset();
+ removeMarkers(markedText.startContainer(), startOffset, endOffset - startOffset, markerTypes, shouldRemovePartiallyOverlappingMarker);
}
}
-static bool startsFurther(const DocumentMarker& lhv, const DocumentMarker& rhv)
+void DocumentMarkerController::removeMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
+{
+ TextIterator markedText(range);
+ DocumentMarkerController::removeMarkers(markedText, markerTypes, shouldRemovePartiallyOverlappingMarker);
+}
+
+void DocumentMarkerController::removeMarkers(const Position& start, const Position& end, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
+{
+ TextIterator markedText(start, end);
+ DocumentMarkerController::removeMarkers(markedText, markerTypes, shouldRemovePartiallyOverlappingMarker);
+}
+
+static bool startsFurther(const OwnPtrWillBeMember<RenderedDocumentMarker>& lhv, const DocumentMarker* rhv)
{
- return lhv.startOffset() < rhv.startOffset();
+ return lhv->startOffset() < rhv->startOffset();
}
-static bool startsAfter(const DocumentMarker& marker, size_t startOffset)
+static bool startsAfter(const OwnPtrWillBeMember<RenderedDocumentMarker>& marker, size_t startOffset)
{
- return marker.startOffset() < startOffset;
+ return marker->startOffset() < startOffset;
}
-static bool endsBefore(size_t startOffset, const DocumentMarker& rhv)
+static bool endsBefore(size_t startOffset, const OwnPtrWillBeMember<RenderedDocumentMarker>& rhv)
{
- return startOffset < rhv.endOffset();
+ return startOffset < rhv->endOffset();
}
-static bool compareByStart(const DocumentMarker* lhv, const DocumentMarker* rhv)
+static bool compareByStart(const RawPtrWillBeMember<DocumentMarker>& lhv, const RawPtrWillBeMember<DocumentMarker>& rhv)
{
- return startsFurther(*lhv, *rhv);
+ return lhv->startOffset() < rhv->startOffset();
}
-static bool doesNotOverlap(const DocumentMarker& lhv, const DocumentMarker& rhv)
+static bool doesNotOverlap(const OwnPtrWillBeMember<RenderedDocumentMarker>& lhv, const DocumentMarker* rhv)
{
- return lhv.endOffset() < rhv.startOffset();
+ return lhv->endOffset() < rhv->startOffset();
}
-static bool doesNotInclude(const DocumentMarker& marker, size_t startOffset)
+static bool doesNotInclude(const OwnPtrWillBeMember<RenderedDocumentMarker>& marker, size_t startOffset)
{
- return marker.endOffset() < startOffset;
+ return marker->endOffset() < startOffset;
}
// Markers are stored in order sorted by their start offset.
m_possiblyExistingMarkerTypes.add(newMarker.type());
- OwnPtr<MarkerLists>& markers = m_markers.add(node, nullptr).iterator->value;
+ OwnPtrWillBeMember<MarkerLists>& markers = m_markers.add(node, nullptr).storedValue->value;
if (!markers) {
- markers = adoptPtr(new MarkerLists);
+ markers = adoptPtrWillBeNoop(new MarkerLists);
markers->grow(DocumentMarker::MarkerTypeIndexesCount);
}
DocumentMarker::MarkerTypeIndex markerListIndex = MarkerTypeToMarkerIndex(newMarker.type());
if (!markers->at(markerListIndex)) {
- markers->insert(markerListIndex, adoptPtr(new MarkerList));
+ markers->insert(markerListIndex, adoptPtrWillBeNoop(new MarkerList));
}
- OwnPtr<MarkerList>& list = markers->at(markerListIndex);
- if (list->isEmpty() || list->last().endOffset() < newMarker.startOffset()) {
- list->append(RenderedDocumentMarker(newMarker));
+ OwnPtrWillBeMember<MarkerList>& list = markers->at(markerListIndex);
+ if (list->isEmpty() || list->last()->endOffset() < newMarker.startOffset()) {
+ list->append(RenderedDocumentMarker::create(newMarker));
} else {
- RenderedDocumentMarker toInsert(newMarker);
+ DocumentMarker toInsert(newMarker);
if (toInsert.type() != DocumentMarker::TextMatch) {
mergeOverlapping(list.get(), toInsert);
} else {
- MarkerList::iterator pos = std::lower_bound(list->begin(), list->end(), toInsert, startsFurther);
- list->insert(pos - list->begin(), RenderedDocumentMarker(toInsert));
+ MarkerList::iterator pos = std::lower_bound(list->begin(), list->end(), &toInsert, startsFurther);
+ list->insert(pos - list->begin(), RenderedDocumentMarker::create(toInsert));
}
}
// repaint the affected node
if (node->renderer())
- node->renderer()->repaint();
+ node->renderer()->setShouldDoFullPaintInvalidation(true);
}
void DocumentMarkerController::mergeOverlapping(MarkerList* list, DocumentMarker& toInsert)
{
- MarkerList::iterator firstOverlapping = std::lower_bound(list->begin(), list->end(), toInsert, doesNotOverlap);
+ MarkerList::iterator firstOverlapping = std::lower_bound(list->begin(), list->end(), &toInsert, doesNotOverlap);
size_t index = firstOverlapping - list->begin();
- list->insert(index, RenderedDocumentMarker(toInsert));
+ list->insert(index, RenderedDocumentMarker::create(toInsert));
MarkerList::iterator inserted = list->begin() + index;
firstOverlapping = inserted + 1;
- for (MarkerList::iterator i = firstOverlapping; i != list->end() && i->startOffset() <= inserted->endOffset(); ) {
- inserted->setStartOffset(std::min(inserted->startOffset(), i->startOffset()));
- inserted->setEndOffset(std::max(inserted->endOffset(), i->endOffset()));
+ for (MarkerList::iterator i = firstOverlapping; i != list->end() && (*i)->startOffset() <= (*inserted)->endOffset(); ) {
+ (*inserted)->setStartOffset(std::min((*inserted)->startOffset(), (*i)->startOffset()));
+ (*inserted)->setEndOffset(std::max((*inserted)->endOffset(), (*i)->endOffset()));
list->remove(i - list->begin());
}
}
bool docDirty = false;
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
if (!list)
continue;
unsigned endOffset = startOffset + length - 1;
MarkerList::iterator startPos = std::lower_bound(list->begin(), list->end(), startOffset, doesNotInclude);
for (MarkerList::iterator i = startPos; i != list->end(); ++i) {
- DocumentMarker marker = *i;
+ DocumentMarker* marker = i->get();
// stop if we are now past the specified range
- if (marker.startOffset() > endOffset)
+ if (marker->startOffset() > endOffset)
break;
// pin the marker to the specified range and apply the shift delta
docDirty = true;
- if (marker.startOffset() < startOffset)
- marker.setStartOffset(startOffset);
- if (marker.endOffset() > endOffset)
- marker.setEndOffset(endOffset);
- marker.shiftOffsets(delta);
+ if (marker->startOffset() < startOffset)
+ marker->setStartOffset(startOffset);
+ if (marker->endOffset() > endOffset)
+ marker->setEndOffset(endOffset);
+ marker->shiftOffsets(delta);
- addMarker(dstNode, marker);
+ addMarker(dstNode, *marker);
}
}
// repaint the affected node
if (docDirty && dstNode->renderer())
- dstNode->renderer()->repaint();
+ dstNode->renderer()->setShouldDoFullPaintInvalidation(true);
}
void DocumentMarkerController::removeMarkers(Node* node, unsigned startOffset, int length, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
bool docDirty = false;
size_t emptyListsCount = 0;
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
if (!list || list->isEmpty()) {
if (list.get() && list->isEmpty())
list.clear();
++emptyListsCount;
continue;
}
- if (!markerTypes.contains(list->begin()->type()))
+ if (!markerTypes.contains((*list->begin())->type()))
continue;
unsigned endOffset = startOffset + length;
MarkerList::iterator startPos = std::upper_bound(list->begin(), list->end(), startOffset, endsBefore);
for (MarkerList::iterator i = startPos; i != list->end(); ) {
- DocumentMarker marker = *i;
+ DocumentMarker marker(*i->get());
// markers are returned in order, so stop if we are now past the specified range
if (marker.startOffset() >= endOffset)
DocumentMarker newLeft = marker;
newLeft.setEndOffset(startOffset);
size_t insertIndex = i - list->begin();
- list->insert(insertIndex , RenderedDocumentMarker(newLeft));
+ list->insert(insertIndex, RenderedDocumentMarker::create(newLeft));
// Move to the marker after the inserted one.
i = list->begin() + insertIndex + 1;
}
DocumentMarker newRight = marker;
newRight.setStartOffset(endOffset);
size_t insertIndex = i - list->begin();
- list->insert(insertIndex, RenderedDocumentMarker(newRight));
+ list->insert(insertIndex, RenderedDocumentMarker::create(newRight));
// Move to the marker after the inserted one.
i = list->begin() + insertIndex + 1;
}
// repaint the affected node
if (docDirty && node->renderer())
- node->renderer()->repaint();
+ node->renderer()->setShouldDoFullPaintInvalidation(true);
}
DocumentMarker* DocumentMarkerController::markerContainingPoint(const LayoutPoint& point, DocumentMarker::MarkerType markerType)
for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
// inner loop; process each marker in this node
MarkerLists* markers = nodeIterator->value.get();
- OwnPtr<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(markerType)];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(markerType)];
unsigned markerCount = list.get() ? list->size() : 0;
for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
- RenderedDocumentMarker& marker = list->at(markerIndex);
-
- if (marker.contains(point))
- return ▮
+ RenderedDocumentMarker* marker = list->at(markerIndex).get();
+ if (marker->contains(point))
+ return marker;
}
}
return 0;
}
-Vector<DocumentMarker*> DocumentMarkerController::markersFor(Node* node, DocumentMarker::MarkerTypes markerTypes)
+DocumentMarkerVector DocumentMarkerController::markersFor(Node* node, DocumentMarker::MarkerTypes markerTypes)
{
- Vector<DocumentMarker*> result;
+ DocumentMarkerVector result;
MarkerLists* markers = m_markers.get(node);
if (!markers)
return result;
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
- if (!list || list->isEmpty() || !markerTypes.contains(list->begin()->type()))
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
+ if (!list || list->isEmpty() || !markerTypes.contains((*list->begin())->type()))
continue;
for (size_t i = 0; i < list->size(); ++i)
- result.append(&(list->at(i)));
+ result.append(list->at(i).get());
}
std::sort(result.begin(), result.end(), compareByStart);
return result;
}
-Vector<DocumentMarker*> DocumentMarkerController::markers()
+DocumentMarkerVector DocumentMarkerController::markers()
{
- Vector<DocumentMarker*> result;
+ DocumentMarkerVector result;
for (MarkerMap::iterator i = m_markers.begin(); i != m_markers.end(); ++i) {
MarkerLists* markers = i->value.get();
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
for (size_t j = 0; list.get() && j < list->size(); ++j)
- result.append(&(list->at(j)));
+ result.append(list->at(j).get());
}
}
std::sort(result.begin(), result.end(), compareByStart);
return result;
}
-Vector<DocumentMarker*> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
+DocumentMarkerVector DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
- return Vector<DocumentMarker*>();
+ return DocumentMarkerVector();
- Vector<DocumentMarker*> foundMarkers;
+ DocumentMarkerVector foundMarkers;
Node* startContainer = range->startContainer();
ASSERT(startContainer);
ASSERT(endContainer);
Node* pastLastNode = range->pastLastNode();
- for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
- Vector<DocumentMarker*> markers = markersFor(node);
- Vector<DocumentMarker*>::const_iterator end = markers.end();
- for (Vector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
+ for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
+ DocumentMarkerVector markers = markersFor(node);
+ DocumentMarkerVector::const_iterator end = markers.end();
+ for (DocumentMarkerVector::const_iterator it = markers.begin(); it != end; ++it) {
DocumentMarker* marker = *it;
if (!markerTypes.contains(marker->type()))
continue;
// inner loop; process each marker in this node
MarkerLists* markers = nodeIterator->value.get();
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
- if (!list || list->isEmpty() || list->begin()->type() != markerType)
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
+ if (!list || list->isEmpty() || (*list->begin())->type() != markerType)
continue;
for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex) {
- const RenderedDocumentMarker& marker = list->at(markerIndex);
-
- if (!marker.isRendered())
+ RenderedDocumentMarker* marker = list->at(markerIndex).get();
+ if (!marker->isRendered())
continue;
-
- result.append(marker.renderedRect());
+ result.append(marker->renderedRect());
}
}
}
return result;
}
+void DocumentMarkerController::trace(Visitor* visitor)
+{
+#if ENABLE(OILPAN)
+ visitor->trace(m_markers);
+#endif
+}
+
void DocumentMarkerController::removeMarkers(Node* node, DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
removeMarkersFromList(iterator, markerTypes);
}
+void DocumentMarkerController::removeMarkers(const MarkerRemoverPredicate& shouldRemoveMarker)
+{
+ for (MarkerMap::iterator i = m_markers.begin(); i != m_markers.end(); ++i) {
+ MarkerLists* markers = i->value.get();
+ for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
+
+ WillBeHeapVector<RawPtrWillBeMember<RenderedDocumentMarker> > markersToBeRemoved;
+ for (size_t j = 0; list.get() && j < list->size(); ++j) {
+ if (i->key->isTextNode() && shouldRemoveMarker(*list->at(j).get(), static_cast<const Text&>(*i->key)))
+ markersToBeRemoved.append(list->at(j).get());
+ }
+
+ for (size_t j = 0; j < markersToBeRemoved.size(); ++j)
+ list->remove(list->find(markersToBeRemoved[j].get()));
+ }
+ }
+}
+
void DocumentMarkerController::removeMarkers(DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
- Vector<RefPtr<Node> > nodesWithMarkers;
+ Vector<const Node*> nodesWithMarkers;
copyKeysToVector(m_markers, nodesWithMarkers);
unsigned size = nodesWithMarkers.size();
for (unsigned i = 0; i < size; ++i) {
MarkerLists* markers = iterator->value.get();
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
if (!list || list->isEmpty()) {
if (list.get() && list->isEmpty())
list.clear();
++emptyListsCount;
continue;
}
- if (markerTypes.contains(list->begin()->type())) {
+ if (markerTypes.contains((*list->begin())->type())) {
list->clear();
list.clear();
++emptyListsCount;
if (needsRepainting) {
if (RenderObject* renderer = iterator->key->renderer())
- renderer->repaint();
+ renderer->setShouldDoFullPaintInvalidation(true);
}
if (nodeCanBeRemoved) {
// outer loop: process each markered node in the document
MarkerMap::iterator end = m_markers.end();
for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
- Node* node = i->key.get();
+ const Node* node = i->key;
// inner loop: process each marker in the current node
MarkerLists* markers = i->value.get();
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
- if (!list || list->isEmpty() || !markerTypes.contains(list->begin()->type()))
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
+ if (!list || list->isEmpty() || !markerTypes.contains((*list->begin())->type()))
continue;
// cause the node to be redrawn
if (RenderObject* renderer = node->renderer()) {
- renderer->repaint();
+ renderer->setShouldDoFullPaintInvalidation(true);
break;
}
}
// inner loop: process each rect in the current node
MarkerLists* markers = i->value.get();
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
for (size_t markerIndex = 0; list.get() && markerIndex < list->size(); ++markerIndex)
- list->at(markerIndex).invalidate(r);
+ list->at(markerIndex)->invalidate(r);
}
}
}
bool docDirty = false;
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
if (!list)
continue;
MarkerList::iterator startPos = std::lower_bound(list->begin(), list->end(), startOffset, startsAfter);
for (MarkerList::iterator marker = startPos; marker != list->end(); ++marker) {
- ASSERT((int)marker->startOffset() + delta >= 0);
- marker->shiftOffsets(delta);
+#if ENABLE(ASSERT)
+ int startOffset = (*marker)->startOffset();
+ ASSERT(startOffset + delta >= 0);
+#endif
+ (*marker)->shiftOffsets(delta);
docDirty = true;
// Marker moved, so previously-computed rendered rectangle is now invalid
- marker->invalidate();
+ (*marker)->invalidate();
}
}
// repaint the affected node
if (docDirty && node->renderer())
- node->renderer()->repaint();
+ node->renderer()->setShouldDoFullPaintInvalidation(true);
}
void DocumentMarkerController::setMarkersActive(Range* range, bool active)
Node* pastLastNode = range->pastLastNode();
- for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
+ for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
int startOffset = node == startContainer ? range->startOffset() : 0;
int endOffset = node == endContainer ? range->endOffset() : INT_MAX;
setMarkersActive(node, startOffset, endOffset, active);
return;
bool docDirty = false;
- OwnPtr<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(DocumentMarker::TextMatch)];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(DocumentMarker::TextMatch)];
if (!list)
return;
MarkerList::iterator startPos = std::upper_bound(list->begin(), list->end(), startOffset, endsBefore);
for (MarkerList::iterator marker = startPos; marker != list->end(); ++marker) {
// Markers are returned in order, so stop if we are now past the specified range.
- if (marker->startOffset() >= endOffset)
+ if ((*marker)->startOffset() >= endOffset)
break;
- marker->setActiveMatch(active);
+ (*marker)->setActiveMatch(active);
docDirty = true;
}
// repaint the affected node
if (docDirty && node->renderer())
- node->renderer()->repaint();
+ node->renderer()->setShouldDoFullPaintInvalidation(true);
}
bool DocumentMarkerController::hasMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes)
ASSERT(endContainer);
Node* pastLastNode = range->pastLastNode();
- for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
- Vector<DocumentMarker*> markers = markersFor(node);
- Vector<DocumentMarker*>::const_iterator end = markers.end();
- for (Vector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
+ for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
+ DocumentMarkerVector markers = markersFor(node);
+ DocumentMarkerVector::const_iterator end = markers.end();
+ for (DocumentMarkerVector::const_iterator it = markers.begin(); it != end; ++it) {
DocumentMarker* marker = *it;
if (!markerTypes.contains(marker->type()))
continue;
fprintf(stderr, "%d nodes have markers:\n", m_markers.size());
MarkerMap::const_iterator end = m_markers.end();
for (MarkerMap::const_iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
- Node* node = nodeIterator->key.get();
+ const Node* node = nodeIterator->key;
fprintf(stderr, "%p", node);
MarkerLists* markers = m_markers.get(node);
for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
- OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+ OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
for (unsigned markerIndex = 0; list.get() && markerIndex < list->size(); ++markerIndex) {
- const DocumentMarker& marker = list->at(markerIndex);
- fprintf(stderr, " %d:[%d:%d](%d)", marker.type(), marker.startOffset(), marker.endOffset(), marker.activeMatch());
+ DocumentMarker* marker = list->at(markerIndex).get();
+ fprintf(stderr, " %d:[%d:%d](%d)", marker->type(), marker->startOffset(), marker->endOffset(), marker->activeMatch());
}
}
}
#endif
-} // namespace WebCore
+} // namespace blink
#ifndef NDEBUG
-void showDocumentMarkers(const WebCore::DocumentMarkerController* controller)
+void showDocumentMarkers(const blink::DocumentMarkerController* controller)
{
if (controller)
controller->showMarkers();
projects / platform / framework / web / crosswalk.git / blobdiff