Changeset 142247 in webkit


Ignore:
Timestamp:
Feb 8, 2013 1:12:52 AM (11 years ago)
Author:
mkwst@chromium.org
Message:

Replace ExceptionCode assertions with ASSERT_NO_EXCEPTION macro.
​https://bugs.webkit.org/show_bug.cgi?id=109044

Reviewed by Darin Adler.

The pattern:

ExceptionCode ec = 0;
methodThatGeneratesException(ec);
ASSERT(!ec);

is more clearly and succinctly written as:

methodThatGeneratesException(ASSERT_NO_EXCEPTION);

This patch replaces the occurances of the former that never touch 'ec'
again with the latter. It does the same for 'ASSERT(ec == 0);' (and, as
a drive-by, replaces 'ASSERT(ec == 0)' with 'ASSERT(!ec)' in places
where it does indeed matter that 'ec' get set properly.

No change in behavior should result from this refactoring.

  • dom/ContainerNode.cpp:

(WebCore::ContainerNode::takeAllChildrenFrom):

  • dom/Document.cpp:

(WebCore::Document::setTitle):

  • dom/MessagePort.cpp:

(WebCore::MessagePort::dispatchMessages):
(WebCore::MessagePort::disentanglePorts):

  • editing/DeleteButtonController.cpp:

(WebCore::enclosingDeletableElement):
(WebCore::DeleteButtonController::createDeletionUI):

Replaced inline ASSERT with ASSERT_NO_EXCEPTION.

(WebCore::DeleteButtonController::show):

Replaced 'ASSERT(ec == 0)' with 'ASSERT(!ec)' to match the style guide.

  • editing/EditorCommand.cpp:

(WebCore::unionDOMRanges):

  • editing/ReplaceNodeWithSpanCommand.cpp:

(WebCore::swapInNodePreservingAttributesAndChildren):

  • editing/ReplaceSelectionCommand.cpp:

(WebCore::ReplacementFragment::ReplacementFragment):
(WebCore::ReplacementFragment::removeNode):
(WebCore::ReplacementFragment::insertNodeBefore):
(WebCore::ReplacementFragment::insertFragmentForTestRendering):
(WebCore::ReplacementFragment::restoreAndRemoveTestRenderingNodesToFragment):
(WebCore::ReplaceSelectionCommand::insertAsListItems):

  • editing/SplitTextNodeCommand.cpp:

(WebCore::SplitTextNodeCommand::doUnapply):

  • editing/TextIterator.cpp:

(WebCore::CharacterIterator::range):
(WebCore::BackwardsCharacterIterator::range):
(WebCore::TextIterator::rangeFromLocationAndLength):
(WebCore::collapsedToBoundary):

  • editing/htmlediting.cpp:

(WebCore::createTabSpanElement):

  • editing/mac/EditorMac.mm:

(WebCore::Editor::fontForSelection):
(WebCore::Editor::fontAttributesForSelectionStart):

  • editing/markup.cpp:

(WebCore::createMarkup):
(WebCore::trimFragment):
(WebCore::createFragmentFromMarkupWithContext):
(WebCore::fillContainerFromString):
(WebCore::createFragmentFromText):
(WebCore::createFragmentFromNodes):

  • html/ColorInputType.cpp:

(WebCore::ColorInputType::createShadowSubtree):

Replaced inline ASSERT with ASSERT_NO_EXCEPTION.

  • html/HTMLOptionsCollection.cpp:

(WebCore::HTMLOptionsCollection::add):

Replaced 'ASSERT(ec == 0)' with 'ASSERT(!ec)' to match the style guide.

  • html/HTMLTextAreaElement.cpp:

(WebCore::HTMLTextAreaElement::updatePlaceholderText):

  • html/HTMLTextFormControlElement.cpp:

(WebCore::HTMLTextFormControlElement::indexForVisiblePosition):
(WebCore::HTMLTextFormControlElement::setInnerTextValue):

  • html/TextFieldInputType.cpp:

(WebCore::TextFieldInputType::updatePlaceholderText):

  • html/ValidationMessage.cpp:

(WebCore::ValidationMessage::buildBubbleTree):

  • html/shadow/MediaControlElementTypes.cpp:

(WebCore::MediaControlVolumeSliderElement::defaultEventHandler):

  • inspector/InspectorPageAgent.cpp:

(WebCore::InspectorPageAgent::getCookies):

  • inspector/InspectorStyleSheet.cpp:

(WebCore::InspectorStyleSheet::addRule):

  • loader/appcache/ApplicationCacheHost.cpp:

(WebCore::ApplicationCacheHost::dispatchDOMEvent):

  • page/DOMSelection.cpp:

(WebCore::DOMSelection::deleteFromDocument):

  • page/DragController.cpp:

(WebCore::prepareClipboardForImageDrag):

  • rendering/RenderTextControl.cpp:

(WebCore::RenderTextControl::visiblePositionForIndex):

Replaced inline ASSERT with ASSERT_NO_EXCEPTION.

Location:
trunk/Source/WebCore
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r142243 r142247  
     12013-02-08  Mike West  <mkwst@chromium.org>
     2
     3        Replace ExceptionCode assertions with ASSERT_NO_EXCEPTION macro.
     4        https://bugs.webkit.org/show_bug.cgi?id=109044
     5
     6        Reviewed by Darin Adler.
     7
     8        The pattern:
     9
     10            ExceptionCode ec = 0;
     11            methodThatGeneratesException(ec);
     12            ASSERT(!ec);
     13
     14        is more clearly and succinctly written as:
     15
     16            methodThatGeneratesException(ASSERT_NO_EXCEPTION);
     17
     18        This patch replaces the occurances of the former that never touch 'ec'
     19        again with the latter. It does the same for 'ASSERT(ec == 0);' (and, as
     20        a drive-by, replaces 'ASSERT(ec == 0)' with 'ASSERT(!ec)' in places
     21        where it does indeed matter that 'ec' get set properly.
     22
     23        No change in behavior should result from this refactoring.
     24
     25        * dom/ContainerNode.cpp:
     26        (WebCore::ContainerNode::takeAllChildrenFrom):
     27        * dom/Document.cpp:
     28        (WebCore::Document::setTitle):
     29        * dom/MessagePort.cpp:
     30        (WebCore::MessagePort::dispatchMessages):
     31        (WebCore::MessagePort::disentanglePorts):
     32        * editing/DeleteButtonController.cpp:
     33        (WebCore::enclosingDeletableElement):
     34        (WebCore::DeleteButtonController::createDeletionUI):
     35            Replaced inline ASSERT with ASSERT_NO_EXCEPTION.
     36        (WebCore::DeleteButtonController::show):
     37            Replaced 'ASSERT(ec == 0)' with 'ASSERT(!ec)' to match the style guide.
     38        * editing/EditorCommand.cpp:
     39        (WebCore::unionDOMRanges):
     40        * editing/ReplaceNodeWithSpanCommand.cpp:
     41        (WebCore::swapInNodePreservingAttributesAndChildren):
     42        * editing/ReplaceSelectionCommand.cpp:
     43        (WebCore::ReplacementFragment::ReplacementFragment):
     44        (WebCore::ReplacementFragment::removeNode):
     45        (WebCore::ReplacementFragment::insertNodeBefore):
     46        (WebCore::ReplacementFragment::insertFragmentForTestRendering):
     47        (WebCore::ReplacementFragment::restoreAndRemoveTestRenderingNodesToFragment):
     48        (WebCore::ReplaceSelectionCommand::insertAsListItems):
     49        * editing/SplitTextNodeCommand.cpp:
     50        (WebCore::SplitTextNodeCommand::doUnapply):
     51        * editing/TextIterator.cpp:
     52        (WebCore::CharacterIterator::range):
     53        (WebCore::BackwardsCharacterIterator::range):
     54        (WebCore::TextIterator::rangeFromLocationAndLength):
     55        (WebCore::collapsedToBoundary):
     56        * editing/htmlediting.cpp:
     57        (WebCore::createTabSpanElement):
     58        * editing/mac/EditorMac.mm:
     59        (WebCore::Editor::fontForSelection):
     60        (WebCore::Editor::fontAttributesForSelectionStart):
     61        * editing/markup.cpp:
     62        (WebCore::createMarkup):
     63        (WebCore::trimFragment):
     64        (WebCore::createFragmentFromMarkupWithContext):
     65        (WebCore::fillContainerFromString):
     66        (WebCore::createFragmentFromText):
     67        (WebCore::createFragmentFromNodes):
     68        * html/ColorInputType.cpp:
     69        (WebCore::ColorInputType::createShadowSubtree):
     70            Replaced inline ASSERT with ASSERT_NO_EXCEPTION.
     71        * html/HTMLOptionsCollection.cpp:
     72        (WebCore::HTMLOptionsCollection::add):
     73            Replaced 'ASSERT(ec == 0)' with 'ASSERT(!ec)' to match the style guide.
     74        * html/HTMLTextAreaElement.cpp:
     75        (WebCore::HTMLTextAreaElement::updatePlaceholderText):
     76        * html/HTMLTextFormControlElement.cpp:
     77        (WebCore::HTMLTextFormControlElement::indexForVisiblePosition):
     78        (WebCore::HTMLTextFormControlElement::setInnerTextValue):
     79        * html/TextFieldInputType.cpp:
     80        (WebCore::TextFieldInputType::updatePlaceholderText):
     81        * html/ValidationMessage.cpp:
     82        (WebCore::ValidationMessage::buildBubbleTree):
     83        * html/shadow/MediaControlElementTypes.cpp:
     84        (WebCore::MediaControlVolumeSliderElement::defaultEventHandler):
     85        * inspector/InspectorPageAgent.cpp:
     86        (WebCore::InspectorPageAgent::getCookies):
     87        * inspector/InspectorStyleSheet.cpp:
     88        (WebCore::InspectorStyleSheet::addRule):
     89        * loader/appcache/ApplicationCacheHost.cpp:
     90        (WebCore::ApplicationCacheHost::dispatchDOMEvent):
     91        * page/DOMSelection.cpp:
     92        (WebCore::DOMSelection::deleteFromDocument):
     93        * page/DragController.cpp:
     94        (WebCore::prepareClipboardForImageDrag):
     95        * rendering/RenderTextControl.cpp:
     96        (WebCore::RenderTextControl::visiblePositionForIndex):
     97            Replaced inline ASSERT with ASSERT_NO_EXCEPTION.
     98
    1992013-02-08  Alexei Filippov  <alph@chromium.org>
    2100

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

    r142204 r142247  
    119119
    120120    for (unsigned i = 0; i < children.size(); ++i) {
    121         ExceptionCode ec = 0;
    122121        if (children[i]->attached())
    123122            children[i]->detach();
    124123        // FIXME: We need a no mutation event version of adoptNode.
    125         RefPtr<Node> child = document()->adoptNode(children[i].release(), ec);
    126         ASSERT(!ec);
     124        RefPtr<Node> child = document()->adoptNode(children[i].release(), ASSERT_NO_EXCEPTION);
    127125        parserAppendChild(child.get());
    128126        // FIXME: Together with adoptNode above, the tree scope might get updated recursively twice

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

    r142234 r142247  
    15271527        if (HTMLElement* headElement = head()) {
    15281528            m_titleElement = createElement(titleTag, false);
    1529             ExceptionCode ec = 0;
    1530             headElement->appendChild(m_titleElement, ec);
    1531             ASSERT(!ec);
     1529            headElement->appendChild(m_titleElement, ASSERT_NO_EXCEPTION);
    15321530        }
    15331531    }

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

    r142126 r142247  
    187187        RefPtr<Event> evt = MessageEvent::create(ports.release(), eventData->message());
    188188
    189         ExceptionCode ec = 0;
    190         dispatchEvent(evt.release(), ec);
    191         ASSERT(!ec);
     189        dispatchEvent(evt.release(), ASSERT_NO_EXCEPTION);
    192190    }
    193191}
    … …  
    230228    OwnPtr<MessagePortChannelArray> portArray = adoptPtr(new MessagePortChannelArray(ports->size()));
    231229    for (unsigned int i = 0 ; i < ports->size() ; ++i) {
    232         OwnPtr<MessagePortChannel> channel = (*ports)[i]->disentangle(ec);
    233         ASSERT(!ec); // Can't generate exception here if passed above checks.
     230        OwnPtr<MessagePortChannel> channel = (*ports)[i]->disentangle(ASSERT_NO_EXCEPTION); // Can't generate exception here if passed above checks.
    234231        (*portArray)[i] = channel.release();
    235232    }

  • trunk/Source/WebCore/editing/DeleteButtonController.cpp

    r142126 r142247  
    156156        return 0;
    157157
    158     ExceptionCode ec = 0;
    159     Node* container = range->commonAncestorContainer(ec);
     158    Node* container = range->commonAncestorContainer(ASSERT_NO_EXCEPTION);
    160159    ASSERT(container);
    161     ASSERT(ec == 0);
    162160
    163161    // The enclosingNodeOfType function only works on nodes that are editable
    … …  
    235233    ExceptionCode ec = 0;
    236234    container->appendChild(outline.get(), ec);
    237     ASSERT(ec == 0);
     235    ASSERT(!ec);
    238236    if (ec)
    239237        return;
    … …  
    267265
    268266    container->appendChild(button.get(), ec);
    269     ASSERT(ec == 0);
     267    ASSERT(!ec);
    270268    if (ec)
    271269        return;
    … …  
    301299    ExceptionCode ec = 0;
    302300    m_target->appendChild(m_containerElement.get(), ec);
    303     ASSERT(ec == 0);
     301    ASSERT(!ec);
    304302    if (ec) {
    305303        hide();

  • trunk/Source/WebCore/editing/EditorCommand.cpp

    r142126 r142247  
    267267static RefPtr<Range> unionDOMRanges(Range* a, Range* b)
    268268{
    269     ExceptionCode ec = 0;
    270     Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ec) <= 0 ? a : b;
    271     ASSERT(!ec);
    272     Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ec) <= 0 ? b : a;
    273     ASSERT(!ec);
     269    Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ASSERT_NO_EXCEPTION) <= 0 ? a : b;
     270    Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ASSERT_NO_EXCEPTION) <= 0 ? b : a;
    274271
    275272    return Range::create(a->ownerDocument(), start->startContainer(), start->startOffset(), end->endContainer(), end->endOffset());

  • trunk/Source/WebCore/editing/ReplaceNodeWithSpanCommand.cpp

    r142126 r142247  
    5252{
    5353    ASSERT(nodeToReplace->inDocument());
    54     ExceptionCode ec = 0;
    5554    RefPtr<ContainerNode> parentNode = nodeToReplace->parentNode();
    56     parentNode->insertBefore(newNode, nodeToReplace, ec);
    57     ASSERT(!ec);
     55    parentNode->insertBefore(newNode, nodeToReplace, ASSERT_NO_EXCEPTION);
    5856
    5957    NodeVector children;
    6058    getChildNodes(nodeToReplace, children);
    61     for (size_t i = 0; i < children.size(); ++i) {
    62         newNode->appendChild(children[i], ec);
    63         ASSERT(!ec);
    64     }
     59    for (size_t i = 0; i < children.size(); ++i)
     60        newNode->appendChild(children[i], ASSERT_NO_EXCEPTION);
    6561
    6662    // FIXME: Fix this to send the proper MutationRecords when MutationObservers are present.
    6763    newNode->cloneDataFromElement(*nodeToReplace);
    6864
    69     parentNode->removeChild(nodeToReplace, ec);
    70     ASSERT(!ec);
     65    parentNode->removeChild(nodeToReplace, ASSERT_NO_EXCEPTION);
    7166}
    7267

  • trunk/Source/WebCore/editing/ReplaceSelectionCommand.cpp

    r142126 r142247  
    182182    // Give the root a chance to change the text.
    183183    RefPtr<BeforeTextInsertedEvent> evt = BeforeTextInsertedEvent::create(text);
    184     ExceptionCode ec = 0;
    185     editableRoot->dispatchEvent(evt, ec);
    186     ASSERT(ec == 0);
     184    editableRoot->dispatchEvent(evt, ASSERT_NO_EXCEPTION);
    187185    if (text != evt->text() || !editableRoot->rendererIsRichlyEditable()) {
    188186        restoreAndRemoveTestRenderingNodesToFragment(holder.get());
    … …  
    235233        return;
    236234   
    237     ExceptionCode ec = 0;
    238     parent->removeChild(node.get(), ec);
    239     ASSERT(ec == 0);
     235    parent->removeChild(node.get(), ASSERT_NO_EXCEPTION);
    240236}
    241237
    … …  
    249245        return;
    250246       
    251     ExceptionCode ec = 0;
    252     parent->insertBefore(node, refNode, ec);
    253     ASSERT(ec == 0);
     247    parent->insertBefore(node, refNode, ASSERT_NO_EXCEPTION);
    254248}
    255249
    … …  
    257251{
    258252    RefPtr<StyledElement> holder = createDefaultParagraphElement(m_document.get());
    259    
    260     ExceptionCode ec = 0;
    261 
    262     holder->appendChild(m_fragment, ec);
    263     ASSERT(ec == 0);
    264 
    265     rootEditableElement->appendChild(holder.get(), ec);
    266     ASSERT(ec == 0);
    267 
     253
     254    holder->appendChild(m_fragment, ASSERT_NO_EXCEPTION);
     255    rootEditableElement->appendChild(holder.get(), ASSERT_NO_EXCEPTION);
    268256    m_document->updateLayoutIgnorePendingStylesheets();
    269257
    … …  
    276264        return;
    277265   
    278     ExceptionCode ec = 0;
    279266    while (RefPtr<Node> node = holder->firstChild()) {
    280         holder->removeChild(node.get(), ec);
    281         ASSERT(ec == 0);
    282         m_fragment->appendChild(node.get(), ec);
    283         ASSERT(ec == 0);
     267        holder->removeChild(node.get(), ASSERT_NO_EXCEPTION);
     268        m_fragment->appendChild(node.get(), ASSERT_NO_EXCEPTION);
    284269    }
    285270
    … …  
    13191304
    13201305    while (RefPtr<Node> listItem = listElement->firstChild()) {
    1321         ExceptionCode ec = 0;
    1322         listElement->removeChild(listItem.get(), ec);
    1323         ASSERT(!ec);
     1306        listElement->removeChild(listItem.get(), ASSERT_NO_EXCEPTION);
    13241307        if (isStart || isMiddle) {
    13251308            insertNodeBefore(listItem, lastNode);

  • trunk/Source/WebCore/editing/SplitTextNodeCommand.cpp

    r142126 r142247  
    7676    String prefixText = m_text1->data();
    7777
    78     ExceptionCode ec = 0;
    79     m_text2->insertData(0, prefixText, ec);
    80     ASSERT(!ec);
     78    m_text2->insertData(0, prefixText, ASSERT_NO_EXCEPTION);
    8179
    8280    document()->markers()->copyMarkers(m_text1.get(), 0, prefixText.length(), m_text2.get(), 0);
    83     m_text1->remove(ec);
     81    m_text1->remove(ASSERT_NO_EXCEPTION);
    8482}
    8583

  • trunk/Source/WebCore/editing/TextIterator.cpp

    r142126 r142247  
    14191419            ASSERT(n == r->endContainer());
    14201420            int offset = r->startOffset() + m_runOffset;
    1421             ExceptionCode ec = 0;
    1422             r->setStart(n, offset, ec);
    1423             r->setEnd(n, offset + 1, ec);
    1424             ASSERT(!ec);
     1421            r->setStart(n, offset, ASSERT_NO_EXCEPTION);
     1422            r->setEnd(n, offset + 1, ASSERT_NO_EXCEPTION);
    14251423        }
    14261424    }
    … …  
    15271525            ASSERT(n == r->endContainer());
    15281526            int offset = r->endOffset() - m_runOffset;
    1529             ExceptionCode ec = 0;
    1530             r->setStart(n, offset - 1, ec);
    1531             r->setEnd(n, offset, ec);
    1532             ASSERT(!ec);
     1527            r->setStart(n, offset - 1, ASSERT_NO_EXCEPTION);
     1528            r->setEnd(n, offset, ASSERT_NO_EXCEPTION);
    15331529        }
    15341530    }
    … …  
    24412437        textRunRange = it.range();
    24422438       
    2443         ExceptionCode ec = 0;
    2444         resultRange->setStart(textRunRange->startContainer(), 0, ec);
    2445         ASSERT(!ec);
    2446         resultRange->setEnd(textRunRange->startContainer(), 0, ec);
    2447         ASSERT(!ec);
     2439        resultRange->setStart(textRunRange->startContainer(), 0, ASSERT_NO_EXCEPTION);
     2440        resultRange->setEnd(textRunRange->startContainer(), 0, ASSERT_NO_EXCEPTION);
    24482441       
    24492442        return resultRange.release();
    … …  
    24672460                if (!it.atEnd()) {
    24682461                    RefPtr<Range> range = it.range();
    2469                     ExceptionCode ec = 0;
    2470                     textRunRange->setEnd(range->startContainer(), range->startOffset(), ec);
    2471                     ASSERT(!ec);
     2462                    textRunRange->setEnd(range->startContainer(), range->startOffset(), ASSERT_NO_EXCEPTION);
    24722463                } else {
    24732464                    Position runStart = textRunRange->startPosition();
    24742465                    Position runEnd = VisiblePosition(runStart).next().deepEquivalent();
    2475                     if (runEnd.isNotNull()) {
    2476                         ExceptionCode ec = 0;
    2477                         textRunRange->setEnd(runEnd.containerNode(), runEnd.computeOffsetInContainerNode(), ec);
    2478                         ASSERT(!ec);
    2479                     }
     2466                    if (runEnd.isNotNull())
     2467                        textRunRange->setEnd(runEnd.containerNode(), runEnd.computeOffsetInContainerNode(), ASSERT_NO_EXCEPTION);
    24802468                }
    24812469            }
    … …  
    25992587static PassRefPtr<Range> collapsedToBoundary(const Range* range, bool forward)
    26002588{
    2601     ExceptionCode ec = 0;
    2602     RefPtr<Range> result = range->cloneRange(ec);
    2603     ASSERT(!ec);
    2604     result->collapse(!forward, ec);
    2605     ASSERT(!ec);
     2589    RefPtr<Range> result = range->cloneRange(ASSERT_NO_EXCEPTION);
     2590    result->collapse(!forward, ASSERT_NO_EXCEPTION);
    26062591    return result.release();
    26072592}

  • trunk/Source/WebCore/editing/htmlediting.cpp

    r142126 r142247  
    940940        tabTextNode = document->createEditingTextNode("\t");
    941941
    942     ExceptionCode ec = 0;
    943     spanElement->appendChild(tabTextNode.release(), ec);
    944     ASSERT(ec == 0);
     942    spanElement->appendChild(tabTextNode.release(), ASSERT_NO_EXCEPTION);
    945943
    946944    return spanElement.release();

  • trunk/Source/WebCore/editing/mac/EditorMac.mm

    r142126 r142247  
    154154            result = style->font().primaryFont();
    155155
    156         if (nodeToRemove) {
    157             ExceptionCode ec;
    158             nodeToRemove->remove(ec);
    159             ASSERT(!ec);
    160         }
     156        if (nodeToRemove)
     157            nodeToRemove->remove(ASSERT_NO_EXCEPTION);
    161158
    162159        return result;
    … …  
    243240        [result setObject:[NSNumber numberWithInt:NSUnderlineStyleSingle] forKey:NSUnderlineStyleAttributeName];
    244241
    245     if (nodeToRemove) {
    246         ExceptionCode ec = 0;
    247         nodeToRemove->remove(ec);
    248         ASSERT(ec == 0);
    249     }
     242    if (nodeToRemove)
     243        nodeToRemove->remove(ASSERT_NO_EXCEPTION);
    250244
    251245    return result;

  • trunk/Source/WebCore/editing/markup.cpp

    r142139 r142247  
    565565        deleteButton->disable();
    566566
    567     ExceptionCode ec = 0;
    568     bool collapsed = updatedRange->collapsed(ec);
    569     ASSERT(!ec);
     567    bool collapsed = updatedRange->collapsed(ASSERT_NO_EXCEPTION);
    570568    if (collapsed)
    571569        return "";
    572     Node* commonAncestor = updatedRange->commonAncestorContainer(ec);
    573     ASSERT(!ec);
     570    Node* commonAncestor = updatedRange->commonAncestorContainer(ASSERT_NO_EXCEPTION);
    574571    if (!commonAncestor)
    575572        return "";
    … …  
    599596        startNode = visibleStart.next().deepEquivalent().deprecatedNode();
    600597
    601         ExceptionCode ec = 0;
    602         if (pastEnd && Range::compareBoundaryPoints(startNode, 0, pastEnd, 0, ec) >= 0) {
    603             ASSERT(!ec);
     598        if (pastEnd && Range::compareBoundaryPoints(startNode, 0, pastEnd, 0, ASSERT_NO_EXCEPTION) >= 0) {
    604599            if (deleteButton)
    605600                deleteButton->enable();
    606601            return interchangeNewlineString;
    607602        }
    608         ASSERT(!ec);
    609603    }
    610604
    … …  
    694688static void trimFragment(DocumentFragment* fragment, Node* nodeBeforeContext, Node* nodeAfterContext)
    695689{
    696     ExceptionCode ec = 0;
    697690    RefPtr<Node> next;
    698691    for (RefPtr<Node> node = fragment->firstChild(); node; node = next) {
    … …  
    703696        next = NodeTraversal::nextSkippingChildren(node.get());
    704697        ASSERT(!node->contains(nodeAfterContext));
    705         node->parentNode()->removeChild(node.get(), ec);
     698        node->parentNode()->removeChild(node.get(), ASSERT_NO_EXCEPTION);
    706699        if (nodeBeforeContext == node)
    707700            break;
    … …  
    711704    for (RefPtr<Node> node = nodeAfterContext; node; node = next) {
    712705        next = NodeTraversal::nextSkippingChildren(node.get());
    713         node->parentNode()->removeChild(node.get(), ec);
    714         ASSERT(!ec);
     706        node->parentNode()->removeChild(node.get(), ASSERT_NO_EXCEPTION);
    715707    }
    716708}
    … …  
    742734        positionBeforeNode(nodeAfterContext.get()).parentAnchoredEquivalent());
    743735
    744     ExceptionCode ec = 0;
    745     Node* commonAncestor = range->commonAncestorContainer(ec);
    746     ASSERT(!ec);
     736    Node* commonAncestor = range->commonAncestorContainer(ASSERT_NO_EXCEPTION);
    747737    Node* specialCommonAncestor = ancestorToRetainStructureAndAppearanceWithNoRenderer(commonAncestor);
    748738
    … …  
    751741    // TD, we need to include the enclosing TABLE tag as well.
    752742    RefPtr<DocumentFragment> fragment = DocumentFragment::create(document);
    753     if (specialCommonAncestor) {
    754         fragment->appendChild(specialCommonAncestor, ec);
    755         ASSERT(!ec);
    756     } else
     743    if (specialCommonAncestor)
     744        fragment->appendChild(specialCommonAncestor, ASSERT_NO_EXCEPTION);
     745    else
    757746        fragment->takeAllChildrenFrom(static_cast<ContainerNode*>(commonAncestor));
    758747
    … …  
    782771    Document* document = paragraph->document();
    783772
    784     ExceptionCode ec = 0;
    785773    if (string.isEmpty()) {
    786         paragraph->appendChild(createBlockPlaceholderElement(document), ec);
    787         ASSERT(!ec);
     774        paragraph->appendChild(createBlockPlaceholderElement(document), ASSERT_NO_EXCEPTION);
    788775        return;
    789776    }
    … …  
    802789        if (!s.isEmpty()) {
    803790            if (!tabText.isEmpty()) {
    804                 paragraph->appendChild(createTabSpanElement(document, tabText), ec);
    805                 ASSERT(!ec);
     791                paragraph->appendChild(createTabSpanElement(document, tabText), ASSERT_NO_EXCEPTION);
    806792                tabText = emptyString();
    807793            }
    808794            RefPtr<Node> textNode = document->createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
    809             paragraph->appendChild(textNode.release(), ec);
    810             ASSERT(!ec);
     795            paragraph->appendChild(textNode.release(), ASSERT_NO_EXCEPTION);
    811796        }
    812797
    … …  
    815800        if (i + 1 != numEntries)
    816801            tabText.append('\t');
    817         else if (!tabText.isEmpty()) {
    818             paragraph->appendChild(createTabSpanElement(document, tabText), ec);
    819             ASSERT(!ec);
    820         }
    821        
     802        else if (!tabText.isEmpty())
     803            paragraph->appendChild(createTabSpanElement(document, tabText), ASSERT_NO_EXCEPTION);
     804
    822805        first = false;
    823806    }
    … …  
    857840    string.replace('\r', '\n');
    858841
    859     ExceptionCode ec = 0;
    860842    RenderObject* renderer = styleNode->renderer();
    861843    if (renderer && renderer->style()->preserveNewline()) {
    862         fragment->appendChild(document->createTextNode(string), ec);
    863         ASSERT(!ec);
     844        fragment->appendChild(document->createTextNode(string), ASSERT_NO_EXCEPTION);
    864845        if (string.endsWith('\n')) {
    865846            RefPtr<Element> element = createBreakElement(document);
    866847            element->setAttribute(classAttr, AppleInterchangeNewline);           
    867             fragment->appendChild(element.release(), ec);
    868             ASSERT(!ec);
     848            fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
    869849        }
    870850        return fragment.release();
    … …  
    908888            fillContainerFromString(element.get(), s);
    909889        }
    910         fragment->appendChild(element.release(), ec);
    911         ASSERT(!ec);
     890        fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
    912891    }
    913892    return fragment.release();
    … …  
    925904    RefPtr<DocumentFragment> fragment = document->createDocumentFragment();
    926905
    927     ExceptionCode ec = 0;
    928906    size_t size = nodes.size();
    929907    for (size_t i = 0; i < size; ++i) {
    930908        RefPtr<Element> element = createDefaultParagraphElement(document);
    931         element->appendChild(nodes[i], ec);
    932         ASSERT(!ec);
    933         fragment->appendChild(element.release(), ec);
    934         ASSERT(!ec);
     909        element->appendChild(nodes[i], ASSERT_NO_EXCEPTION);
     910        fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
    935911    }
    936912

  • trunk/Source/WebCore/html/ColorInputType.cpp

    r142126 r142247  
    127127    RefPtr<HTMLDivElement> colorSwatch = HTMLDivElement::create(document);
    128128    colorSwatch->setPseudo(AtomicString("-webkit-color-swatch", AtomicString::ConstructFromLiteral));
    129     ExceptionCode ec = 0;
    130     wrapperElement->appendChild(colorSwatch.release(), ec);
    131     ASSERT(!ec);
    132     element()->userAgentShadowRoot()->appendChild(wrapperElement.release(), ec);
    133     ASSERT(!ec);
     129    wrapperElement->appendChild(colorSwatch.release(), ASSERT_NO_EXCEPTION);
     130    element()->userAgentShadowRoot()->appendChild(wrapperElement.release(), ASSERT_NO_EXCEPTION);
    134131   
    135132    updateColorSwatch();

  • trunk/Source/WebCore/html/HTMLOptionsCollection.cpp

    r142126 r142247  
    6666        select->add(newOption, static_cast<HTMLOptionElement*>(item(index)), ec);
    6767
    68     ASSERT(ec == 0);
     68    ASSERT(!ec);
    6969}
    7070

  • trunk/Source/WebCore/html/HTMLTextAreaElement.cpp

    r142126 r142247  
    540540void HTMLTextAreaElement::updatePlaceholderText()
    541541{
    542     ExceptionCode ec = 0;
    543542    String placeholderText = strippedPlaceholder();
    544543    if (placeholderText.isEmpty()) {
    545544        if (m_placeholder) {
    546             userAgentShadowRoot()->removeChild(m_placeholder, ec);
    547             ASSERT(!ec);
     545            userAgentShadowRoot()->removeChild(m_placeholder, ASSERT_NO_EXCEPTION);
    548546            m_placeholder = 0;
    549547        }
    … …  
    554552        m_placeholder = placeholder.get();
    555553        m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
    556         userAgentShadowRoot()->insertBefore(m_placeholder, innerTextElement()->nextSibling(), ec);
    557         ASSERT(!ec);
    558     }
    559     m_placeholder->setInnerText(placeholderText, ec);
    560     ASSERT(!ec);
     554        userAgentShadowRoot()->insertBefore(m_placeholder, innerTextElement()->nextSibling(), ASSERT_NO_EXCEPTION);
     555    }
     556    m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
    561557    fixPlaceholderRenderer(m_placeholder, innerTextElement());
    562558}

  • trunk/Source/WebCore/html/HTMLTextFormControlElement.cpp

    r142126 r142247  
    351351    if (enclosingTextFormControl(indexPosition) != this)
    352352        return 0;
    353     ExceptionCode ec = 0;
    354353    RefPtr<Range> range = Range::create(indexPosition.document());
    355     range->setStart(innerTextElement(), 0, ec);
    356     ASSERT(!ec);
    357     range->setEnd(indexPosition.containerNode(), indexPosition.offsetInContainerNode(), ec);
    358     ASSERT(!ec);
     354    range->setStart(innerTextElement(), 0, ASSERT_NO_EXCEPTION);
     355    range->setEnd(indexPosition.containerNode(), indexPosition.offsetInContainerNode(), ASSERT_NO_EXCEPTION);
    359356    return TextIterator::rangeLength(range.get());
    360357}
    … …  
    540537            document()->axObjectCache()->postNotification(this, AXObjectCache::AXValueChanged, false);
    541538
    542         ExceptionCode ec = 0;
    543         innerTextElement()->setInnerText(value, ec);
    544         ASSERT(!ec);
    545 
    546         if (value.endsWith('\n') || value.endsWith('\r')) {
    547             innerTextElement()->appendChild(HTMLBRElement::create(document()), ec);
    548             ASSERT(!ec);
    549         }
     539        innerTextElement()->setInnerText(value, ASSERT_NO_EXCEPTION);
     540
     541        if (value.endsWith('\n') || value.endsWith('\r'))
     542            innerTextElement()->appendChild(HTMLBRElement::create(document()), ASSERT_NO_EXCEPTION);
    550543    }
    551544

  • trunk/Source/WebCore/html/TextFieldInputType.cpp

    r142126 r142247  
    407407    if (!supportsPlaceholder())
    408408        return;
    409     ExceptionCode ec = 0;
    410409    String placeholderText = element()->strippedPlaceholder();
    411410    if (placeholderText.isEmpty()) {
    412411        if (m_placeholder) {
    413             m_placeholder->parentNode()->removeChild(m_placeholder.get(), ec);
    414             ASSERT(!ec);
     412            m_placeholder->parentNode()->removeChild(m_placeholder.get(), ASSERT_NO_EXCEPTION);
    415413            m_placeholder.clear();
    416414        }
    … …  
    420418        m_placeholder = HTMLDivElement::create(element()->document());
    421419        m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
    422         element()->userAgentShadowRoot()->insertBefore(m_placeholder, m_container ? m_container->nextSibling() : innerTextElement()->nextSibling(), ec);
    423         ASSERT(!ec);
    424     }
    425     m_placeholder->setInnerText(placeholderText, ec);
    426     ASSERT(!ec);
     420        element()->userAgentShadowRoot()->insertBefore(m_placeholder, m_container ? m_container->nextSibling() : innerTextElement()->nextSibling(), ASSERT_NO_EXCEPTION);
     421    }
     422    m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
    427423    element()->fixPlaceholderRenderer(m_placeholder.get(), m_container ? m_container.get() : m_innerText.get());
    428424}

  • trunk/Source/WebCore/html/ValidationMessage.cpp

    r142126 r142247  
    184184    // contains non-absolute or non-fixed renderers as children.
    185185    m_bubble->setInlineStyleProperty(CSSPropertyPosition, CSSValueAbsolute);
    186     ExceptionCode ec = 0;
    187     shadowRoot->appendChild(m_bubble.get(), ec);
    188     ASSERT(!ec);
     186    shadowRoot->appendChild(m_bubble.get(), ASSERT_NO_EXCEPTION);
    189187    m_element->document()->updateLayout();
    190188    adjustBubblePosition(m_element->boundingBox(), m_bubble.get());
    … …  
    194192    RefPtr<HTMLDivElement> bubbleArrow = HTMLDivElement::create(doc);
    195193    bubbleArrow->setPseudo(AtomicString("-webkit-validation-bubble-arrow", AtomicString::ConstructFromLiteral));
    196     clipper->appendChild(bubbleArrow.release(), ec);
    197     ASSERT(!ec);
    198     m_bubble->appendChild(clipper.release(), ec);
    199     ASSERT(!ec);
     194    clipper->appendChild(bubbleArrow.release(), ASSERT_NO_EXCEPTION);
     195    m_bubble->appendChild(clipper.release(), ASSERT_NO_EXCEPTION);
    200196
    201197    RefPtr<HTMLElement> message = HTMLDivElement::create(doc);

  • trunk/Source/WebCore/html/shadow/MediaControlElementTypes.cpp

    r142126 r142247  
    294294
    295295    float volume = narrowPrecisionToFloat(value().toDouble());
    296     if (volume != mediaController()->volume()) {
    297         ExceptionCode ec = 0;
    298         mediaController()->setVolume(volume, ec);
    299         ASSERT(!ec);
    300     }
     296    if (volume != mediaController()->volume())
     297        mediaController()->setVolume(volume, ASSERT_NO_EXCEPTION);
    301298    if (m_clearMutedOnUserInteraction)
    302299        mediaController()->setMuted(false);

  • trunk/Source/WebCore/inspector/InspectorPageAgent.cpp

    r142144 r142247  
    551551            if (!rawCookiesImplemented) {
    552552                // FIXME: We need duplication checking for the String representation of cookies.
    553                 ExceptionCode ec = 0;
    554                 stringCookiesList.append(document->cookie(ec));
     553                //
    555554                // Exceptions are thrown by cookie() in sandboxed frames. That won't happen here
    556555                // because "document" is the document of the main frame of the page.
    557                 ASSERT(!ec);
     556                stringCookiesList.append(document->cookie(ASSERT_NO_EXCEPTION));
    558557            } else {
    559558                int cookiesSize = docCookiesList.size();

  • trunk/Source/WebCore/inspector/InspectorStyleSheet.cpp

    r142126 r142247  
    863863        // What we just added has to be a CSSStyleRule - we cannot handle other types of rules yet.
    864864        // If it is not a style rule, pretend we never touched the stylesheet.
    865         m_pageStyleSheet->deleteRule(lastRuleIndex, ec);
    866         ASSERT(!ec);
     865        m_pageStyleSheet->deleteRule(lastRuleIndex, ASSERT_NO_EXCEPTION);
    867866        ec = SYNTAX_ERR;
    868867        return 0;

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp

    r142126 r142247  
    309309    if (m_domApplicationCache) {
    310310        const AtomicString& eventType = DOMApplicationCache::toEventType(id);
    311         ExceptionCode ec = 0;
    312311        RefPtr<Event> event;
    313312        if (id == PROGRESS_EVENT)
    … …  
    315314        else
    316315            event = Event::create(eventType, false, false);
    317         m_domApplicationCache->dispatchEvent(event, ec);
    318         ASSERT(!ec);
     316        m_domApplicationCache->dispatchEvent(event, ASSERT_NO_EXCEPTION);
    319317    }
    320318}

  • trunk/Source/WebCore/page/DOMSelection.cpp

    r142126 r142247  
    439439        return;
    440440
    441     ExceptionCode ec = 0;
    442     selectedRange->deleteContents(ec);
    443     ASSERT(!ec);
    444 
    445     setBaseAndExtent(selectedRange->startContainer(ec), selectedRange->startOffset(), selectedRange->startContainer(), selectedRange->startOffset(), ec);
    446     ASSERT(!ec);
     441    selectedRange->deleteContents(ASSERT_NO_EXCEPTION);
     442
     443    setBaseAndExtent(selectedRange->startContainer(ASSERT_NO_EXCEPTION), selectedRange->startOffset(), selectedRange->startContainer(), selectedRange->startOffset(), ASSERT_NO_EXCEPTION);
    447444}
    448445

  • trunk/Source/WebCore/page/DragController.cpp

    r142126 r142247  
    702702    if (node->isContentRichlyEditable()) {
    703703        RefPtr<Range> range = source->document()->createRange();
    704         ExceptionCode ec = 0;
    705         range->selectNode(node, ec);
    706         ASSERT(!ec);
     704        range->selectNode(node, ASSERT_NO_EXCEPTION);
    707705        source->selection()->setSelection(VisibleSelection(range.get(), DOWNSTREAM));
    708706    }

  • trunk/Source/WebCore/rendering/RenderTextControl.cpp

    r142126 r142247  
    130130    if (index <= 0)
    131131        return VisiblePosition(firstPositionInNode(innerTextElement()), DOWNSTREAM);
    132     ExceptionCode ec = 0;
    133132    RefPtr<Range> range = Range::create(document());
    134     range->selectNodeContents(innerTextElement(), ec);
    135     ASSERT(!ec);
     133    range->selectNodeContents(innerTextElement(), ASSERT_NO_EXCEPTION);
    136134    CharacterIterator it(range.get());
    137135    it.advance(index - 1);
Note: See TracChangeset for help on using the changeset viewer.