Changeset 116906 in webkit


Ignore:
Timestamp:
May 13, 2012 4:39:53 PM (12 years ago)
Author:
Darin Adler
Message:

RenderView::selectionBounds and RenderView::setSelection use maps with raw pointers that should be OwnPtr
https://bugs.webkit.org/show_bug.cgi?id=86300

Reviewed by Eric Seidel.

  • rendering/RenderView.cpp:

(WebCore::RenderView::selectionBounds): Changed SelectionMap type to use OwnPtr.
Added code to do adoptPtr as needed and removed explicit delete code.
(WebCore::RenderView::setSelection): Changed SelectedBlockMap type to use OwnPtr.
Added code to do adoptPtr as needed and removed explicit delete code.

Location:
trunk/Source/WebCore
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r116905 r116906  
     12012-05-13  Darin Adler  <darin@apple.com>
     2
     3        RenderView::selectionBounds and RenderView::setSelection use maps with raw pointers that should be OwnPtr
     4        https://bugs.webkit.org/show_bug.cgi?id=86300
     5
     6        Reviewed by Eric Seidel.
     7
     8        * rendering/RenderView.cpp:
     9        (WebCore::RenderView::selectionBounds): Changed SelectionMap type to use OwnPtr.
     10        Added code to do adoptPtr as needed and removed explicit delete code.
     11        (WebCore::RenderView::setSelection): Changed SelectedBlockMap type to use OwnPtr.
     12        Added code to do adoptPtr as needed and removed explicit delete code.
     13
    1142012-05-13  Darin Adler  <darin@apple.com>
    215
  • trunk/Source/WebCore/rendering/RenderView.cpp

    r115981 r116906  
    401401    document()->updateStyleIfNeeded();
    402402
    403     typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectionMap;
     403    typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectionMap;
    404404    SelectionMap selectedObjects;
    405405
     
    409409        if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
    410410            // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
    411             selectedObjects.set(os, new RenderSelectionInfo(os, clipToVisibleContent));
     411            selectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, clipToVisibleContent)));
    412412            RenderBlock* cb = os->containingBlock();
    413413            while (cb && !cb->isRenderView()) {
    414                 RenderSelectionInfo* blockInfo = selectedObjects.get(cb);
     414                OwnPtr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).iterator->second;
    415415                if (blockInfo)
    416416                    break;
    417                 selectedObjects.set(cb, new RenderSelectionInfo(cb, clipToVisibleContent));
     417                blockInfo = adoptPtr(new RenderSelectionInfo(cb, clipToVisibleContent));
    418418                cb = cb->containingBlock();
    419419            }
     
    427427    SelectionMap::iterator end = selectedObjects.end();
    428428    for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
    429         RenderSelectionInfo* info = i->second;
     429        RenderSelectionInfo* info = i->second.get();
    430430        // RenderSelectionInfo::rect() is in the coordinates of the repaintContainer, so map to page coordinates.
    431431        LayoutRect currRect = info->rect();
     
    435435        }
    436436        selRect.unite(currRect);
    437         delete info;
    438437    }
    439438    return pixelSnappedIntRect(selRect);
     
    473472
    474473    // Objects each have a single selection rect to examine.
    475     typedef HashMap<RenderObject*, RenderSelectionInfo*> SelectedObjectMap;
     474    typedef HashMap<RenderObject*, OwnPtr<RenderSelectionInfo> > SelectedObjectMap;
    476475    SelectedObjectMap oldSelectedObjects;
    477476    SelectedObjectMap newSelectedObjects;
     
    480479    // In order to get the repaint rect right, we have to examine left, middle, and right rects individually, since otherwise
    481480    // the union of those rects might remain the same even when changes have occurred.
    482     typedef HashMap<RenderBlock*, RenderBlockSelectionInfo*> SelectedBlockMap;
     481    typedef HashMap<RenderBlock*, OwnPtr<RenderBlockSelectionInfo> > SelectedBlockMap;
    483482    SelectedBlockMap oldSelectedBlocks;
    484483    SelectedBlockMap newSelectedBlocks;
     
    489488        if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
    490489            // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
    491             oldSelectedObjects.set(os, new RenderSelectionInfo(os, true));
     490            oldSelectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, true)));
    492491            if (blockRepaintMode == RepaintNewXOROld) {
    493492                RenderBlock* cb = os->containingBlock();
    494493                while (cb && !cb->isRenderView()) {
    495                     RenderBlockSelectionInfo* blockInfo = oldSelectedBlocks.get(cb);
     494                    OwnPtr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).iterator->second;
    496495                    if (blockInfo)
    497496                        break;
    498                     oldSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
     497                    blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
    499498                    cb = cb->containingBlock();
    500499                }
     
    543542    while (o && o != stop) {
    544543        if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
    545             newSelectedObjects.set(o, new RenderSelectionInfo(o, true));
     544            newSelectedObjects.set(o, adoptPtr(new RenderSelectionInfo(o, true)));
    546545            RenderBlock* cb = o->containingBlock();
    547546            while (cb && !cb->isRenderView()) {
    548                 RenderBlockSelectionInfo* blockInfo = newSelectedBlocks.get(cb);
     547                OwnPtr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).iterator->second;
    549548                if (blockInfo)
    550549                    break;
    551                 newSelectedBlocks.set(cb, new RenderBlockSelectionInfo(cb));
     550                blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
    552551                cb = cb->containingBlock();
    553552            }
     
    557556    }
    558557
    559     if (!m_frameView || blockRepaintMode == RepaintNothing) {
    560         // We built the maps, but we aren't going to use them.
    561         // We need to delete the values, otherwise they'll all leak!
    562         deleteAllValues(oldSelectedObjects);
    563         deleteAllValues(newSelectedObjects);
    564         deleteAllValues(oldSelectedBlocks);
    565         deleteAllValues(newSelectedBlocks);
    566         return;
    567     }
     558    if (!m_frameView || blockRepaintMode == RepaintNothing)
     559        return;
    568560
    569561    m_frameView->beginDeferredRepaints();
     
    573565        RenderObject* obj = i->first;
    574566        RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
    575         RenderSelectionInfo* oldInfo = i->second;
     567        RenderSelectionInfo* oldInfo = i->second.get();
    576568        if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
    577569            (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
     
    581573                newInfo->repaint();
    582574                newSelectedObjects.remove(obj);
    583                 delete newInfo;
    584575            }
    585576        }
    586         delete oldInfo;
    587577    }
    588578
    589579    // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
    590580    SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
    591     for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {
    592         RenderSelectionInfo* newInfo = i->second;
    593         newInfo->repaint();
    594         delete newInfo;
    595     }
     581    for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i)
     582        i->second->repaint();
    596583
    597584    // Have any of the old blocks changed?
     
    600587        RenderBlock* block = i->first;
    601588        RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
    602         RenderBlockSelectionInfo* oldInfo = i->second;
     589        RenderBlockSelectionInfo* oldInfo = i->second.get();
    603590        if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
    604591            oldInfo->repaint();
     
    606593                newInfo->repaint();
    607594                newSelectedBlocks.remove(block);
    608                 delete newInfo;
    609595            }
    610596        }
    611         delete oldInfo;
    612597    }
    613598
    614599    // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
    615600    SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
    616     for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {
    617         RenderBlockSelectionInfo* newInfo = i->second;
    618         newInfo->repaint();
    619         delete newInfo;
    620     }
     601    for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i)
     602        i->second->repaint();
    621603
    622604    m_frameView->endDeferredRepaints();
Note: See TracChangeset for help on using the changeset viewer.