Attachment #198790 for bug #113479

View Details Raw Unified Return to Bug 113479

| Differences between



#include "RenderLayer.h"
#include "RenderLayerBacking.h"
#include "RenderPart.h"
#include "RenderSelectionInfo.h"
#include "RenderScrollbar.h"
#include "RenderScrollbarPart.h"
#include "RenderTheme.h"

    InspectorInstrumentation::willPaint(m_frame.get());

    Document* document = m_frame->document();
    RenderSelectionOffsetCaches caches;

#ifndef NDEBUG
    bool fillWithRed;



#include "RenderMarquee.h"
#include "RenderReplica.h"
#include "RenderSVGResourceClipper.h"
#include "REnderSelectionInfo.h"
#include "RenderScrollbar.h"
#include "RenderScrollbarPart.h"
#include "RenderTheme.h"

    LayoutPoint offsetFromRoot;
    convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);

    RenderSelectionOffsetCaches caches;
    IntRect rootRelativeBounds;
    bool rootRelativeBoundsComputed = false;




public:
    RenderBlockSelectionInfo(RenderBlock* b)
        : RenderSelectionInfoBase(b)
        , m_rects(b->canUpdateSelectionOnRootLineBoxes() ? b->selectionGapRectsForRepaint(m_repaintContainer) : GapRects())
    { 
    }


    GapRects m_rects; // relative to repaint container
};

class RenderSelectionOffsetCaches {
public:
    struct Caches : public RefCounted<Caches> {
        HashMap<RenderBlock*, LayoutUnit> m_leftCache;
        HashMap<RenderBlock*, LayoutUnit> m_rightCache;
    };

    RenderSelectionOffsetCaches()
    {
        if (s_caches)
            m_caches = s_caches;
        else {
            m_caches = adoptRef(new Caches);
            s_caches = m_caches.get();
        }
    }

    ~RenderSelectionOffsetCaches()
    {
        ASSERT(s_caches);
        if (m_caches->hasOneRef())
            s_caches = 0;
        m_caches.clear();
    }

    static void cacheLeftOffset(RenderBlock* block, const LayoutUnit& offset)
    {
        ASSERT(s_caches);
        s_caches->m_leftCache.add(block, offset);
    }

    static bool getCachedLeftOffset(RenderBlock* block, LayoutUnit& offset)
    {
        ASSERT(s_caches);
        HashMap<RenderBlock*, LayoutUnit>::iterator it = s_caches->m_leftCache.find(block);
        if (it == s_caches->m_leftCache.end())
            return false;
        offset = it->value;
        return true;
    }

    static void cacheRightOffset(RenderBlock* block, const LayoutUnit& offset)
    {
        ASSERT(s_caches);
        s_caches->m_rightCache.add(block, offset);
    }

    static bool getCachedRightOffset(RenderBlock* block, LayoutUnit& offset)
    {
        ASSERT(s_caches);
        HashMap<RenderBlock*, LayoutUnit>::iterator it = s_caches->m_rightCache.find(block);
        if (it == s_caches->m_rightCache.end())
            return false;
        offset = it->value;
        return true;
    }

private:
    RefPtr<Caches> m_caches;

    static Caches* s_caches;
};

} // namespace WebCore






    typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectionMap;
    SelectionMap selectedObjects;
    RenderSelectionOffsetCaches caches;
    
    RenderObject* os = m_selectionStart;
    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
    while (os && os != stop) {

    document()->updateStyleIfNeeded();

    HashSet<RenderBlock*> processedBlocks;
    RenderSelectionOffsetCaches caches;

    RenderObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
    for (RenderObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {

    typedef HashMap<RenderBlock*, OwnPtr<RenderBlockSelectionInfo> > SelectedBlockMap;
    SelectedBlockMap oldSelectedBlocks;
    SelectedBlockMap newSelectedBlocks;
    RenderSelectionOffsetCaches caches;

    RenderObject* os = m_selectionStart;
    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);

Lines 55-60 Source/WebCore/rendering/RenderBlock.cpp_sec1
- Source/WebCore/rendering/RenderBlock.cpp -6 / +39 lines
55	#include "RenderNamedFlowThread.h"	55	#include "RenderNamedFlowThread.h"
56	#include "RenderRegion.h"	56	#include "RenderRegion.h"
57	#include "RenderReplica.h"	57	#include "RenderReplica.h"
		58	#include "RenderSelectionInfo.h"
58	#include "RenderTableCell.h"	59	#include "RenderTableCell.h"
59	#include "RenderTextFragment.h"	60	#include "RenderTextFragment.h"
60	#include "RenderTheme.h"	61	#include "RenderTheme.h"
Lines 3678-3691 Source/WebCore/rendering/RenderBlock.cpp_sec2
3678	(state == RenderObject::SelectionEnd && !ltr);	3679	(state == RenderObject::SelectionEnd && !ltr);
3679	}	3680	}
3680		3681
		3682	RenderSelectionOffsetCaches::Caches* RenderSelectionOffsetCaches::s_caches = 0;
		3683
3681	LayoutUnit RenderBlock::logicalLeftSelectionOffset(RenderBlock* rootBlock, LayoutUnit position)	3684	LayoutUnit RenderBlock::logicalLeftSelectionOffset(RenderBlock* rootBlock, LayoutUnit position)
3682	{	3685	{
3683	LayoutUnit logicalLeft = logicalLeftOffsetForLine(position, false);	3686	LayoutUnit logicalLeft = logicalLeftOffsetForLine(position, false);
3684	if (logicalLeft == logicalLeftOffsetForContent()) {	3687	if (logicalLeft == logicalLeftOffsetForContent()) {
3685	if (rootBlock != this)	3688	if (rootBlock != this) {
3686	// The border can potentially be further extended by our containingBlock().	3689	// The border can potentially be further extended by our containingBlock().
3687	return containingBlock()->logicalLeftSelectionOffset(rootBlock, position + logicalTop());	3690
3688	return logicalLeft;	3691	// FIXME: We shouldn't have to walk up the tree here.
		3692	RenderBlock* cb = this;
		3693	bool canUseCachedOffset = true;
		3694	do {
		3695	cb = cb->containingBlock();
		3696	ASSERT(cb);
		3697	canUseCachedOffset &= !(cb->m_floatingObjects \|\| flowThreadContainingBlock());
		3698	} while (cb != rootBlock);
		3699
		3700	if (canUseCachedOffset)
		3701	canUseCachedOffset = RenderSelectionOffsetCaches::getCachedLeftOffset(this, logicalLeft);
		3702
		3703	if (!canUseCachedOffset)
		3704	logicalLeft = containingBlock()->logicalLeftSelectionOffset(rootBlock, position + logicalTop());
		3705	}
3689	} else {	3706	} else {
3690	RenderBlock* cb = this;	3707	RenderBlock* cb = this;
3691	while (cb != rootBlock) {	3708	while (cb != rootBlock) {
Lines 3693-3698 Source/WebCore/rendering/RenderBlock.cpp_sec3
3693	cb = cb->containingBlock();	3710	cb = cb->containingBlock();
3694	}	3711	}
3695	}	3712	}
		3713	RenderSelectionOffsetCaches::cacheLeftOffset(this, logicalLeft);
3696	return logicalLeft;	3714	return logicalLeft;
3697	}	3715	}
3698		3716
Lines 3700-3709 Source/WebCore/rendering/RenderBlock.cpp_sec4
3700	{	3718	{
3701	LayoutUnit logicalRight = logicalRightOffsetForLine(position, false);	3719	LayoutUnit logicalRight = logicalRightOffsetForLine(position, false);
3702	if (logicalRight == logicalRightOffsetForContent()) {	3720	if (logicalRight == logicalRightOffsetForContent()) {
3703	if (rootBlock != this)	3721	if (rootBlock != this) {
3704	// The border can potentially be further extended by our containingBlock().	3722	// The border can potentially be further extended by our containingBlock().
3705	return containingBlock()->logicalRightSelectionOffset(rootBlock, position + logicalTop());	3723
3706	return logicalRight;	3724	// FIXME: We shouldn't have to walk up the tree here.
		3725	RenderBlock* cb = this;
		3726	bool canUseCachedOffset = true;
		3727	do {
		3728	cb = cb->containingBlock();
		3729	ASSERT(cb);
		3730	canUseCachedOffset &= !(cb->m_floatingObjects \|\| flowThreadContainingBlock());
		3731	} while (cb != rootBlock);
		3732
		3733	if (canUseCachedOffset)
		3734	canUseCachedOffset = RenderSelectionOffsetCaches::getCachedRightOffset(this, logicalRight);
		3735
		3736	if (!canUseCachedOffset)
		3737	logicalRight = containingBlock()->logicalRightSelectionOffset(rootBlock, position + logicalTop());
		3738	}
3707	} else {	3739	} else {
3708	RenderBlock* cb = this;	3740	RenderBlock* cb = this;
3709	while (cb != rootBlock) {	3741	while (cb != rootBlock) {
Lines 3711-3716 Source/WebCore/rendering/RenderBlock.cpp_sec5
3711	cb = cb->containingBlock();	3743	cb = cb->containingBlock();
3712	}	3744	}
3713	}	3745	}
		3746	RenderSelectionOffsetCaches::cacheRightOffset(this, logicalRight);
3714	return logicalRight;	3747	return logicalRight;
3715	}	3748	}
3716		3749

Return to Bug 113479

Lines 83-89 Source/WebCore/rendering/RenderSelectionInfo.h_sec1
- Source/WebCore/rendering/RenderSelectionInfo.h -1 / +64 lines
83	public:	83	public:
84	RenderBlockSelectionInfo(RenderBlock* b)	84	RenderBlockSelectionInfo(RenderBlock* b)
85	: RenderSelectionInfoBase(b)	85	: RenderSelectionInfoBase(b)
86	, m_rects(b->canUpdateSelectionOnRootLineBoxes() ? block()->selectionGapRectsForRepaint(m_repaintContainer) : GapRects())	86	, m_rects(b->canUpdateSelectionOnRootLineBoxes() ? b->selectionGapRectsForRepaint(m_repaintContainer) : GapRects())
87	{	87	{
88	}	88	}
89		89
Lines 99-104 Source/WebCore/rendering/RenderSelectionInfo.h_sec2
99	GapRects m_rects; // relative to repaint container	99	GapRects m_rects; // relative to repaint container
100	};	100	};
101		101
		102	class RenderSelectionOffsetCaches {
		103	public:
		104	struct Caches : public RefCounted<Caches> {
		105	HashMap<RenderBlock*, LayoutUnit> m_leftCache;
		106	HashMap<RenderBlock*, LayoutUnit> m_rightCache;
		107	};
		108
		109	RenderSelectionOffsetCaches()
		110	{
		111	if (s_caches)
		112	m_caches = s_caches;
		113	else {
		114	m_caches = adoptRef(new Caches);
		115	s_caches = m_caches.get();
		116	}
		117	}
		118
		119	~RenderSelectionOffsetCaches()
		120	{
		121	ASSERT(s_caches);
		122	if (m_caches->hasOneRef())
		123	s_caches = 0;
		124	m_caches.clear();
		125	}
		126
		127	static void cacheLeftOffset(RenderBlock* block, const LayoutUnit& offset)
		128	{
		129	ASSERT(s_caches);
		130	s_caches->m_leftCache.add(block, offset);
		131	}
		132
		133	static bool getCachedLeftOffset(RenderBlock* block, LayoutUnit& offset)
		134	{
		135	ASSERT(s_caches);
		136	HashMap<RenderBlock*, LayoutUnit>::iterator it = s_caches->m_leftCache.find(block);
		137	if (it == s_caches->m_leftCache.end())
		138	return false;
		139	offset = it->value;
		140	return true;
		141	}
		142
		143	static void cacheRightOffset(RenderBlock* block, const LayoutUnit& offset)
		144	{
		145	ASSERT(s_caches);
		146	s_caches->m_rightCache.add(block, offset);
		147	}
		148
		149	static bool getCachedRightOffset(RenderBlock* block, LayoutUnit& offset)
		150	{
		151	ASSERT(s_caches);
		152	HashMap<RenderBlock*, LayoutUnit>::iterator it = s_caches->m_rightCache.find(block);
		153	if (it == s_caches->m_rightCache.end())
		154	return false;
		155	offset = it->value;
		156	return true;
		157	}
		158
		159	private:
		160	RefPtr<Caches> m_caches;
		161
		162	static Caches* s_caches;
		163	};
		164
102	} // namespace WebCore	165	} // namespace WebCore
103		166
104		167

Lines 60-65 Source/WebCore/page/FrameView.cpp_sec1
- Source/WebCore/page/FrameView.cpp +2 lines
60	#include "RenderLayer.h"	60	#include "RenderLayer.h"
61	#include "RenderLayerBacking.h"	61	#include "RenderLayerBacking.h"
62	#include "RenderPart.h"	62	#include "RenderPart.h"
		63	#include "RenderSelectionInfo.h"
63	#include "RenderScrollbar.h"	64	#include "RenderScrollbar.h"
64	#include "RenderScrollbarPart.h"	65	#include "RenderScrollbarPart.h"
65	#include "RenderTheme.h"	66	#include "RenderTheme.h"
Lines 3401-3406 Source/WebCore/page/FrameView.cpp_sec2
3401	InspectorInstrumentation::willPaint(m_frame.get());	3402	InspectorInstrumentation::willPaint(m_frame.get());
3402		3403
3403	Document* document = m_frame->document();	3404	Document* document = m_frame->document();
		3405	RenderSelectionOffsetCaches caches;
3404		3406
3405	#ifndef NDEBUG	3407	#ifndef NDEBUG
3406	bool fillWithRed;	3408	bool fillWithRed;

Lines 86-91 Source/WebCore/rendering/RenderLayer.cpp_sec1
- Source/WebCore/rendering/RenderLayer.cpp +2 lines
86	#include "RenderMarquee.h"	86	#include "RenderMarquee.h"
87	#include "RenderReplica.h"	87	#include "RenderReplica.h"
88	#include "RenderSVGResourceClipper.h"	88	#include "RenderSVGResourceClipper.h"
		89	#include "REnderSelectionInfo.h"
89	#include "RenderScrollbar.h"	90	#include "RenderScrollbar.h"
90	#include "RenderScrollbarPart.h"	91	#include "RenderScrollbarPart.h"
91	#include "RenderTheme.h"	92	#include "RenderTheme.h"
Lines 3686-3691 Source/WebCore/rendering/RenderLayer.cpp_sec2
3686	LayoutPoint offsetFromRoot;	3687	LayoutPoint offsetFromRoot;
3687	convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);	3688	convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
3688		3689
		3690	RenderSelectionOffsetCaches caches;
3689	IntRect rootRelativeBounds;	3691	IntRect rootRelativeBounds;
3690	bool rootRelativeBoundsComputed = false;	3692	bool rootRelativeBoundsComputed = false;
3691		3693

Lines 583-589 Source/WebCore/rendering/RenderView.cpp_sec1
- Source/WebCore/rendering/RenderView.cpp -1 / +4 lines
583		583
584	typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectionMap;	584	typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectionMap;
585	SelectionMap selectedObjects;	585	SelectionMap selectedObjects;
586		586	RenderSelectionOffsetCaches caches;
		587
587	RenderObject* os = m_selectionStart;	588	RenderObject* os = m_selectionStart;
588	RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);	589	RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
589	while (os && os != stop) {	590	while (os && os != stop) {
Lines 624-629 Source/WebCore/rendering/RenderView.cpp_sec2
624	document()->updateStyleIfNeeded();	625	document()->updateStyleIfNeeded();
625		626
626	HashSet<RenderBlock*> processedBlocks;	627	HashSet<RenderBlock*> processedBlocks;
		628	RenderSelectionOffsetCaches caches;
627		629
628	RenderObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);	630	RenderObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
629	for (RenderObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {	631	for (RenderObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {
Lines 690-695 Source/WebCore/rendering/RenderView.cpp_sec3
690	typedef HashMap<RenderBlock*, OwnPtr<RenderBlockSelectionInfo> > SelectedBlockMap;	692	typedef HashMap<RenderBlock*, OwnPtr<RenderBlockSelectionInfo> > SelectedBlockMap;
691	SelectedBlockMap oldSelectedBlocks;	693	SelectedBlockMap oldSelectedBlocks;
692	SelectedBlockMap newSelectedBlocks;	694	SelectedBlockMap newSelectedBlocks;
		695	RenderSelectionOffsetCaches caches;
693		696
694	RenderObject* os = m_selectionStart;	697	RenderObject* os = m_selectionStart;
695	RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);	698	RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);