Reviewed by Eric and Geoff.
authordarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 10 Feb 2006 00:09:17 +0000 (00:09 +0000)
committerdarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 10 Feb 2006 00:09:17 +0000 (00:09 +0000)
        - changed basic DOM mutation calls to assert that "this"
          is not floating, then added more uses of RefPtr to prevent the
          assertion from firing (at least during my testing and layout tests)

        - removed use of PassRefPtr as the type of a local variable; after talking
          with Maciej and Eric, this type of use is now "deprecated"

        * bindings/js/JSDOMCore.cpp: Touched this file to get things to build.

        * bindings/objc/DOM.mm:
        (-[DOMRange extractContents]):
        (-[DOMRange cloneContents]):
        (-[DOMRange cloneRange]):
        * khtml/ecma/kjs_range.cpp:
        (KJS::DOMRange::getValueProperty):
        (KJS::DOMRangeProtoFunc::callAsFunction):
        * khtml/editing/Selection.cpp:
        (WebCore::Selection::toRange):
        * bridge/mac/WebCoreFrameBridge.mm:
        (-[WebCoreFrameBridge documentFragmentWithMarkupString:baseURLString:]):
        * dom/ContainerNodeImpl.cpp:
        (WebCore::ContainerNodeImpl::insertBefore):
        (WebCore::ContainerNodeImpl::replaceChild):
        (WebCore::ContainerNodeImpl::removeChild):
        (WebCore::ContainerNodeImpl::appendChild):
        * dom/DocPtr.h: Removed uses of NULL and unused deprecated functions.
        * dom/dom2_rangeimpl.h:
        * dom/dom2_rangeimpl.cpp:
        (WebCore::RangeImpl::RangeImpl):
        (WebCore::RangeImpl::startContainer):
        (WebCore::RangeImpl::endContainer):
        (WebCore::RangeImpl::commonAncestorContainer):
        (WebCore::RangeImpl::setStart):
        (WebCore::RangeImpl::setEnd):
        (WebCore::RangeImpl::collapse):
        (WebCore::RangeImpl::compareBoundaryPoints):
        (WebCore::RangeImpl::boundaryPointsValid):
        (WebCore::RangeImpl::processContents):
        (WebCore::RangeImpl::extractContents):
        (WebCore::RangeImpl::cloneContents):
        (WebCore::RangeImpl::insertNode):
        (WebCore::RangeImpl::createContextualFragment):
        (WebCore::RangeImpl::detach):
        (WebCore::RangeImpl::cloneRange):
        (WebCore::RangeImpl::selectNodeContents):
        (WebCore::RangeImpl::surroundContents):
        (WebCore::RangeImpl::containedByReadOnly):
        (WebCore::RangeImpl::startPosition):
        (WebCore::RangeImpl::endPosition):
        (WebCore::RangeImpl::startNode):
        (WebCore::RangeImpl::editingStartPosition):
        (WebCore::rangeOfContents):
        * dom/dom_elementimpl.h:
        * dom/dom_elementimpl.cpp:
        (WebCore::AttrImpl::AttrImpl):
        (WebCore::AttrImpl::~AttrImpl):
        (WebCore::AttrImpl::setValue):
        (WebCore::AttrImpl::childTypeAllowed):
        (WebCore::AttrImpl::childrenChanged):
        (WebCore::ElementImpl::removeAttributeNode):
        (WebCore::NamedAttrMapImpl::clearAttributes):
        (WebCore::CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl):
        (WebCore::MappedAttributeImpl::clone):
        * dom/DocumentFragmentImpl.cpp:
        (DOM::DocumentFragmentImpl::cloneNode):
        * dom/dom_xmlimpl.cpp:
        (WebCore::EntityReferenceImpl::cloneNode):
        (WebCore::ProcessingInstructionImpl::ProcessingInstructionImpl):
        (WebCore::ProcessingInstructionImpl::checkStyleSheet):
        (WebCore::ProcessingInstructionImpl::setStyleSheet):
        * dom/dom_position.cpp:
        * khtml/editing/break_blockquote_command.cpp:
        (WebCore::BreakBlockquoteCommand::doApply):
        * khtml/editing/composite_edit_command.cpp:
        (WebCore::CompositeEditCommand::appendBlockPlaceholder):
        (WebCore::CompositeEditCommand::insertBlockPlaceholder):
        (WebCore::CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary):
        (WebCore::createBlockPlaceholderElement):
        * khtml/editing/delete_selection_command.cpp:
        (WebCore::DeleteSelectionCommand::insertPlaceholderForAncestorBlockContent):
        (WebCore::DeleteSelectionCommand::moveNodesAfterNode):
        * khtml/editing/html_interchange.cpp:
        * khtml/editing/htmlediting.cpp:
        (WebCore::rebalanceWhitespaceInTextNode):
        (WebCore::nonBreakingSpaceString):
        (WebCore::createDefaultParagraphElement):
        (WebCore::createBreakElement):
        (WebCore::createTabSpanElement):
        * khtml/editing/insert_line_break_command.cpp:
        (khtml::InsertLineBreakCommand::doApply):
        * khtml/editing/insert_paragraph_separator_command.cpp:
        (WebCore::InsertParagraphSeparatorCommand::doApply):
        * khtml/editing/insert_paragraph_separator_command.h:
        * khtml/editing/insert_text_command.cpp:
        (khtml::InsertTextCommand::insertTab):
        * khtml/editing/markup.cpp:
        (khtml::createFragmentFromMarkup):
        (khtml::createParagraphContentsFromString):
        (khtml::createFragmentFromText):
        (khtml::createFragmentFromNodeList):
        * khtml/editing/rebalance_whitespace_command.cpp:
        * khtml/editing/replace_selection_command.cpp:
        (WebCore::ReplacementFragment::ReplacementFragment):
        (WebCore::ReplacementFragment::insertFragmentForTestRendering):
        (WebCore::ReplaceSelectionCommand::doApply):
        * khtml/editing/visible_text.cpp:
        (khtml::CharacterIterator::range):
        (khtml::findPlainText):
        * khtml/html/HTMLElementImpl.cpp:
        (WebCore::HTMLElementImpl::cloneNode):
        * khtml/html/htmlparser.cpp:
        (HTMLParser::handleResidualStyleCloseTagAcrossBlocks):
        * ksvg2/svg/SVGTransformableImpl.cpp:
        (SVGTransformableImpl::parseTransformAttribute):
        * ksvg2/svg/SVGUseElementImpl.cpp:
        (SVGUseElementImpl::closeRenderer):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@12725 268f45cc-cd09-0410-ab3c-d52691b4dbfc

33 files changed:
WebCore/ChangeLog
WebCore/bindings/js/JSDOMCore.cpp
WebCore/bindings/objc/DOM.mm
WebCore/bridge/mac/WebCoreFrameBridge.mm
WebCore/dom/ContainerNodeImpl.cpp
WebCore/dom/DocPtr.h
WebCore/dom/DocumentFragmentImpl.cpp
WebCore/dom/dom2_rangeimpl.cpp
WebCore/dom/dom2_rangeimpl.h
WebCore/dom/dom_elementimpl.cpp
WebCore/dom/dom_elementimpl.h
WebCore/dom/dom_position.cpp
WebCore/dom/dom_xmlimpl.cpp
WebCore/khtml/ecma/kjs_range.cpp
WebCore/khtml/editing/Selection.cpp
WebCore/khtml/editing/break_blockquote_command.cpp
WebCore/khtml/editing/composite_edit_command.cpp
WebCore/khtml/editing/delete_selection_command.cpp
WebCore/khtml/editing/html_interchange.cpp
WebCore/khtml/editing/htmlediting.cpp
WebCore/khtml/editing/htmlediting.h
WebCore/khtml/editing/insert_line_break_command.cpp
WebCore/khtml/editing/insert_paragraph_separator_command.cpp
WebCore/khtml/editing/insert_paragraph_separator_command.h
WebCore/khtml/editing/insert_text_command.cpp
WebCore/khtml/editing/markup.cpp
WebCore/khtml/editing/rebalance_whitespace_command.cpp
WebCore/khtml/editing/replace_selection_command.cpp
WebCore/khtml/editing/visible_text.cpp
WebCore/khtml/html/HTMLElementImpl.cpp
WebCore/khtml/html/htmlparser.cpp
WebCore/ksvg2/svg/SVGTransformableImpl.cpp
WebCore/ksvg2/svg/SVGUseElementImpl.cpp

index b13f1a063ff502a7071b2d3db10837f4f691e442..a3b54fea0aa892358d9cb298a43f12dcbd2cd18b 100644 (file)
@@ -1,3 +1,124 @@
+2006-02-09  Darin Adler  <darin@apple.com>
+
+        Reviewed by Eric and Geoff.
+
+        - changed basic DOM mutation calls to assert that "this"
+          is not floating, then added more uses of RefPtr to prevent the
+          assertion from firing (at least during my testing and layout tests)
+
+        - removed use of PassRefPtr as the type of a local variable; after talking
+          with Maciej and Eric, this type of use is now "deprecated"
+
+        * bindings/js/JSDOMCore.cpp: Touched this file to get things to build.
+
+        * bindings/objc/DOM.mm:
+        (-[DOMRange extractContents]):
+        (-[DOMRange cloneContents]):
+        (-[DOMRange cloneRange]):
+        * khtml/ecma/kjs_range.cpp:
+        (KJS::DOMRange::getValueProperty):
+        (KJS::DOMRangeProtoFunc::callAsFunction):
+        * khtml/editing/Selection.cpp:
+        (WebCore::Selection::toRange):
+        * bridge/mac/WebCoreFrameBridge.mm:
+        (-[WebCoreFrameBridge documentFragmentWithMarkupString:baseURLString:]):
+        * dom/ContainerNodeImpl.cpp:
+        (WebCore::ContainerNodeImpl::insertBefore):
+        (WebCore::ContainerNodeImpl::replaceChild):
+        (WebCore::ContainerNodeImpl::removeChild):
+        (WebCore::ContainerNodeImpl::appendChild):
+        * dom/DocPtr.h: Removed uses of NULL and unused deprecated functions.
+        * dom/dom2_rangeimpl.h:
+        * dom/dom2_rangeimpl.cpp:
+        (WebCore::RangeImpl::RangeImpl):
+        (WebCore::RangeImpl::startContainer):
+        (WebCore::RangeImpl::endContainer):
+        (WebCore::RangeImpl::commonAncestorContainer):
+        (WebCore::RangeImpl::setStart):
+        (WebCore::RangeImpl::setEnd):
+        (WebCore::RangeImpl::collapse):
+        (WebCore::RangeImpl::compareBoundaryPoints):
+        (WebCore::RangeImpl::boundaryPointsValid):
+        (WebCore::RangeImpl::processContents):
+        (WebCore::RangeImpl::extractContents):
+        (WebCore::RangeImpl::cloneContents):
+        (WebCore::RangeImpl::insertNode):
+        (WebCore::RangeImpl::createContextualFragment):
+        (WebCore::RangeImpl::detach):
+        (WebCore::RangeImpl::cloneRange):
+        (WebCore::RangeImpl::selectNodeContents):
+        (WebCore::RangeImpl::surroundContents):
+        (WebCore::RangeImpl::containedByReadOnly):
+        (WebCore::RangeImpl::startPosition):
+        (WebCore::RangeImpl::endPosition):
+        (WebCore::RangeImpl::startNode):
+        (WebCore::RangeImpl::editingStartPosition):
+        (WebCore::rangeOfContents):
+        * dom/dom_elementimpl.h:
+        * dom/dom_elementimpl.cpp:
+        (WebCore::AttrImpl::AttrImpl):
+        (WebCore::AttrImpl::~AttrImpl):
+        (WebCore::AttrImpl::setValue):
+        (WebCore::AttrImpl::childTypeAllowed):
+        (WebCore::AttrImpl::childrenChanged):
+        (WebCore::ElementImpl::removeAttributeNode):
+        (WebCore::NamedAttrMapImpl::clearAttributes):
+        (WebCore::CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl):
+        (WebCore::MappedAttributeImpl::clone):
+        * dom/DocumentFragmentImpl.cpp:
+        (DOM::DocumentFragmentImpl::cloneNode):
+        * dom/dom_xmlimpl.cpp:
+        (WebCore::EntityReferenceImpl::cloneNode):
+        (WebCore::ProcessingInstructionImpl::ProcessingInstructionImpl):
+        (WebCore::ProcessingInstructionImpl::checkStyleSheet):
+        (WebCore::ProcessingInstructionImpl::setStyleSheet):
+        * dom/dom_position.cpp:
+        * khtml/editing/break_blockquote_command.cpp:
+        (WebCore::BreakBlockquoteCommand::doApply):
+        * khtml/editing/composite_edit_command.cpp:
+        (WebCore::CompositeEditCommand::appendBlockPlaceholder):
+        (WebCore::CompositeEditCommand::insertBlockPlaceholder):
+        (WebCore::CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary):
+        (WebCore::createBlockPlaceholderElement):
+        * khtml/editing/delete_selection_command.cpp:
+        (WebCore::DeleteSelectionCommand::insertPlaceholderForAncestorBlockContent):
+        (WebCore::DeleteSelectionCommand::moveNodesAfterNode):
+        * khtml/editing/html_interchange.cpp:
+        * khtml/editing/htmlediting.cpp:
+        (WebCore::rebalanceWhitespaceInTextNode):
+        (WebCore::nonBreakingSpaceString):
+        (WebCore::createDefaultParagraphElement):
+        (WebCore::createBreakElement):
+        (WebCore::createTabSpanElement):
+        * khtml/editing/insert_line_break_command.cpp:
+        (khtml::InsertLineBreakCommand::doApply):
+        * khtml/editing/insert_paragraph_separator_command.cpp:
+        (WebCore::InsertParagraphSeparatorCommand::doApply):
+        * khtml/editing/insert_paragraph_separator_command.h:
+        * khtml/editing/insert_text_command.cpp:
+        (khtml::InsertTextCommand::insertTab):
+        * khtml/editing/markup.cpp:
+        (khtml::createFragmentFromMarkup):
+        (khtml::createParagraphContentsFromString):
+        (khtml::createFragmentFromText):
+        (khtml::createFragmentFromNodeList):
+        * khtml/editing/rebalance_whitespace_command.cpp:
+        * khtml/editing/replace_selection_command.cpp:
+        (WebCore::ReplacementFragment::ReplacementFragment):
+        (WebCore::ReplacementFragment::insertFragmentForTestRendering):
+        (WebCore::ReplaceSelectionCommand::doApply):
+        * khtml/editing/visible_text.cpp:
+        (khtml::CharacterIterator::range):
+        (khtml::findPlainText):
+        * khtml/html/HTMLElementImpl.cpp:
+        (WebCore::HTMLElementImpl::cloneNode):
+        * khtml/html/htmlparser.cpp:
+        (HTMLParser::handleResidualStyleCloseTagAcrossBlocks):
+        * ksvg2/svg/SVGTransformableImpl.cpp:
+        (SVGTransformableImpl::parseTransformAttribute):
+        * ksvg2/svg/SVGUseElementImpl.cpp:
+        (SVGUseElementImpl::closeRenderer):
+
 2006-02-09  Alexander Kellett  <lypanov@kde.org>
 
         Reviewed and landed by Maciej. 
index 533aa4cd9698fa9914da10014e121df2c317c7ab..6895212c2d5117f1ddcac296f7d9d874c75b6e8b 100644 (file)
@@ -1,6 +1,6 @@
 #include "config.h"
 
-// These are generated files
+// These are generated files.
 
 #include "JSAttr.cpp"
 #include "JSCharacterData.cpp"
index 014697b7253c8b5b56736e6626db309648e0d082..cc3f9d8decd1150abf9985df8ef4d6bd0adf0bd6 100644 (file)
@@ -1854,7 +1854,7 @@ static ListenerMap *listenerMap;
 - (DOMDocumentFragment *)extractContents
 {
     int exceptionCode = 0;
-    DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->extractContents(exceptionCode)];
+    DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->extractContents(exceptionCode).get()];
     raiseOnDOMError(exceptionCode);
     return result;
 }
@@ -1862,7 +1862,7 @@ static ListenerMap *listenerMap;
 - (DOMDocumentFragment *)cloneContents
 {
     int exceptionCode = 0;
-    DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->cloneContents(exceptionCode)];
+    DOMDocumentFragment *result = [DOMDocumentFragment _documentFragmentWithImpl:[self _rangeImpl]->cloneContents(exceptionCode).get()];
     raiseOnDOMError(exceptionCode);
     return result;
 }
@@ -1884,7 +1884,7 @@ static ListenerMap *listenerMap;
 - (DOMRange *)cloneRange
 {
     int exceptionCode = 0;
-    DOMRange *result = [DOMRange _rangeWithImpl:[self _rangeImpl]->cloneRange(exceptionCode)];
+    DOMRange *result = [DOMRange _rangeWithImpl:[self _rangeImpl]->cloneRange(exceptionCode).get()];
     raiseOnDOMError(exceptionCode);
     return result;
 }
index 69060d661fdadc3e45ad7bfbe04ffba7b41cecdd..aa11d27477feab014ddce1845100053383cb57e9 100644 (file)
@@ -2154,8 +2154,8 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     if (!m_frame || !m_frame->document())
         return 0;
 
-    PassRefPtr<DocumentFragmentImpl> fragment = createFragmentFromMarkup(m_frame->document(), QString::fromNSString(markupString), QString::fromNSString(baseURLString));
-    return [DOMDocumentFragment _documentFragmentWithImpl:fragment.get()];
+    return [DOMDocumentFragment _documentFragmentWithImpl:createFragmentFromMarkup(m_frame->document(),
+        QString::fromNSString(markupString), QString::fromNSString(baseURLString)).get()];
 }
 
 - (DOMDocumentFragment *)documentFragmentWithText:(NSString *)text
index 6b7835a9929827ac12a85ed37b3d37ea15b62765..301310c278fcf1312b7bca7f00b31dc1fa1c98fb 100644 (file)
@@ -120,6 +120,10 @@ NodeImpl* ContainerNodeImpl::lastChild() const
 
 bool ContainerNodeImpl::insertBefore(PassRefPtr<NodeImpl> newChild, NodeImpl* refChild, ExceptionCode& ec)
 {
+    // Check that this node is not "floating".
+    // If it is, it can be deleted as a side effect of sending mutation events.
+    ASSERT(refCount() || parent());
+
     ec = 0;
 
     // insertBefore(node, 0) is equivalent to appendChild(node)
@@ -212,6 +216,10 @@ bool ContainerNodeImpl::insertBefore(PassRefPtr<NodeImpl> newChild, NodeImpl* re
 
 bool ContainerNodeImpl::replaceChild(PassRefPtr<NodeImpl> newChild, NodeImpl* oldChild, ExceptionCode& ec)
 {
+    // Check that this node is not "floating".
+    // If it is, it can be deleted as a side effect of sending mutation events.
+    ASSERT(refCount() || parent());
+
     ec = 0;
 
     if (oldChild == newChild) // nothing to do
@@ -335,6 +343,10 @@ static ExceptionCode willRemoveChild(NodeImpl *child)
 
 bool ContainerNodeImpl::removeChild(NodeImpl* oldChild, ExceptionCode& ec)
 {
+    // Check that this node is not "floating".
+    // If it is, it can be deleted as a side effect of sending mutation events.
+    ASSERT(refCount() || parent());
+
     ec = 0;
 
     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
@@ -456,6 +468,10 @@ void ContainerNodeImpl::removeChildren()
 
 bool ContainerNodeImpl::appendChild(PassRefPtr<NodeImpl> newChild, ExceptionCode& ec)
 {
+    // Check that this node is not "floating".
+    // If it is, it can be deleted as a side effect of sending mutation events.
+    ASSERT(refCount() || parent());
+
     ec = 0;
 
     // Make sure adding the new child is ok
index 00d780b12f32a51b99513985d44f67d72570a333..81c0889c5de649054a25f5779195b1f4eeecc30c 100644 (file)
@@ -1,7 +1,7 @@
 // -*- mode: c++; c-basic-offset: 4 -*-
 /*
  * This file is part of the DOM implementation for KDE.
- * Copyright (C) 2005 Apple Computer, Inc.
+ * Copyright (C) 2005, 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -19,6 +19,7 @@
  * Boston, MA 02111-1307, USA.
  *
  */
+
 #ifndef DOM_DocPtr_h
 #define DOM_DocPtr_h
 
@@ -27,21 +28,13 @@ namespace DOM {
 template <class T> class DocPtr
 {
  public:
-    DocPtr() : m_ptr(NULL) {}
+    DocPtr() : m_ptr(0) {}
     DocPtr(T *ptr) : m_ptr(ptr) { if (ptr) ptr->selfOnlyRef(); }
     DocPtr(const DocPtr &o) : m_ptr(o.m_ptr) { if (T *ptr = m_ptr) ptr->selfOnlyRefRef(); }
     ~DocPtr() { if (T *ptr = m_ptr) ptr->selfOnlyDeref(); }
     
     template <class U> DocPtr(const DocPtr<U> &o) : m_ptr(o.get()) { if (T *ptr = m_ptr) ptr->selfOnlyRef(); }
     
-    // FIXME: Deprecate in favor of operators below, then remove?
-    bool isNull() const { return m_ptr == NULL; }
-    bool notNull() const { return m_ptr != NULL; }
-    
-    // FIXME: Deprecate in favor of operator=, then remove?
-    void reset() { if (T *ptr = m_ptr) ptr->selfOnlyDeref(); m_ptr = NULL; }
-    void reset(T *o) { if (o) o->selfOnlyRef(); if (T *ptr = m_ptr) ptr->selfOnlyDeref(); m_ptr = o; }
-
     void resetSkippingRef(T *o) { m_ptr = o; }
     
     T *get() const { return m_ptr; }
@@ -49,7 +42,7 @@ template <class T> class DocPtr
     T &operator*() const { return *m_ptr; }
     T *operator->() const { return m_ptr; }
     
-    bool operator!() const { return m_ptr == NULL; }
+    bool operator!() const { return !m_ptr; }
 
     // this type conversion operator allows implicit conversion to
     // bool but not to other integer types
index 22a36807b176c0de1f73e45c01d8747590622ee8..9aaad8854cf0c8438703106c9dc7de996ee8c827 100644 (file)
@@ -69,10 +69,10 @@ DOMString DocumentFragmentImpl::toString() const
 
 PassRefPtr<NodeImpl> DocumentFragmentImpl::cloneNode(bool deep)
 {
-    PassRefPtr<DocumentFragmentImpl> clone = new DocumentFragmentImpl(getDocument());
+    RefPtr<DocumentFragmentImpl> clone = new DocumentFragmentImpl(getDocument());
     if (deep)
         cloneChildNodes(clone.get());
-    return clone;
+    return clone.release();
 }
 
 }
index 0b812406f3123937a61e53b088dfad3c48fc7b49..2a596873e617b68bccb2276e7bac0a57d1f47910 100644 (file)
 #include "dom2_rangeimpl.h"
 
 #include "DocumentImpl.h"
-#include "dom/dom_exception.h"
+#include "dom_exception.h"
 #include "dom_textimpl.h"
 #include "dom_xmlimpl.h"
 #include "HTMLElementImpl.h"
-#include "editing/markup.h"
-#include "editing/visible_position.h"
-#include "editing/visible_units.h"
-#include "editing/visible_text.h"
+#include "markup.h"
+#include "visible_position.h"
+#include "visible_units.h"
+#include "visible_text.h"
 #include "dom_position.h"
-
 #include "RenderBlock.h"
 
-using khtml::createMarkup;
-using khtml::RenderBlock;
-using khtml::RenderObject;
-using khtml::VisiblePosition;
-using khtml::DOWNSTREAM;
-using khtml::isEndOfParagraph;
-
-namespace DOM {
-
-RangeImpl::RangeImpl(DocumentImpl *_ownerDocument)
-{
-    m_ownerDocument = _ownerDocument;
-    m_ownerDocument->ref();
-    m_startContainer = _ownerDocument;
-    m_startContainer->ref();
-    m_endContainer = _ownerDocument;
-    m_endContainer->ref();
-    m_startOffset = 0;
-    m_endOffset = 0;
-    m_detached = false;
-}
+namespace WebCore {
 
-RangeImpl::RangeImpl(DocumentImpl *_ownerDocument,
-              NodeImpl *_startContainer, int _startOffset,
-              NodeImpl *_endContainer, int _endOffset)
+RangeImpl::RangeImpl(DocumentImpl* ownerDocument)
+    : m_ownerDocument(ownerDocument)
+    , m_startContainer(ownerDocument), m_startOffset(0)
+    , m_endContainer(ownerDocument), m_endOffset(0)
+    , m_detached(false)
 {
-    m_ownerDocument = _ownerDocument;
-    m_ownerDocument->ref();
-    m_startContainer = _startContainer;
-    m_startContainer->ref();
-    m_startOffset = _startOffset;
-    m_endContainer = _endContainer;
-    m_endContainer->ref();
-    m_endOffset = _endOffset;
-    m_detached = false;
 }
 
-RangeImpl::~RangeImpl()
+RangeImpl::RangeImpl(DocumentImpl* ownerDocument,
+              NodeImpl* startContainer, int startOffset,
+              NodeImpl* endContainer, int endOffset)
+    : m_ownerDocument(ownerDocument)
+    , m_startContainer(startContainer), m_startOffset(startOffset)
+    , m_endContainer(endContainer), m_endOffset(endOffset)
+    , m_detached(false)
 {
-    m_ownerDocument->deref();
-    int exceptioncode = 0;
-    if (!m_detached)
-        detach(exceptioncode);
 }
 
 NodeImpl *RangeImpl::startContainer(int &exceptioncode) const
@@ -91,7 +65,7 @@ NodeImpl *RangeImpl::startContainer(int &exceptioncode) const
         return 0;
     }
 
-    return m_startContainer;
+    return m_startContainer.get();
 }
 
 int RangeImpl::startOffset(int &exceptioncode) const
@@ -111,7 +85,7 @@ NodeImpl *RangeImpl::endContainer(int &exceptioncode) const
         return 0;
     }
 
-    return m_endContainer;
+    return m_endContainer.get();
 }
 
 int RangeImpl::endOffset(int &exceptioncode) const
@@ -131,7 +105,7 @@ NodeImpl *RangeImpl::commonAncestorContainer(int &exceptioncode) const
         return 0;
     }
 
-    NodeImpl *com = commonAncestorContainer(m_startContainer,m_endContainer);
+    NodeImpl *com = commonAncestorContainer(m_startContainer.get(), m_endContainer.get());
     if (!com) //  should never happen
         exceptioncode = DOMException::WRONG_DOCUMENT_ERR;
     return com;
@@ -186,21 +160,21 @@ void RangeImpl::setStart( NodeImpl *refNode, int offset, int &exceptioncode )
     if (exceptioncode)
         return;
 
-    setStartContainer(refNode);
+    m_startContainer = refNode;
     m_startOffset = offset;
 
     // check if different root container
-    NodeImpl *endRootContainer = m_endContainer;
+    NodeImpl* endRootContainer = m_endContainer.get();
     while (endRootContainer->parentNode())
         endRootContainer = endRootContainer->parentNode();
-    NodeImpl *startRootContainer = m_startContainer;
+    NodeImpl* startRootContainer = m_startContainer.get();
     while (startRootContainer->parentNode())
         startRootContainer = startRootContainer->parentNode();
     if (startRootContainer != endRootContainer)
-        collapse(true,exceptioncode);
+        collapse(true, exceptioncode);
     // check if new start after end
-    else if (compareBoundaryPoints(m_startContainer,m_startOffset,m_endContainer,m_endOffset) > 0)
-        collapse(true,exceptioncode);
+    else if (compareBoundaryPoints(m_startContainer.get(), m_startOffset, m_endContainer.get(), m_endOffset) > 0)
+        collapse(true, exceptioncode);
 }
 
 void RangeImpl::setEnd( NodeImpl *refNode, int offset, int &exceptioncode )
@@ -224,21 +198,21 @@ void RangeImpl::setEnd( NodeImpl *refNode, int offset, int &exceptioncode )
     if (exceptioncode)
         return;
 
-    setEndContainer(refNode);
+    m_endContainer = refNode;
     m_endOffset = offset;
 
     // check if different root container
-    NodeImpl *endRootContainer = m_endContainer;
+    NodeImpl* endRootContainer = m_endContainer.get();
     while (endRootContainer->parentNode())
         endRootContainer = endRootContainer->parentNode();
-    NodeImpl *startRootContainer = m_startContainer;
+    NodeImpl* startRootContainer = m_startContainer.get();
     while (startRootContainer->parentNode())
         startRootContainer = startRootContainer->parentNode();
     if (startRootContainer != endRootContainer)
-        collapse(false,exceptioncode);
+        collapse(false, exceptioncode);
     // check if new end before start
-    if (compareBoundaryPoints(m_startContainer,m_startOffset,m_endContainer,m_endOffset) > 0)
-        collapse(false,exceptioncode);
+    if (compareBoundaryPoints(m_startContainer.get(), m_startOffset, m_endContainer.get(), m_endOffset) > 0)
+        collapse(false, exceptioncode);
 }
 
 void RangeImpl::collapse( bool toStart, int &exceptioncode )
@@ -248,14 +222,11 @@ void RangeImpl::collapse( bool toStart, int &exceptioncode )
         return;
     }
 
-    if( toStart )   // collapse to start
-    {
-        setEndContainer(m_startContainer);
+    if (toStart) {  // collapse to start
+        m_endContainer = m_startContainer;
         m_endOffset = m_startOffset;
-    }
-    else            // collapse to end
-    {
-        setStartContainer(m_endContainer);
+    } else {        // collapse to end
+        m_startContainer = m_endContainer;
         m_startOffset = m_endOffset;
     }
 }
@@ -296,19 +267,19 @@ short RangeImpl::compareBoundaryPoints( Range::CompareHow how, const RangeImpl *
     switch(how)
     {
     case Range::START_TO_START:
-        return compareBoundaryPoints( m_startContainer, m_startOffset,
+        return compareBoundaryPoints( m_startContainer.get(), m_startOffset,
                                       sourceRange->startContainer(exceptioncode), sourceRange->startOffset(exceptioncode) );
         break;
     case Range::START_TO_END:
-        return compareBoundaryPoints( m_startContainer, m_startOffset,
+        return compareBoundaryPoints( m_startContainer.get(), m_startOffset,
                                       sourceRange->endContainer(exceptioncode), sourceRange->endOffset(exceptioncode) );
         break;
     case Range::END_TO_END:
-        return compareBoundaryPoints( m_endContainer, m_endOffset,
+        return compareBoundaryPoints( m_endContainer.get(), m_endOffset,
                                       sourceRange->endContainer(exceptioncode), sourceRange->endOffset(exceptioncode) );
         break;
     case Range::END_TO_START:
-        return compareBoundaryPoints( m_endContainer, m_endOffset,
+        return compareBoundaryPoints( m_endContainer.get(), m_endOffset,
                                       sourceRange->startContainer(exceptioncode), sourceRange->startOffset(exceptioncode) );
         break;
     default:
@@ -397,9 +368,9 @@ short RangeImpl::compareBoundaryPoints( const Position &a, const Position &b )
     return compareBoundaryPoints(a.node(), a.offset(), b.node(), b.offset());
 }
 
-bool RangeImpl::boundaryPointsValid(  ) const
+bool RangeImpl::boundaryPointsValid() const
 {
-    return compareBoundaryPoints( m_startContainer, m_startOffset, m_endContainer, m_endOffset ) <= 0;
+    return compareBoundaryPoints(m_startContainer.get(), m_startOffset, m_endContainer.get(), m_endOffset) <= 0;
 }
 
 void RangeImpl::deleteContents( int &exceptioncode ) {
@@ -415,7 +386,7 @@ void RangeImpl::deleteContents( int &exceptioncode ) {
     processContents(DELETE_CONTENTS,exceptioncode);
 }
 
-DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &exceptioncode )
+PassRefPtr<DocumentFragmentImpl> RangeImpl::processContents ( ActionType action, int &exceptioncode )
 {
     // ### when mutation events are implemented, we will have to take into account
     // situations where the tree is being transformed while we delete - ugh!
@@ -434,7 +405,7 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
     // what is the highest node that partially selects the start of the range?
     NodeImpl *partialStart = 0;
     if (m_startContainer != cmnRoot) {
-        partialStart = m_startContainer;
+        partialStart = m_startContainer.get();
         while (partialStart->parentNode() != cmnRoot)
             partialStart = partialStart->parentNode();
     }
@@ -442,12 +413,12 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
     // what is the highest node that partially selects the end of the range?
     NodeImpl *partialEnd = 0;
     if (m_endContainer != cmnRoot) {
-        partialEnd = m_endContainer;
+        partialEnd = m_endContainer.get();
         while (partialEnd->parentNode() != cmnRoot)
             partialEnd = partialEnd->parentNode();
     }
 
-    DocumentFragmentImpl *fragment = 0;
+    RefPtr<DocumentFragmentImpl> fragment;
     if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS)
         fragment = new DocumentFragmentImpl(m_ownerDocument.get());
 
@@ -459,13 +430,13 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
            m_startContainer->nodeType() == Node::COMMENT_NODE) {
 
             if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
-                PassRefPtr<CharacterDataImpl> c = static_pointer_cast<CharacterDataImpl>(m_startContainer->cloneNode(true));
-                c->deleteData(m_endOffset,static_cast<CharacterDataImpl*>(m_startContainer)->length()-m_endOffset,exceptioncode);
-                c->deleteData(0,m_startOffset,exceptioncode);
-                fragment->appendChild(c, exceptioncode);
+                RefPtr<CharacterDataImpl> c = static_pointer_cast<CharacterDataImpl>(m_startContainer->cloneNode(true));
+                c->deleteData(m_endOffset, c->length() - m_endOffset, exceptioncode);
+                c->deleteData(0, m_startOffset, exceptioncode);
+                fragment->appendChild(c.release(), exceptioncode);
             }
             if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS)
-                static_cast<CharacterDataImpl*>(m_startContainer)->deleteData(m_startOffset,m_endOffset-m_startOffset,exceptioncode);
+                static_cast<CharacterDataImpl*>(m_startContainer.get())->deleteData(m_startOffset,m_endOffset-m_startOffset,exceptioncode);
         }
         else if (m_startContainer->nodeType() == Node::PROCESSING_INSTRUCTION_NODE) {
             // ### operate just on data ?
@@ -481,18 +452,15 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
                     fragment->appendChild(n,exceptioncode); // will remove n from it's parent
                 else if (action == CLONE_CONTENTS)
                     fragment->appendChild(n->cloneNode(true),exceptioncode);
-                else {
-                    n->ref();
+                else
                     m_startContainer->removeChild(n,exceptioncode);
-                    n->deref();
-                }
                 n = next;
                 i++;
             }
         }
         if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS)
             collapse(true,exceptioncode);
-        return fragment;
+        return fragment.release();
     }
 
     // Complex case: Start and end containers are different.
@@ -521,13 +489,13 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
            m_startContainer->nodeType() == Node::COMMENT_NODE) {
 
             if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
-                PassRefPtr<CharacterDataImpl> c = static_pointer_cast<CharacterDataImpl>(m_startContainer->cloneNode(true));
-                c->deleteData(0,m_startOffset,exceptioncode);
-                leftContents = c;
+                RefPtr<CharacterDataImpl> c = static_pointer_cast<CharacterDataImpl>(m_startContainer->cloneNode(true));
+                c->deleteData(0, m_startOffset, exceptioncode);
+                leftContents = c.release();
             }
             if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS)
-                static_cast<CharacterDataImpl*>(m_startContainer)->deleteData(
-                    m_startOffset,static_cast<CharacterDataImpl*>(m_startContainer)->length()-m_startOffset,exceptioncode);
+                static_cast<CharacterDataImpl*>(m_startContainer.get())->deleteData(
+                    m_startOffset, static_cast<CharacterDataImpl*>(m_startContainer.get())->length() - m_startOffset, exceptioncode);
         }
         else if (m_startContainer->nodeType() == Node::PROCESSING_INSTRUCTION_NODE) {
             // ### operate just on data ?
@@ -545,11 +513,8 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
                     leftContents->appendChild(n,exceptioncode); // will remove n from m_startContainer
                 else if (action == CLONE_CONTENTS)
                     leftContents->appendChild(n->cloneNode(true),exceptioncode);
-                else {
-                    n->ref();
+                else
                     m_startContainer->removeChild(n,exceptioncode);
-                    n->deref();
-                }
                 n = next;
             }
         }
@@ -570,11 +535,8 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
                     leftContents->appendChild(n,exceptioncode); // will remove n from leftParent
                 else if (action == CLONE_CONTENTS)
                     leftContents->appendChild(n->cloneNode(true),exceptioncode);
-                else {
-                    n->ref();
+                else
                     leftParent->removeChild(n,exceptioncode);
-                    n->deref();
-                }
             }
             n = leftParent->nextSibling();
         }
@@ -590,11 +552,11 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
 
             if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
                 RefPtr<CharacterDataImpl> c = static_pointer_cast<CharacterDataImpl>(m_endContainer->cloneNode(true));
-                c->deleteData(m_endOffset,static_cast<CharacterDataImpl*>(m_endContainer)->length()-m_endOffset,exceptioncode);
+                c->deleteData(m_endOffset, static_cast<CharacterDataImpl*>(m_endContainer.get())->length() - m_endOffset, exceptioncode);
                 rightContents = c;
             }
             if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS)
-                static_cast<CharacterDataImpl*>(m_endContainer)->deleteData(0,m_endOffset,exceptioncode);
+                static_cast<CharacterDataImpl*>(m_endContainer.get())->deleteData(0, m_endOffset, exceptioncode);
         }
         else if (m_startContainer->nodeType() == Node::PROCESSING_INSTRUCTION_NODE) {
             // ### operate just on data ?
@@ -640,12 +602,8 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
                     rightContents->insertBefore(n,rightContents->firstChild(),exceptioncode); // will remove n from it's parent
                 else if (action == CLONE_CONTENTS)
                     rightContents->insertBefore(n->cloneNode(true),rightContents->firstChild(),exceptioncode);
-                else {
-                    n->ref();
+                else
                     rightParent->removeChild(n,exceptioncode);
-                    n->deref();
-                }
-
             }
             n = rightParent->previousSibling();
         }
@@ -661,7 +619,7 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
             processStart = processStart->nextSibling();
     }
     else {
-        processStart = m_startContainer;
+        processStart = m_startContainer.get();
         while (processStart->parentNode() != cmnRoot)
             processStart = processStart->parentNode();
         processStart = processStart->nextSibling();
@@ -674,7 +632,7 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
             processEnd = processEnd->nextSibling();
     }
     else {
-        processEnd = m_endContainer;
+        processEnd = m_endContainer.get();
         while (processEnd->parentNode() != cmnRoot)
             processEnd = processEnd->parentNode();
     }
@@ -695,11 +653,8 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
                 fragment->appendChild(n,exceptioncode); // will remove from cmnRoot
             else if (action == CLONE_CONTENTS)
                 fragment->appendChild(n->cloneNode(true),exceptioncode);
-            else {
-                n->ref();
+            else
                 cmnRoot->removeChild(n,exceptioncode);
-                n->deref();
-            }
         }
     }
 
@@ -711,21 +666,21 @@ DocumentFragmentImpl *RangeImpl::processContents ( ActionType action, int &excep
         if (!partialStart && !partialEnd)
             collapse(true,exceptioncode);
         else if (partialStart) {
-            setStartContainer(partialStart->parentNode());
-            setEndContainer(partialStart->parentNode());
+            m_startContainer = partialStart->parentNode();
+            m_endContainer = partialStart->parentNode();
             m_startOffset = m_endOffset = partialStart->nodeIndex()+1;
         }
         else if (partialEnd) {
-            setStartContainer(partialEnd->parentNode());
-            setEndContainer(partialEnd->parentNode());
+            m_startContainer = partialEnd->parentNode();
+            m_endContainer = partialEnd->parentNode();
             m_startOffset = m_endOffset = partialEnd->nodeIndex();
         }
     }
-    return fragment;
+    return fragment.release();
 }
 
 
-DocumentFragmentImpl *RangeImpl::extractContents( int &exceptioncode )
+PassRefPtr<DocumentFragmentImpl> RangeImpl::extractContents( int &exceptioncode )
 {
     if (m_detached) {
         exceptioncode = DOMException::INVALID_STATE_ERR;
@@ -739,7 +694,7 @@ DocumentFragmentImpl *RangeImpl::extractContents( int &exceptioncode )
     return processContents(EXTRACT_CONTENTS,exceptioncode);
 }
 
-DocumentFragmentImpl *RangeImpl::cloneContents( int &exceptioncode  )
+PassRefPtr<DocumentFragmentImpl> RangeImpl::cloneContents( int &exceptioncode  )
 {
     if (m_detached) {
         exceptioncode = DOMException::INVALID_STATE_ERR;
@@ -749,7 +704,7 @@ DocumentFragmentImpl *RangeImpl::cloneContents( int &exceptioncode  )
     return processContents(CLONE_CONTENTS,exceptioncode);
 }
 
-void RangeImpl::insertNode( NodeImpl *newNode, int &exceptioncode )
+void RangeImpl::insertNode(PassRefPtr<NodeImpl> newNode, int &exceptioncode )
 {
     if (m_detached) {
         exceptioncode = DOMException::INVALID_STATE_ERR;
@@ -786,7 +741,7 @@ void RangeImpl::insertNode( NodeImpl *newNode, int &exceptioncode )
     if (m_startContainer->nodeType() == Node::TEXT_NODE)
         checkAgainst = m_startContainer->parentNode();
     else
-        checkAgainst = m_startContainer;
+        checkAgainst = m_startContainer.get();
 
     if (newNode->nodeType() == Node::DOCUMENT_FRAGMENT_NODE) {
         // check each child node, not the DocumentFragment itself
@@ -805,7 +760,7 @@ void RangeImpl::insertNode( NodeImpl *newNode, int &exceptioncode )
         }
     }
 
-    for (NodeImpl *n = m_startContainer; n; n = n->parentNode()) {
+    for (NodeImpl *n = m_startContainer.get(); n; n = n->parentNode()) {
         if (n == newNode) {
             exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
             return;
@@ -824,7 +779,7 @@ void RangeImpl::insertNode( NodeImpl *newNode, int &exceptioncode )
     if( m_startContainer->nodeType() == Node::TEXT_NODE ||
         m_startContainer->nodeType() == Node::CDATA_SECTION_NODE )
     {
-        TextImpl *newText = static_cast<TextImpl*>(m_startContainer)->splitText(m_startOffset,exceptioncode);
+        TextImpl *newText = static_cast<TextImpl*>(m_startContainer.get())->splitText(m_startOffset,exceptioncode);
         if (exceptioncode)
             return;
         m_startContainer->parentNode()->insertBefore( newNode, newText, exceptioncode );
@@ -874,26 +829,25 @@ DOMString RangeImpl::text() const
     return khtml::plainText(const_cast<RangeImpl *>(this));
 }
 
-DocumentFragmentImpl *RangeImpl::createContextualFragment(const DOMString &html, int &exceptioncode) const
+PassRefPtr<DocumentFragmentImpl> RangeImpl::createContextualFragment(const DOMString &html, int &exceptioncode) const
 {
-   if (m_detached) {
+    if (m_detached) {
         exceptioncode = DOMException::INVALID_STATE_ERR;
-        return NULL;
+        return 0;
     }
 
     if (! m_startContainer->isHTMLElement()) {
         exceptioncode = DOMException::NOT_SUPPORTED_ERR;
-        return NULL;
+        return 0;
     }
 
-    HTMLElementImpl *e = static_cast<HTMLElementImpl *>(m_startContainer);
-    DocumentFragmentImpl *fragment = e->createContextualFragment(html);
+    RefPtr<DocumentFragmentImpl> fragment = static_cast<HTMLElementImpl*>(m_startContainer.get())->createContextualFragment(html);
     if (!fragment) {
         exceptioncode = DOMException::NOT_SUPPORTED_ERR;
-        return NULL;
+        return 0;
     }
 
-    return fragment;
+    return fragment.release();
 }
 
 
@@ -904,11 +858,7 @@ void RangeImpl::detach( int &exceptioncode )
         return;
     }
 
-    if (m_startContainer)
-        m_startContainer->deref();
     m_startContainer = 0;
-    if (m_endContainer)
-        m_endContainer->deref();
     m_endContainer = 0;
     m_detached = true;
 }
@@ -972,14 +922,14 @@ void RangeImpl::checkNodeBA( NodeImpl *n, int &exceptioncode ) const
 
 }
 
-RangeImpl *RangeImpl::cloneRange(int &exceptioncode) const
+PassRefPtr<RangeImpl> RangeImpl::cloneRange(int &exceptioncode) const
 {
     if (m_detached) {
         exceptioncode = DOMException::INVALID_STATE_ERR;
         return 0;
     }
 
-    return new RangeImpl(m_ownerDocument.get(), m_startContainer, m_startOffset, m_endContainer, m_endOffset);
+    return new RangeImpl(m_ownerDocument.get(), m_startContainer.get(), m_startOffset, m_endContainer.get(), m_endOffset);
 }
 
 void RangeImpl::setStartAfter( NodeImpl *refNode, int &exceptioncode )
@@ -1122,20 +1072,22 @@ void RangeImpl::selectNodeContents( NodeImpl *refNode, int &exceptioncode )
         }
     }
 
-    setStartContainer(refNode);
+    m_startContainer = refNode;
     m_startOffset = 0;
-    setEndContainer(refNode);
+    m_endContainer = refNode;
     m_endOffset = refNode->childNodeCount();
 }
 
-void RangeImpl::surroundContents( NodeImpl *newParent, int &exceptioncode )
+void RangeImpl::surroundContents(PassRefPtr<NodeImpl> passNewParent, int &exceptioncode )
 {
+    RefPtr<NodeImpl> newParent = passNewParent;
+
     if (m_detached) {
         exceptioncode = DOMException::INVALID_STATE_ERR;
         return;
     }
 
-    if( !newParent ) {
+    if (!newParent) {
         exceptioncode = DOMException::NOT_FOUND_ERR;
         return;
     }
@@ -1174,7 +1126,7 @@ void RangeImpl::surroundContents( NodeImpl *newParent, int &exceptioncode )
         return;
     }
 
-    for (NodeImpl *n = m_startContainer; n; n = n->parentNode()) {
+    for (NodeImpl *n = m_startContainer.get(); n; n = n->parentNode()) {
         if (n == newParent) {
             exceptioncode = DOMException::HIERARCHY_REQUEST_ERR;
             return;
@@ -1197,23 +1149,21 @@ void RangeImpl::surroundContents( NodeImpl *newParent, int &exceptioncode )
         }
     }
 
-    while (NodeImpl *n = newParent->firstChild()) {
-        n->ref();
-        newParent->removeChild(n,exceptioncode);
-        n->deref();
+    while (NodeImpl* n = newParent->firstChild()) {
+        newParent->removeChild(n, exceptioncode);
         if (exceptioncode)
             return;
     }
-    DocumentFragmentImpl *fragment = extractContents(exceptioncode);
+    RefPtr<DocumentFragmentImpl> fragment = extractContents(exceptioncode);
     if (exceptioncode)
         return;
-    insertNode( newParent, exceptioncode );
+    insertNode(newParent, exceptioncode);
     if (exceptioncode)
         return;
-    newParent->appendChild( fragment, exceptioncode );
+    newParent->appendChild(fragment.release(), exceptioncode);
     if (exceptioncode)
         return;
-    selectNode( newParent, exceptioncode );
+    selectNode(newParent.get(), exceptioncode);
 }
 
 void RangeImpl::setStartBefore( NodeImpl *refNode, int &exceptioncode )
@@ -1240,30 +1190,6 @@ void RangeImpl::setStartBefore( NodeImpl *refNode, int &exceptioncode )
     setStart( refNode->parentNode(), refNode->nodeIndex(), exceptioncode );
 }
 
-void RangeImpl::setStartContainer(NodeImpl *_startContainer)
-{
-    if (m_startContainer == _startContainer)
-        return;
-
-    if (m_startContainer)
-        m_startContainer->deref();
-    m_startContainer = _startContainer;
-    if (m_startContainer)
-        m_startContainer->ref();
-}
-
-void RangeImpl::setEndContainer(NodeImpl *_endContainer)
-{
-    if (m_endContainer == _endContainer)
-        return;
-
-    if (m_endContainer)
-        m_endContainer->deref();
-    m_endContainer = _endContainer;
-    if (m_endContainer)
-        m_endContainer->ref();
-}
-
 void RangeImpl::checkDeleteExtract(int &exceptioncode)
 {
     NodeImpl *pastEnd = pastEndNode();
@@ -1287,11 +1213,11 @@ void RangeImpl::checkDeleteExtract(int &exceptioncode)
 bool RangeImpl::containedByReadOnly() const
 {
     NodeImpl *n;
-    for (n = m_startContainer; n; n = n->parentNode()) {
+    for (n = m_startContainer.get(); n; n = n->parentNode()) {
         if (n->isReadOnly())
             return true;
     }
-    for (n = m_endContainer; n; n = n->parentNode()) {
+    for (n = m_endContainer.get(); n; n = n->parentNode()) {
         if (n->isReadOnly())
             return true;
     }
@@ -1300,12 +1226,12 @@ bool RangeImpl::containedByReadOnly() const
 
 Position RangeImpl::startPosition() const
 {
-    return Position(m_startContainer, m_startOffset);
+    return Position(m_startContainer.get(), m_startOffset);
 }
 
 Position RangeImpl::endPosition() const
 {
-    return Position(m_endContainer, m_endOffset);
+    return Position(m_endContainer.get(), m_endOffset);
 }
 
 NodeImpl *RangeImpl::startNode() const
@@ -1313,12 +1239,12 @@ NodeImpl *RangeImpl::startNode() const
     if (!m_startContainer)
         return 0;
     if (offsetInCharacters(m_startContainer->nodeType()))
-        return m_startContainer;
+        return m_startContainer.get();
     NodeImpl *child = m_startContainer->childNode(m_startOffset);
     if (child)
         return child;
     if (m_startOffset == 0)
-        return m_startContainer;
+        return m_startContainer.get();
     return m_startContainer->traverseNextSibling();
 }
 
@@ -1329,7 +1255,7 @@ Position RangeImpl::editingStartPosition() const
     // It is important to skip certain irrelevant content at the start of the selection, so we do not wind up 
     // with a spurious "mixed" style.
     
-    VisiblePosition visiblePosition(m_startContainer, m_startOffset, VP_DEFAULT_AFFINITY);
+    VisiblePosition visiblePosition(m_startContainer.get(), m_startOffset, VP_DEFAULT_AFFINITY);
     if (visiblePosition.isNull())
         return Position();
 
@@ -1409,12 +1335,12 @@ bool operator==(const RangeImpl &a, const RangeImpl &b)
         && a.endOffset(exception) == b.endOffset(exception);
 }
 
-RefPtr<RangeImpl> rangeOfContents(NodeImpl *node)
+PassRefPtr<RangeImpl> rangeOfContents(NodeImpl *node)
 {
-    RangeImpl *range = new RangeImpl(node->getDocument());
+    RefPtr<RangeImpl> range = new RangeImpl(node->getDocument());
     int exception = 0;
     range->selectNodeContents(node, exception);
-    return RefPtr<RangeImpl>(range);
+    return range.release();
 }
 
 }
index dfa548bc8f8b24c62c9dfc2260f452396bc194f0..513d7bbf186adc6bdf910f01ca1b93dd9aee94f5 100644 (file)
@@ -5,7 +5,7 @@
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
- * Copyright (C) 2004 Apple Computer, Inc.
+ * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  *
  */
 
-#ifndef _DOM2_RangeImpl_h_
-#define _DOM2_RangeImpl_h_
+#ifndef DOM2_RangeImpl_h_
+#define DOM2_RangeImpl_h_
 
-#include "dom/dom2_range.h"
+#include "dom2_range.h"
 #include "Shared.h"
-#include "DocPtr.h"
+#include <kxmlcore/RefPtr.h>
 
-namespace DOM {
+namespace KXMLCore {
+    template <typename T> class PassRefPtr;
+}
+using KXMLCore::PassRefPtr;
+
+namespace WebCore {
+
+typedef int ExceptionCode;
 
 class DocumentFragmentImpl;
-class DOMString;
+class DocumentImpl;
 class NodeImpl;
 class Position;
+class String;
 
 class RangeImpl : public Shared<RangeImpl>
 {
-    friend class DocumentImpl;
 public:
-    RangeImpl(DocumentImpl *_ownerDocument);
-    RangeImpl(DocumentImpl *_ownerDocument,
-              NodeImpl *_startContainer, int _startOffset,
-              NodeImpl *_endContainer, int _endOffset);
-
-    ~RangeImpl();
-
-    NodeImpl *startContainer(int &exceptioncode) const;
-    int startOffset(int &exceptioncode) const;
-    NodeImpl *endContainer(int &exceptioncode) const;
-    int endOffset(int &exceptioncode) const;
-    bool collapsed(int &exceptioncode) const;
-
-    NodeImpl *commonAncestorContainer(int &exceptioncode) const;
-    static NodeImpl *commonAncestorContainer(NodeImpl *containerA, NodeImpl *containerB);
-    void setStart ( NodeImpl *refNode, int offset, int &exceptioncode );
-    void setEnd ( NodeImpl *refNode, int offset, int &exceptioncode );
-    void collapse ( bool toStart, int &exceptioncode );
-    short compareBoundaryPoints ( Range::CompareHow how, const RangeImpl *sourceRange, int &exceptioncode ) const;
-    static short compareBoundaryPoints ( NodeImpl *containerA, int offsetA, NodeImpl *containerB, int offsetB );
-    static short compareBoundaryPoints ( const Position &a, const Position &b );
-    bool boundaryPointsValid (  ) const;
-    void deleteContents ( int &exceptioncode );
-    DocumentFragmentImpl *extractContents ( int &exceptioncode );
-    DocumentFragmentImpl *cloneContents ( int &exceptioncode );
-    void insertNode( NodeImpl *newNode, int &exceptioncode );
-    DOMString toString ( int &exceptioncode ) const;
-    DOMString toHTML() const;
-    DOMString text() const;
-
-    DocumentFragmentImpl *createContextualFragment(const DOMString &html, int &exceptioncode) const;
-    
-    void detach ( int &exceptioncode );
+    RangeImpl(DocumentImpl*);
+    RangeImpl(DocumentImpl*, NodeImpl* startContainer, int startOffset, NodeImpl* endContainer, int endOffset);
+
+    NodeImpl* startContainer(ExceptionCode&) const;
+    int startOffset(ExceptionCode&) const;
+    NodeImpl* endContainer(ExceptionCode&) const;
+    int endOffset(ExceptionCode&) const;
+    bool collapsed(ExceptionCode&) const;
+
+    NodeImpl* commonAncestorContainer(ExceptionCode&) const;
+    static NodeImpl* commonAncestorContainer(NodeImpl* containerA, NodeImpl* containerB);
+    void setStart(NodeImpl* container, int offset, ExceptionCode&);
+    void setEnd(NodeImpl* container, int offset, ExceptionCode&);
+    void collapse(bool toStart, ExceptionCode&);
+    short compareBoundaryPoints(Range::CompareHow how, const RangeImpl* sourceRange, ExceptionCode&) const;
+    static short compareBoundaryPoints(NodeImpl* containerA, int offsetA, NodeImpl* containerB, int offsetB );
+    static short compareBoundaryPoints(const Position&, const Position&);
+    bool boundaryPointsValid() const;
+    void deleteContents(ExceptionCode&);
+    PassRefPtr<DocumentFragmentImpl> extractContents(ExceptionCode&);
+    PassRefPtr<DocumentFragmentImpl> cloneContents(ExceptionCode&);
+    void insertNode(PassRefPtr<NodeImpl>, ExceptionCode&);
+    String toString(ExceptionCode&) const;
+    String toHTML() const;
+    String text() const;
+
+    PassRefPtr<DocumentFragmentImpl> createContextualFragment(const String& html, ExceptionCode&) const;
+
+    void detach(ExceptionCode&);
     bool isDetached() const;
-    RangeImpl *cloneRange(int &exceptioncode) const;
+    PassRefPtr<RangeImpl> cloneRange(ExceptionCode&) const;
 
-    void setStartAfter( NodeImpl *refNode, int &exceptioncode );
-    void setEndBefore( NodeImpl *refNode, int &exceptioncode );
-    void setEndAfter( NodeImpl *refNode, int &exceptioncode );
-    void selectNode( NodeImpl *refNode, int &exceptioncode );
-    void selectNodeContents( NodeImpl *refNode, int &exceptioncode );
-    void surroundContents( NodeImpl *newParent, int &exceptioncode );
-    void setStartBefore( NodeImpl *refNode, int &exceptioncode );
+    void setStartAfter(NodeImpl*, ExceptionCode&);
+    void setEndBefore(NodeImpl*, ExceptionCode&);
+    void setEndAfter(NodeImpl*, ExceptionCode&);
+    void selectNode(NodeImpl*, ExceptionCode&);
+    void selectNodeContents(NodeImpl*, ExceptionCode&);
+    void surroundContents(PassRefPtr<NodeImpl>, ExceptionCode&);
+    void setStartBefore(NodeImpl*, ExceptionCode&);
 
     enum ActionType {
         DELETE_CONTENTS,
         EXTRACT_CONTENTS,
         CLONE_CONTENTS
     };
-    DocumentFragmentImpl *processContents ( ActionType action, int &exceptioncode );
+    PassRefPtr<DocumentFragmentImpl> processContents(ActionType, ExceptionCode&);
 
     Position startPosition() const;
     Position endPosition() const;
 
-    NodeImpl *startNode() const;
-    NodeImpl *pastEndNode() const;
+    NodeImplstartNode() const;
+    NodeImplpastEndNode() const;
 
     Position editingStartPosition() const;
 
-#ifndef NDEBUG
+#if !NDEBUG
     void formatForDebugger(char *buffer, unsigned length) const;
 #endif
 
-protected:
-    // FIXME - this could be a full-on RefPtr in principle...
-    DocPtr<DocumentImpl> m_ownerDocument;
-    NodeImpl *m_startContainer;
+private:
+    RefPtr<DocumentImpl> m_ownerDocument;
+    RefPtr<NodeImpl> m_startContainer;
     unsigned m_startOffset;
-    NodeImpl *m_endContainer;
+    RefPtr<NodeImpl> m_endContainer;
     unsigned m_endOffset;
     bool m_detached;
 
-private:
-    void checkNodeWOffset( NodeImpl *n, int offset, int &exceptioncode) const;
-    void checkNodeBA( NodeImpl *n, int &exceptioncode ) const;
-    void setStartContainer(NodeImpl *_startContainer);
-    void setEndContainer(NodeImpl *_endContainer);
-    void checkDeleteExtract(int &exceptioncode);
+    void checkNodeWOffset(NodeImpl*, int offset, ExceptionCode&) const;
+    void checkNodeBA(NodeImpl*, ExceptionCode&) const;
+    void checkDeleteExtract(ExceptionCode&);
     bool containedByReadOnly() const;
 };
 
-RefPtr<RangeImpl> rangeOfContents(NodeImpl *node);
+PassRefPtr<RangeImpl> rangeOfContents(NodeImpl*);
 
-bool operator==(const RangeImpl &, const RangeImpl &);
-inline bool operator!=(const RangeImpl &a, const RangeImpl &b) { return !(a == b); }
+bool operator==(const RangeImpl&, const RangeImpl&);
+inline bool operator!=(const RangeImpl& a, const RangeImpl& b) { return !(a == b); }
 
 } // namespace
 
index e4bc1c07b19777e3d09f47c4ea1979d094e5123c..c36be00c827ebc716f0dd6fff804d0e9afbd882d 100644 (file)
@@ -96,7 +96,6 @@ AttrImpl::AttrImpl(ElementImpl* element, DocumentImpl* docPtr, AttributeImpl* a)
 {
     assert(!m_attribute->m_impl);
     m_attribute->m_impl = this;
-    m_attribute->ref();
     m_specified = true;
 }
 
@@ -104,7 +103,6 @@ AttrImpl::~AttrImpl()
 {
     assert(m_attribute->m_impl == this);
     m_attribute->m_impl = 0;
-    m_attribute->deref();
 }
 
 void AttrImpl::createTextChild()
@@ -183,7 +181,7 @@ void AttrImpl::setValue( const DOMString &v, int &exceptioncode )
     
     m_attribute->setValue(v.impl());
     if (m_element)
-        m_element->attributeChanged(m_attribute);
+        m_element->attributeChanged(m_attribute.get());
 }
 
 void AttrImpl::setNodeValue( const DOMString &v, int &exceptioncode )
@@ -201,21 +199,12 @@ PassRefPtr<NodeImpl> AttrImpl::cloneNode(bool /*deep*/)
 }
 
 // DOM Section 1.1.1
-bool AttrImpl::childAllowed( NodeImpl *newChild )
-{
-    if(!newChild)
-        return false;
-
-    return childTypeAllowed(newChild->nodeType());
-}
-
-bool AttrImpl::childTypeAllowed( unsigned short type )
+bool AttrImpl::childTypeAllowed(unsigned short type)
 {
     switch (type) {
         case Node::TEXT_NODE:
         case Node::ENTITY_REFERENCE_NODE:
             return true;
-            break;
         default:
             return false;
     }
@@ -238,7 +227,7 @@ void AttrImpl::childrenChanged()
     
     m_attribute->setValue(val.impl());
     if (m_element)
-        m_element->attributeChanged(m_attribute);
+        m_element->attributeChanged(m_attribute.get());
 }
 
 DOMString AttrImpl::toString() const
@@ -264,16 +253,6 @@ DOMString AttrImpl::toString() const
     return result;
 }
 
-DOMString AttrImpl::name() const
-{
-    return m_attribute->name().toString();
-}
-
-DOMString AttrImpl::value() const
-{
-    return m_attribute->value();
-}
-
 // -------------------------------------------------------------------------
 
 #ifndef NDEBUG
@@ -792,7 +771,7 @@ PassRefPtr<AttrImpl> ElementImpl::removeAttributeNode(AttrImpl *attr, int &excep
     if (!attrs)
         return 0;
 
-    return static_pointer_cast<AttrImpl>(attrs->removeNamedItem(attr->m_attribute->name(), exception));
+    return static_pointer_cast<AttrImpl>(attrs->removeNamedItem(attr->qualifiedName(), exception));
 }
 
 void ElementImpl::setAttributeNS(const DOMString &namespaceURI, const DOMString &qualifiedName, const DOMString &value, int &exception)
@@ -1011,8 +990,7 @@ AttributeImpl* NamedAttrMapImpl::getAttributeItem(const QualifiedName& name) con
 void NamedAttrMapImpl::clearAttributes()
 {
     if (attrs) {
-        uint i;
-        for (i = 0; i < len; i++) {
+        for (unsigned i = 0; i < len; i++) {
             if (attrs[i]->m_impl)
                 attrs[i]->m_impl->m_element = 0;
             attrs[i]->deref();
@@ -1162,7 +1140,8 @@ bool NamedAttrMapImpl::mapsEquivalent(const NamedAttrMapImpl* otherMap) const
 
 // ------------------------------- Styled Element and Mapped Attribute Implementation
 
-CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl() {
+CSSMappedAttributeDeclarationImpl::~CSSMappedAttributeDeclarationImpl()
+{
     if (m_entryType != ePersistent)
         StyledElementImpl::removeMappedAttributeDecl(m_entryType, m_attrName, m_attrValue);
 }
@@ -1207,7 +1186,7 @@ void StyledElementImpl::updateStyleAttributeIfNeeded() const
 
 AttributeImpl* MappedAttributeImpl::clone(bool preserveDecl) const
 {
-    return new MappedAttributeImpl(m_name, m_value, preserveDecl ? m_styleDecl.get() : 0);
+    return new MappedAttributeImpl(name(), value(), preserveDecl ? m_styleDecl.get() : 0);
 }
 
 NamedMappedAttrMapImpl::NamedMappedAttrMapImpl(ElementImpl *e)
index 58c66e4dacb048e9a95cc833d6aa052584336224..b9540b7206f7e9af51f2fa8414885ea54704fa56 100644 (file)
@@ -5,7 +5,7 @@
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003 Apple Computer, Inc.
+ * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
 #include "NamedNodeMapImpl.h"
 #include "ContainerNodeImpl.h"
 #include "StringImpl.h"
-#include "Shared.h"
-#include "css/css_valueimpl.h"
+#include "css_valueimpl.h"
 #include "dom_qname.h"
+#include "dom_atomicstringlist.h"
 
-#ifdef __OBJC__
+#if __OBJC__
 #define id id_AVOID_KEYWORD
 #endif
 
-#include "dom_atomicstringlist.h"
-
 namespace khtml {
     class CSSStyleSelector;
 }
 
 namespace DOM {
 
-class AtomicStringList;
-class DocumentImpl;
 class CSSStyleDeclarationImpl;
 class ElementImpl;
 class NamedAttrMapImpl;
@@ -58,8 +54,7 @@ class AttrImpl;
 // the actual Attr (AttrImpl) with its value as textchild
 // is only allocated on demand by the DOM bindings.
 // Any use of AttrImpl inside khtml should be avoided.
- class AttributeImpl : public Shared<AttributeImpl>
-{
+class AttributeImpl : public Shared<AttributeImpl> {
     friend class NamedAttrMapImpl;
     friend class ElementImpl;
     friend class AttrImpl;
@@ -74,7 +69,7 @@ public:
         : m_name(nullAtom, name, nullAtom), m_value(value), m_impl(0)
     {}
 
-    virtual ~AttributeImpl() {}
+    virtual ~AttributeImpl() { }
     
     const AtomicString& value() const { return m_value; }
     const AtomicString& prefix() const { return m_name.prefix(); }
@@ -98,7 +93,6 @@ private:
     void setValue(const AtomicString& value) { m_value = value; }
     void setPrefix(const AtomicString& prefix) { m_name.setPrefix(prefix); }
 
-protected:
     QualifiedName m_name;
     AtomicString m_value;
     AttrImpl* m_impl;
@@ -109,65 +103,62 @@ protected:
 // is to dynamically allocate a textchild and store the
 // resulting nodevalue in the AttributeImpl upon
 // destruction. however, this is not yet implemented.
-class AttrImpl : public ContainerNodeImpl
-{
-    friend class ElementImpl;
+class AttrImpl : public ContainerNodeImpl {
     friend class NamedAttrMapImpl;
 
 public:
-    AttrImpl(ElementImpl* element, DocumentImpl* doc, AttributeImpl* a);
+    AttrImpl(ElementImpl*, DocumentImpl*, AttributeImpl*);
     ~AttrImpl();
 
-    // Call this after calling the constructor so the 
-    // AttrImpl node isn't floating when we append the text node
+    // Call this after calling the constructor so the
+    // AttrImpl node isn't floating when we append the text node.
     void createTextChild();
     
     // DOM methods & attributes for Attr
-    DOMString name() const;
+    DOMString name() const { return qualifiedName().toString(); }
     bool specified() const { return m_specified; }
     ElementImpl* ownerElement() const { return m_element; }
-    AttributeImpl* attrImpl() const { return m_attribute; }
 
-    DOMString value() const;
-    void setValue( const DOMString &v, int &exceptioncode );
+    DOMString value() const { return m_attribute->value(); }
+    void setValue(const DOMString&, ExceptionCode&);
 
-    // DOM methods overridden from  parent classes
+    // DOM methods overridden from parent classes
     virtual DOMString nodeName() const;
     virtual unsigned short nodeType() const;
     virtual const AtomicString& localName() const;
     virtual const AtomicString& namespaceURI() const;
     virtual const AtomicString& prefix() const;
-    virtual void setPrefix(const AtomicString &_prefix, int &exceptioncode);
+    virtual void setPrefix(const AtomicString&, ExceptionCode&);
 
     virtual DOMString nodeValue() const;
-    virtual void setNodeValue( const DOMString &, int &exceptioncode );
+    virtual void setNodeValue(const DOMString&, ExceptionCode&);
     virtual PassRefPtr<NodeImpl> cloneNode(bool deep);
 
     // Other methods (not part of DOM)
     virtual bool isAttributeNode() const { return true; }
-    virtual bool childAllowed( NodeImpl *newChild );
-    virtual bool childTypeAllowed( unsigned short type );
+    virtual bool childTypeAllowed(unsigned short type);
 
     virtual void childrenChanged();
     virtual DOMString toString() const;
 
+    AttributeImpl* attrImpl() const { return m_attribute.get(); }
+    const QualifiedName& qualifiedName() const { return m_attribute->name(); }
+
     // An extension to get presentational information for attributes.
     CSSStyleDeclarationImpl* style() { return m_attribute->style(); }
-    
-protected:
+
+private:
     ElementImpl* m_element;
-    AttributeImpl* m_attribute;
+    RefPtr<AttributeImpl> m_attribute;
     int m_ignoreChildrenChanged;
 };
 
-
-class ElementImpl : public ContainerNodeImpl
-{
+class ElementImpl : public ContainerNodeImpl {
     friend class DocumentImpl;
     friend class NamedAttrMapImpl;
     friend class AttrImpl;
     friend class NodeImpl;
-    friend class khtml::CSSStyleSelector;
+    friend class CSSStyleSelector;
 public:
     ElementImpl(const QualifiedName& tagName, DocumentImpl *doc);
     ~ElementImpl();
@@ -243,8 +234,8 @@ public:
     virtual QString state() { return QString::null; }
 
     virtual void attach();
-    virtual khtml::RenderStyle *styleForRenderer(khtml::RenderObject *parent);
-    virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
+    virtual RenderStyle *styleForRenderer(RenderObject *parent);
+    virtual RenderObject *createRenderer(RenderArena *, RenderStyle *);
     virtual void recalcStyle( StyleChange = NoChange );
 
     virtual void mouseEventHandler( MouseEvent * /*ev*/, bool /*inside*/ ) {};
@@ -255,7 +246,7 @@ public:
     void dispatchAttrRemovalEvent(AttributeImpl *attr);
     void dispatchAttrAdditionEvent(AttributeImpl *attr);
 
-    virtual void accessKeyAction(bool sendToAnyEvent) { };
+    virtual void accessKeyAction(bool sendToAnyEvent) { }
 
     virtual DOMString toString() const;
 
@@ -264,11 +255,8 @@ public:
     virtual void focus();
     void blur();
     
-#ifndef NDEBUG
+#if !NDEBUG
     virtual void dump(QTextStream *stream, QString ind = "") const;
-#endif
-
-#ifndef NDEBUG
     virtual void formatForDebugger(char *buffer, unsigned length) const;
 #endif
 
@@ -287,8 +275,7 @@ protected: // member variables
 };
 
 // the map of attributes of an element
-class NamedAttrMapImpl : public NamedNodeMapImpl
-{
+class NamedAttrMapImpl : public NamedNodeMapImpl {
     friend class ElementImpl;
 public:
     NamedAttrMapImpl(ElementImpl *e);
@@ -338,7 +325,6 @@ protected:
     virtual void clearAttributes();
     void detachFromElement();
 
-protected:
     ElementImpl *element;
     AttributeImpl **attrs;
     uint len;
@@ -349,8 +335,7 @@ protected:
 enum MappedAttributeEntry { eNone, eUniversal, ePersistent, eReplaced, eBlock, eHR, eUnorderedList, eListItem,
     eTable, eCell, eCaption, eBDO, ePre, eLastEntry };
 
-class CSSMappedAttributeDeclarationImpl : public CSSMutableStyleDeclarationImpl
-{
+class CSSMappedAttributeDeclarationImpl : public CSSMutableStyleDeclarationImpl {
 public:
     CSSMappedAttributeDeclarationImpl(CSSRuleImpl *parentRule)
     : CSSMutableStyleDeclarationImpl(parentRule), m_entryType(eNone), m_attrName(anyQName())
@@ -438,7 +423,7 @@ public:
     void addCSSLength(MappedAttributeImpl* attr, int id, const DOMString &value);
     void addCSSProperty(MappedAttributeImpl* attr, int id, const DOMString &value);
     void addCSSProperty(MappedAttributeImpl* attr, int id, int value);
-    void addCSSStringProperty(MappedAttributeImpl* attr, int id, const DOMString &value, DOM::CSSPrimitiveValue::UnitTypes = DOM::CSSPrimitiveValue::CSS_STRING);
+    void addCSSStringProperty(MappedAttributeImpl* attr, int id, const DOMString &value, CSSPrimitiveValue::UnitTypes = CSSPrimitiveValue::CSS_STRING);
     void addCSSImageProperty(MappedAttributeImpl* attr, int id, const DOMString &URL);
     void addCSSColor(MappedAttributeImpl* attr, int id, const DOMString &c);
     void createMappedDecl(MappedAttributeImpl* attr);
@@ -469,7 +454,7 @@ protected:
     mutable bool m_synchronizingStyleAttribute : 1;
 };
 
-}; //namespace
+} //namespace
 
 #undef id
 
index 5f3c9a36cea6dd15cf164322b84e31f6590d56e3..2cfe5a6b39cf1727d06e6a52a1c54e153ed532bc 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 #include "config.h"
 #include "dom_position.h"
 
-#include <QString.h>
-
+#include "DocumentImpl.h"
+#include "InlineTextBox.h"
+#include "KWQLogging.h"
+#include "QString.h"
+#include "RenderBlock.h"
 #include "css_computedstyle.h"
 #include "css_valueimpl.h"
-#include "dom_elementimpl.h"
 #include "dom2_range.h"
 #include "dom2_rangeimpl.h"
 #include "dom2_viewsimpl.h"
+#include "dom_elementimpl.h"
 #include "helper.h"
 #include "htmlediting.h"
-#include "text_affinity.h"
-#include "visible_position.h"
-#include "visible_units.h"
-#include "RenderBlock.h"
+#include "htmlnames.h"
 #include "render_flow.h"
 #include "render_line.h"
 #include "render_style.h"
-#include "InlineTextBox.h"
+#include "text_affinity.h"
+#include "visible_position.h"
 #include "visible_text.h"
-#include "htmlnames.h"
-
+#include "visible_units.h"
 #include <kxmlcore/Assertions.h>
-#include "KWQLogging.h"
-
-using khtml::EAffinity;
-using khtml::InlineBox;
-using khtml::InlineTextBox;
-using khtml::isAtomicNode;
-using khtml::isCollapsibleWhitespace;
-using khtml::maxDeepOffset;
-using khtml::RenderBlock;
-using khtml::RenderFlow;
-using khtml::RenderObject;
-using khtml::RenderText;
-using khtml::RootInlineBox;
-using khtml::VISIBLE;
-using khtml::VisiblePosition;
-
-namespace DOM {
+  
+namespace WebCore {
 
 using namespace HTMLNames;
 
@@ -723,28 +708,25 @@ void Position::debugPosition(const char *msg) const
         fprintf(stderr, "Position [%s]: %s [%p] at %d\n", msg, node()->nodeName().qstring().latin1(), node(), offset());
 }
 
-#ifndef NDEBUG
-#define FormatBufferSize 1024
+#if !NDEBUG
+
 void Position::formatForDebugger(char *buffer, unsigned length) const
 {
-    DOMString result;
-    DOMString s;
+    String result;
     
     if (isNull()) {
         result = "<null>";
-    }
-    else {
-        char s[FormatBufferSize];
+    } else {
+        char s[1024];
         result += "offset ";
         result += QString::number(m_offset);
         result += " of ";
-        m_node->formatForDebugger(s, FormatBufferSize);
+        m_node->formatForDebugger(s, sizeof(s));
         result += s;
     }
           
     strncpy(buffer, result.qstring().latin1(), length - 1);
 }
-#undef FormatBufferSize
 
 void Position::showTree() const
 {
@@ -762,8 +744,8 @@ void showTree(const Position *pos)
     if (pos)
         pos->showTree();
 }
-#endif
 
+#endif
 
 Position startPosition(const RangeImpl *r)
 {
@@ -781,4 +763,4 @@ Position endPosition(const RangeImpl *r)
     return Position(r->endContainer(exceptionCode), r->endOffset(exceptionCode));
 }
 
-} // namespace DOM
+} // namespace WebCore
index 7d2e9c2dd2fe51041c03b914dc3933e5a0ed18b4..d62affecd94b196669dfd278ecbfb5e19862990f 100644 (file)
 #include "CachedXSLStyleSheet.h"
 #include "DocLoader.h"
 #include "DocumentImpl.h"
-#include "css/css_stylesheetimpl.h"
-#include "dom/dom_exception.h"
-#include "dom_node.h"
 #include "StringImpl.h"
+#include "css_stylesheetimpl.h"
+#include "dom_exception.h"
+#include "dom_node.h"
 #include "xml_tokenizer.h"
 
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
 #include "xsl_stylesheetimpl.h"
 #endif
 
@@ -139,12 +139,12 @@ unsigned short EntityReferenceImpl::nodeType() const
 
 PassRefPtr<NodeImpl> EntityReferenceImpl::cloneNode(bool deep)
 {
-    PassRefPtr<EntityReferenceImpl> clone = new EntityReferenceImpl(getDocument(), m_entityName.get());
+    RefPtr<EntityReferenceImpl> clone = new EntityReferenceImpl(getDocument(), m_entityName.get());
     // ### make sure children are readonly
     // ### since we are a reference, should we clone children anyway (even if not deep?)
     if (deep)
         cloneChildNodes(clone.get());
-    return clone;
+    return clone.release();
 }
 
 // DOM Section 1.1.1
@@ -214,7 +214,7 @@ bool NotationImpl::childTypeAllowed( unsigned short /*type*/ )
 ProcessingInstructionImpl::ProcessingInstructionImpl(DocumentImpl* doc)
     : ContainerNodeImpl(doc), m_cachedSheet(0), m_loading(false)
 {
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
     m_isXSL = false;
 #endif
 }
@@ -222,7 +222,7 @@ ProcessingInstructionImpl::ProcessingInstructionImpl(DocumentImpl* doc)
 ProcessingInstructionImpl::ProcessingInstructionImpl(DocumentImpl* doc, const DOMString& target, const DOMString& data)
     : ContainerNodeImpl(doc), m_target(target.impl()), m_data(data.impl()), m_cachedSheet(0), m_loading(false)
 {
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
     m_isXSL = false;
 #endif
 }
@@ -293,7 +293,7 @@ bool ProcessingInstructionImpl::checkStyleSheet()
             type = i->second;
         
         bool isCSS = type.isEmpty() || type == "text/css";
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
         m_isXSL = (type == "text/xml" || type == "text/xsl" || type == "application/xml" ||
                    type == "application/xhtml+xml" || type == "application/rss+xml" || type == "application/atom=xml");
         if (!isCSS && !m_isXSL)
@@ -302,7 +302,7 @@ bool ProcessingInstructionImpl::checkStyleSheet()
 #endif
             return true;
 
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
         if (m_isXSL)
             getDocument()->tokenizer()->setTransformSource(getDocument());
 #endif
@@ -312,14 +312,14 @@ bool ProcessingInstructionImpl::checkStyleSheet()
         if (href.length() > 1) {
             if (href[0] == '#') {
                 m_localHref = href.substring(1).impl();
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
                 // We need to make a synthetic XSLStyleSheetImpl that is embedded.  It needs to be able
                 // to kick off import/include loads that can hang off some parent sheet.
                 if (m_isXSL) {
-                    PassRefPtr<XSLStyleSheetImpl> localSheet = new XSLStyleSheetImpl(this, m_localHref.get(), true);
+                    RefPtr<XSLStyleSheetImpl> localSheet = new XSLStyleSheetImpl(this, m_localHref.get(), true);
                     localSheet->setDocument((xmlDocPtr)getDocument()->transformSource());
                     localSheet->loadChildSheets();
-                    m_sheet = localSheet;
+                    m_sheet = localSheet.release();
                     m_loading = false;
                 }                    
                 return !m_isXSL;
@@ -333,7 +333,7 @@ bool ProcessingInstructionImpl::checkStyleSheet()
                     m_loading = true;
                     getDocument()->addPendingSheet();
                     if (m_cachedSheet) m_cachedSheet->deref(this);
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
                     if (m_isXSL)
                         m_cachedSheet = getDocument()->docLoader()->requestXSLStyleSheet(getDocument()->completeURL(href));
                     else
@@ -341,7 +341,7 @@ bool ProcessingInstructionImpl::checkStyleSheet()
                     m_cachedSheet = getDocument()->docLoader()->requestStyleSheet(getDocument()->completeURL(href), QString::null);
                     if (m_cachedSheet)
                         m_cachedSheet->ref( this );
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
                     return !m_isXSL;
 #endif
                 }
@@ -370,7 +370,7 @@ void ProcessingInstructionImpl::sheetLoaded()
 
 void ProcessingInstructionImpl::setStyleSheet(const DOMString &url, const DOMString &sheet)
 {
-#ifdef KHTML_XSLT
+#if KHTML_XSLT
     if (m_isXSL)
         m_sheet = new XSLStyleSheetImpl(this, url);
     else
index 3cf12a5016110921c675e97fad8d9dd29f57fb36..1791e947592f9d2f2ce4e02ab78494f1e96a05ef 100644 (file)
@@ -2,7 +2,7 @@
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
- *  Copyright (C) 2003 Apple Computer, Inc.
+ *  Copyright (C) 2003, 2006 Apple Computer, Inc.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
 #include "config.h"
 #include "kjs_range.h"
 
-#include <kdebug.h>
-#include "dom/dom2_range.h"
 #include "DocumentFragmentImpl.h"
+#include "DocumentImpl.h"
+#include "dom2_range.h"
 #include "dom2_rangeimpl.h"
 
-using DOM::DOMString;
-using DOM::Range;
-using DOM::RangeImpl;
+using WebCore::String;
+using WebCore::Range;
+using WebCore::RangeImpl;
 
 #include "kjs_range.lut.h"
 
@@ -107,8 +107,7 @@ JSValue *DOMRange::getValueProperty(ExecState *exec, int token) const
   case CommonAncestorContainer:
     return getDOMNode(exec, range.commonAncestorContainer(exception));
   default:
-    kdWarning() << "Unhandled token in DOMRange::getValueProperty : " << token << endl;
-    return NULL;
+    return 0;
   }
 }
 
@@ -167,7 +166,7 @@ JSValue *DOMRangeProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, c
       range.surroundContents(toNode(args[0]), exception);
       break;
     case DOMRange::CloneRange:
-      result = getDOMRange(exec, range.cloneRange(exception));
+      result = getDOMRange(exec, range.cloneRange(exception).get());
       break;
     case DOMRange::ToString:
       result = jsStringOrNull(range.toString(exception));
index 6ffe9ad7a023a51872a23de9703c566f164d45a9..c81f1a87e365acf1fb2acdde24f00bd7e939808b 100644 (file)
@@ -108,7 +108,7 @@ PassRefPtr<RangeImpl> Selection::toRange() const
     }
 
     int exceptionCode = 0;
-    PassRefPtr<RangeImpl> result(new RangeImpl(s.node()->getDocument()));
+    RefPtr<RangeImpl> result(new RangeImpl(s.node()->getDocument()));
     result->setStart(s.node(), s.offset(), exceptionCode);
     if (exceptionCode) {
         ERROR("Exception setting Range start from Selection: %d", exceptionCode);
@@ -119,7 +119,7 @@ PassRefPtr<RangeImpl> Selection::toRange() const
         ERROR("Exception setting Range end from Selection: %d", exceptionCode);
         return 0;
     }
-    return result;
+    return result.release();
 }
 
 bool Selection::expandUsingGranularity(ETextGranularity granularity)
index d984e04c74a2cc0355e2ea02a68923d22111bf73..22cca922d1f64ea8833596f0977fb34333e3b597 100644 (file)
@@ -44,7 +44,6 @@ BreakBlockquoteCommand::BreakBlockquoteCommand(DocumentImpl *document)
 
 void BreakBlockquoteCommand::doApply()
 {
-    DOM::ElementImpl *breakNode;
     QPtrList<DOM::NodeImpl> ancestors;
     
     Selection selection = endingSelection();
@@ -71,8 +70,8 @@ void BreakBlockquoteCommand::doApply()
         return;
     
     // Insert a break after the top blockquote.
-    breakNode = createBreakElement(document());
-    insertNodeAfter(breakNode, topBlockquote);
+    RefPtr<ElementImpl> breakNode = createBreakElement(document());
+    insertNodeAfter(breakNode.get(), topBlockquote);
     
     if (!isLastVisiblePositionInNode(VisiblePosition(pos, affinity), topBlockquote)) {
         
@@ -110,7 +109,7 @@ void BreakBlockquoteCommand::doApply()
         
         // Insert a clone of the top blockquote after the break.
         RefPtr<NodeImpl> clonedBlockquote = topBlockquote->cloneNode(false);
-        insertNodeAfter(clonedBlockquote.get(), breakNode);
+        insertNodeAfter(clonedBlockquote.get(), breakNode.get());
         
         // Clone startNode's ancestors into the cloned blockquote.
         // On exiting this loop, clonedAncestor is the lowest ancestor
@@ -157,7 +156,7 @@ void BreakBlockquoteCommand::doApply()
     }
     
     // Put the selection right before the break.
-    setEndingSelection(Position(breakNode, 0), DOWNSTREAM);
+    setEndingSelection(Position(breakNode.get(), 0), DOWNSTREAM);
     rebalanceWhitespace();
 }
 
index 12b00f6c0e92810e2db8c3bccd094222fc949539..5c276c9921b85b0ff29909806f422d54f7365d88 100644 (file)
@@ -462,9 +462,9 @@ NodeImpl *CompositeEditCommand::appendBlockPlaceholder(NodeImpl *node)
     // Should assert isBlockFlow || isInlineFlow when deletion improves.  See 4244964.
     ASSERT(node->renderer());
 
-    NodeImpl *placeholder = createBlockPlaceholderElement(document());
-    appendNode(placeholder, node);
-    return placeholder;
+    RefPtr<NodeImpl> placeholder = createBlockPlaceholderElement(document());
+    appendNode(placeholder.get(), node);
+    return placeholder.get();
 }
 
 NodeImpl *CompositeEditCommand::insertBlockPlaceholder(const Position &pos)
@@ -475,9 +475,9 @@ NodeImpl *CompositeEditCommand::insertBlockPlaceholder(const Position &pos)
     // Should assert isBlockFlow || isInlineFlow when deletion improves.  See 4244964.
     ASSERT(pos.node()->renderer());
 
-    NodeImpl *placeholder = createBlockPlaceholderElement(document());
-    insertNodeAt(placeholder, pos.node(), pos.offset());
-    return placeholder;
+    RefPtr<NodeImpl> placeholder = createBlockPlaceholderElement(document());
+    insertNodeAt(placeholder.get(), pos.node(), pos.offset());
+    return placeholder.get();
 }
 
 NodeImpl *CompositeEditCommand::addBlockPlaceholderIfNeeded(NodeImpl *node)
@@ -570,32 +570,32 @@ void CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Posi
         }
     }
 
-    NodeImpl *newBlock = createDefaultParagraphElement(document());
+    RefPtr<NodeImpl> newBlock = createDefaultParagraphElement(document());
 
     NodeImpl *moveNode = paragraphStart.node();
     if (paragraphStart.offset() >= paragraphStart.node()->caretMaxOffset())
         moveNode = moveNode->traverseNextNode();
     NodeImpl *endNode = end.node();
     
-    insertNodeAt(newBlock, paragraphStart.node(), paragraphStart.offset());
+    insertNodeAt(newBlock.get(), paragraphStart.node(), paragraphStart.offset());
 
     while (moveNode && !moveNode->isBlockFlow()) {
         NodeImpl *next = moveNode->traverseNextSibling();
         removeNode(moveNode);
-        appendNode(moveNode, newBlock);
+        appendNode(moveNode, newBlock.get());
         if (moveNode == endNode)
             break;
         moveNode = next;
     }
 }
 
-ElementImpl *createBlockPlaceholderElement(DocumentImpl *document)
+PassRefPtr<ElementImpl> createBlockPlaceholderElement(DocumentImpl* document)
 {
     int exceptionCode = 0;
-    ElementImpl *breakNode = document->createElementNS(xhtmlNamespaceURI, "br", exceptionCode);
+    RefPtr<ElementImpl> breakNode = document->createElementNS(xhtmlNamespaceURI, "br", exceptionCode);
     ASSERT(exceptionCode == 0);
     breakNode->setAttribute(classAttr, blockPlaceholderClassString());
-    return breakNode;
+    return breakNode.release();
 }
 
 static const DOMString &blockPlaceholderClassString()
index 9dd6f768c6fcf87ea8a01ebaa415b8920a42cc67..f915ecd298f8e6789df11233b573cbf309583b2d 100644 (file)
@@ -249,10 +249,10 @@ void DeleteSelectionCommand::insertPlaceholderForAncestorBlockContent()
         
         if ((!afterEnd.isNull() && !inSameBlock(afterEnd, visibleEnd) && !inSameBlock(afterEnd, visibleStart)) ||
             (m_downstreamEnd == m_selectionToDelete.end() && isEndOfParagraph(visibleEnd) && !m_downstreamEnd.node()->hasTagName(brTag))) {
-            NodeImpl *block = createDefaultParagraphElement(document());
-            insertNodeBefore(block, m_upstreamStart.node());
-            addBlockPlaceholderIfNeeded(block);
-            m_endingPosition = Position(block, 0);
+            RefPtr<NodeImpl> block = createDefaultParagraphElement(document());
+            insertNodeBefore(block.get(), m_upstreamStart.node());
+            addBlockPlaceholderIfNeeded(block.get());
+            m_endingPosition = Position(block.get(), 0);
         }
     }
 }
@@ -569,7 +569,7 @@ void DeleteSelectionCommand::moveNodesAfterNode()
         removeNode(startBlock);
         updateLayout();
         if (refNode->renderer() && refNode->renderer()->inlineBox() && refNode->renderer()->inlineBox()->nextOnLineExists()) {
-            insertNodeAfter(createBreakElement(document()), refNode);
+            insertNodeAfter(createBreakElement(document()).get(), refNode);
         }
     }
 }
index 78b3e21bbeb210a91ffcbfd9b400c28f1b5a83c5..40f6089d4574ac27ce75e948c7713dbc4067ba7e 100644 (file)
@@ -26,7 +26,8 @@
 #include "config.h"
 #include "html_interchange.h"
 
-#include <QString.h>
+#include "DocumentImpl.h"
+#include "QString.h"
 #include "visible_text.h"
 
 using khtml::isCollapsibleWhitespace;
index 7f48e25751b9740b6e905d2cacf2a1ebd7d92314..551bccce7d340c68dc4a75d00c6d766d33a69ea0 100644 (file)
@@ -151,7 +151,7 @@ void rebalanceWhitespaceInTextNode(NodeImpl *node, unsigned int start, unsigned
      
     ASSERT(node->isTextNode());
     TextImpl *textNode = static_cast<TextImpl *>(node);
-    DOMString text = textNode->data();
+    String text = textNode->data();
     ASSERT(length <= text.length() && start + length <= text.length());
     
     QString substring = text.substring(start, length).qstring();
@@ -177,7 +177,7 @@ void rebalanceWhitespaceInTextNode(NodeImpl *node, unsigned int start, unsigned
         substring.replace(end, 1, nbsp);
     
     text.remove(start, length);
-    text.insert(DOMString(substring), start);
+    text.insert(String(substring), start);
 }
 
 bool isTableStructureNode(const NodeImpl *node)
@@ -186,18 +186,12 @@ bool isTableStructureNode(const NodeImpl *node)
     return (r && (r->isTableCell() || r->isTableRow() || r->isTableSection() || r->isTableCol()));
 }
 
-DOMString &nonBreakingSpaceString()
+const String& nonBreakingSpaceString()
 {
-    static DOMString nonBreakingSpaceString = QString(QChar(NON_BREAKING_SPACE));
+    static String nonBreakingSpaceString = QString(QChar(NON_BREAKING_SPACE));
     return nonBreakingSpaceString;
 }
 
-void derefNodesInList(const QPtrList<NodeImpl>& list)
-{
-    for (QPtrListIterator<NodeImpl> it(list); it.current(); ++it)
-        it.current()->deref();
-}
-
 // FIXME: Why use this instead of maxDeepOffset???
 static int maxRangeOffset(NodeImpl *n)
 {
@@ -475,17 +469,15 @@ Position positionAvoidingSpecialElementBoundary(const Position &pos)
     return result;
 }
 
-ElementImpl *createDefaultParagraphElement(DocumentImpl *document)
+PassRefPtr<ElementImpl> createDefaultParagraphElement(DocumentImpl *document)
 {
-    // We would need this margin-zeroing code back if we ever return to using <p> elements for default paragraphs.
-    // static const DOMString defaultParagraphStyle("margin-top: 0; margin-bottom: 0");    
     int exceptionCode = 0;
     ElementImpl *element = document->createElementNS(xhtmlNamespaceURI, "div", exceptionCode);
     ASSERT(exceptionCode == 0);
     return element;
 }
 
-ElementImpl *createBreakElement(DocumentImpl *document)
+PassRefPtr<ElementImpl> createBreakElement(DocumentImpl *document)
 {
     int exceptionCode = 0;
     ElementImpl *breakNode = document->createElementNS(xhtmlNamespaceURI, "br", exceptionCode);
@@ -519,11 +511,11 @@ Position positionBeforeTabSpan(const Position& pos)
     return Position(node->parentNode(), node->nodeIndex());
 }
 
-ElementImpl *createTabSpanElement(DocumentImpl *document, NodeImpl *tabTextNode)
+PassRefPtr<ElementImpl> createTabSpanElement(DocumentImpl* document, PassRefPtr<NodeImpl> tabTextNode)
 {
     // make the span to hold the tab
     int exceptionCode = 0;
-    ElementImpl *spanElement = document->createElementNS(xhtmlNamespaceURI, "span", exceptionCode);
+    RefPtr<ElementImpl> spanElement = document->createElementNS(xhtmlNamespaceURI, "span", exceptionCode);
     assert(exceptionCode == 0);
     spanElement->setAttribute(classAttr, AppleTabSpanClass);
     spanElement->setAttribute(styleAttr, "white-space:pre");
@@ -534,12 +526,17 @@ ElementImpl *createTabSpanElement(DocumentImpl *document, NodeImpl *tabTextNode)
     spanElement->appendChild(tabTextNode, exceptionCode);
     assert(exceptionCode == 0);
 
-    return spanElement;
+    return spanElement.release();
+}
+
+PassRefPtr<ElementImpl> createTabSpanElement(DocumentImpl* document, const String& tabText)
+{
+    return createTabSpanElement(document, document->createTextNode(tabText));
 }
 
-ElementImpl *createTabSpanElement(DocumentImpl *document, QString *tabText)
+PassRefPtr<ElementImpl> createTabSpanElement(DocumentImpl* document)
 {
-    return createTabSpanElement(document, document->createTextNode(*tabText));
+    return createTabSpanElement(document, PassRefPtr<NodeImpl>());
 }
 
 bool isNodeRendered(const NodeImpl *node)
index 182e9553b4637bedd3aa5f1d4aabeb96369a67ca..4b6bd0c0189bd0e68b5cd4502628d6c325274c31 100644 (file)
 #ifndef htmlediting_h
 #define htmlediting_h
 
-#include <qptrlist.h>
-
-class QString;
+namespace KXMLCore {
+    template <typename T> class PassRefPtr;
+}
+using KXMLCore::PassRefPtr;
 
 namespace WebCore {
 
-class DOMString;
 class DocumentImpl;
 class ElementImpl;
 class NodeImpl;
 class Position;
+class String;
 class VisiblePosition;
 
 const unsigned short NON_BREAKING_SPACE = 0xa0;
 
-Position rangeCompliantEquivalent(const Position& pos);
-Position rangeCompliantEquivalent(const VisiblePosition& vpos);
-int maxDeepOffset(const NodeImpl* node);
-bool isAtomicNode(const NodeImpl* node);
-bool editingIgnoresContent(const NodeImpl* node);
+Position rangeCompliantEquivalent(const Position&);
+Position rangeCompliantEquivalent(const VisiblePosition&);
+int maxDeepOffset(const NodeImpl*);
+bool isAtomicNode(const NodeImpl*);
+bool editingIgnoresContent(const NodeImpl*);
 
 void rebalanceWhitespaceInTextNode(NodeImpl*, unsigned start, unsigned length);
-DOMString& nonBreakingSpaceString();
-void derefNodesInList(const QPtrList<NodeImpl>&);
+const String& nonBreakingSpaceString();
 
 //------------------------------------------------------------------------------------------
 
@@ -58,15 +58,16 @@ Position positionAfterNode(const NodeImpl*);
 
 bool isSpecialElement(const NodeImpl*);
 
-ElementImpl* createDefaultParagraphElement(DocumentImpl*);
-ElementImpl* createBreakElement(DocumentImpl*);
+PassRefPtr<ElementImpl> createDefaultParagraphElement(DocumentImpl*);
+PassRefPtr<ElementImpl> createBreakElement(DocumentImpl*);
 
 bool isTabSpanNode(const NodeImpl*);
 bool isTabSpanTextNode(const NodeImpl*);
 NodeImpl* tabSpanNode(const NodeImpl*);
 Position positionBeforeTabSpan(const Position&);
-ElementImpl* createTabSpanElement(DocumentImpl*, NodeImpl* tabTextNode = 0);
-ElementImpl* createTabSpanElement(DocumentImpl*, QString* tabText);
+PassRefPtr<ElementImpl> createTabSpanElement(DocumentImpl*);
+PassRefPtr<ElementImpl> createTabSpanElement(DocumentImpl*, PassRefPtr<NodeImpl> tabTextNode);
+PassRefPtr<ElementImpl> createTabSpanElement(DocumentImpl*, const String& tabText);
 
 bool isNodeRendered(const NodeImpl*);
 bool isMailBlockquote(const NodeImpl*);
@@ -75,19 +76,19 @@ NodeImpl* nearestMailBlockquote(const NodeImpl*);
 //------------------------------------------------------------------------------------------
 
 bool isTableStructureNode(const NodeImpl*);
-ElementImpl *createBlockPlaceholderElement(DocumentImpl*);
+PassRefPtr<ElementImpl> createBlockPlaceholderElement(DocumentImpl*);
 
-bool isFirstVisiblePositionInSpecialElement(const Position& pos);
-Position positionBeforeContainingSpecialElement(const Position& pos, NodeImpl** containingSpecialElement=0);
-bool isLastVisiblePositionInSpecialElement(const Position& pos);
-Position positionAfterContainingSpecialElement(const Position& pos, NodeImpl** containingSpecialElement=0);
-Position positionOutsideContainingSpecialElement(const Position &pos, NodeImpl** containingSpecialElement=0);
+bool isFirstVisiblePositionInSpecialElement(const Position&);
+Position positionBeforeContainingSpecialElement(const Position&, NodeImpl** containingSpecialElement=0);
+bool isLastVisiblePositionInSpecialElement(const Position&);
+Position positionAfterContainingSpecialElement(const Position&, NodeImpl** containingSpecialElement=0);
+Position positionOutsideContainingSpecialElement(const Position&, NodeImpl** containingSpecialElement=0);
 
 bool isListElement(NodeImpl* n);
 bool isTableElement(NodeImpl* n);
-bool isFirstVisiblePositionAfterTableElement(const Position &pos);
-Position positionBeforePrecedingTableElement(const Position &pos);
-Position positionAvoidingSpecialElementBoundary(const Position &pos);
+bool isFirstVisiblePositionAfterTableElement(const Position&);
+Position positionBeforePrecedingTableElement(const Position&);
+Position positionAvoidingSpecialElementBoundary(const Position&);
 
 }
 
index ce4dde1442e9110b9741e06c64140163508e0bdc..6760c7603efb8213f1a62e1a8a361067e60bf327 100644 (file)
@@ -92,8 +92,8 @@ void InsertLineBreakCommand::doApply()
     deleteSelection();
     Selection selection = endingSelection();
 
-    ElementImpl *breakNode = createBreakElement(document());
-    NodeImpl *nodeToInsert = breakNode;
+    RefPtr<ElementImpl> breakNode = createBreakElement(document());
+    NodeImpl* nodeToInsert = breakNode.get();
     
     Position pos(selection.start().upstream());
 
@@ -119,9 +119,9 @@ void InsertLineBreakCommand::doApply()
                 setEndingSelection(Selection(Position(next, 0), DOWNSTREAM));
             else if (!document()->inStrictMode()) {
                 // Insert an "extra" BR at the end of the block. 
-                ElementImpl *extraBreakNode = createBreakElement(document());
-                insertNodeAfter(extraBreakNode, nodeToInsert);
-                setEndingSelection(Position(extraBreakNode, 0), DOWNSTREAM);
+                RefPtr<ElementImpl> extraBreakNode = createBreakElement(document());
+                insertNodeAfter(extraBreakNode.get(), nodeToInsert);
+                setEndingSelection(Position(extraBreakNode.get(), 0), DOWNSTREAM);
             }
         }
     }
index ba77471fba2511cc571532feab0b7d87c7ff27ca..ce50f84a94da06dd697a146482a09a9fd39e60fe 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 #include "config.h"
 #include "insert_paragraph_separator_command.h"
 
-#include "htmlediting.h"
-#include "visible_position.h"
-#include "visible_units.h"
-
-#include "css/css_computedstyle.h"
-#include "css/css_valueimpl.h"
-#include "htmlnames.h"
 #include "DocumentImpl.h"
+#include "KWQLogging.h"
+#include "css_computedstyle.h"
 #include "dom_elementimpl.h"
 #include "dom_textimpl.h"
-
+#include "htmlediting.h"
+#include "htmlnames.h"
+#include "visible_position.h"
+#include "visible_units.h"
 #include <kxmlcore/Assertions.h>
-#include "KWQLogging.h"
-
-using namespace DOM::HTMLNames;
 
-using DOM::CSSComputedStyleDeclarationImpl;
-using DOM::DocumentImpl;
-using DOM::ElementImpl;
-using DOM::NodeImpl;
-using DOM::Position;
-using DOM::TextImpl;
+namespace WebCore {
 
-namespace khtml {
+using namespace HTMLNames;
 
 InsertParagraphSeparatorCommand::InsertParagraphSeparatorCommand(DocumentImpl *document) 
     : CompositeEditCommand(document)
 {
 }
 
-InsertParagraphSeparatorCommand::~InsertParagraphSeparatorCommand() 
-{
-    derefNodesInList(clonedNodes);
-}
-
 bool InsertParagraphSeparatorCommand::preservesTypingStyle() const
 {
     return true;
 }
 
-ElementImpl *InsertParagraphSeparatorCommand::createParagraphElement()
-{
-    ElementImpl *element = createDefaultParagraphElement(document());
-    element->ref();
-    clonedNodes.append(element);
-    return element;
-}
-
 void InsertParagraphSeparatorCommand::calculateStyleBeforeInsertion(const Position &pos)
 {
     // It is only important to set a style to apply later if we're at the boundaries of
@@ -133,16 +110,18 @@ void InsertParagraphSeparatorCommand::doApply()
     bool startBlockIsRoot = startBlock == startBlock->rootEditableElement();
 
     // This is the block that is going to be inserted.
-    RefPtr<NodeImpl> blockToInsert = startBlockIsRoot ? createParagraphElement() : startBlock->cloneNode(false);
+    RefPtr<NodeImpl> blockToInsert = startBlockIsRoot
+        ? static_pointer_cast<NodeImpl>(createDefaultParagraphElement(document()))
+        : startBlock->cloneNode(false);
 
     //---------------------------------------------------------------------
     // Handle empty block case.
     if (isFirstInBlock && isLastInBlock) {
         LOG(Editing, "insert paragraph separator: empty block case");
         if (startBlockIsRoot) {
-            NodeImpl *extraBlock = createParagraphElement();
-            appendNode(extraBlock, startBlock);
-            appendBlockPlaceholder(extraBlock);
+            RefPtr<NodeImpl> extraBlock = createDefaultParagraphElement(document());
+            appendNode(extraBlock.get(), startBlock);
+            appendBlockPlaceholder(extraBlock.get());
             appendNode(blockToInsert.get(), startBlock);
         }
         else {
@@ -206,7 +185,7 @@ void InsertParagraphSeparatorCommand::doApply()
     if (!document()->inStrictMode()) {
         Position upstreamPos = pos.upstream();
         if (upstreamPos.node()->hasTagName(brTag))
-            insertNodeAfter(createBreakElement(document()), upstreamPos.node());
+            insertNodeAfter(createBreakElement(document()).get(), upstreamPos.node());
     }
     
     // Move downstream. Typing style code will take care of carrying along the 
@@ -215,6 +194,7 @@ void InsertParagraphSeparatorCommand::doApply()
     startNode = pos.node();
 
     // Build up list of ancestors in between the start node and the start block.
+    QPtrList<NodeImpl> ancestors;
     if (startNode != startBlock) {
         for (NodeImpl *n = startNode->parentNode(); n && n != startBlock; n = n->parentNode())
             ancestors.prepend(n);
@@ -247,13 +227,11 @@ void InsertParagraphSeparatorCommand::doApply()
     }
 
     // Make clones of ancestors in between the start node and the start block.
-    NodeImpl *parent = blockToInsert.get();
+    RefPtr<NodeImpl> parent = blockToInsert;
     for (QPtrListIterator<NodeImpl> it(ancestors); it.current(); ++it) {
         RefPtr<NodeImpl> child = it.current()->cloneNode(false); // shallow clone
-        child->ref();
-        clonedNodes.append(child.get());
-        appendNode(child.get(), parent);
-        parent = child.get();
+        appendNode(child.get(), parent.get());
+        parent = child.release();
     }
 
     // Insert a block placeholder if the next visible position is in a different paragraph,
@@ -272,7 +250,7 @@ void InsertParagraphSeparatorCommand::doApply()
         while (n && n != blockToInsert) {
             NodeImpl *next = n->nextSibling();
             removeNode(n);
-            appendNode(n, parent);
+            appendNode(n, parent.get());
             n = next;
         }
     }            
@@ -285,7 +263,7 @@ void InsertParagraphSeparatorCommand::doApply()
         while (n && n != blockToInsert) {
             NodeImpl *next = n->nextSibling();
             removeNode(n);
-            appendNode(n, parent);
+            appendNode(n, parent.get());
             n = next;
         }
         leftParent = leftParent->parentNode();
@@ -308,4 +286,4 @@ void InsertParagraphSeparatorCommand::doApply()
     applyStyleAfterInsertion();
 }
 
-} // namespace khtml
+} // namespace WebCore
index 899fade5bab0d66c4d3a277e821f06b4e30177c7..3be2643d3b803146504b60c659a28f5d2d1dcaa6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef __insert_paragraph_separator_command_h__
-#define __insert_paragraph_separator_command_h__
+#ifndef insert_paragraph_separator_command_h__
+#define insert_paragraph_separator_command_h__
 
 #include "composite_edit_command.h"
-#include "qptrlist.h"
 
-namespace khtml {
+namespace WebCore {
 
-class InsertParagraphSeparatorCommand : public CompositeEditCommand
-{
+class InsertParagraphSeparatorCommand : public CompositeEditCommand {
 public:
-    InsertParagraphSeparatorCommand(DOM::DocumentImpl *document);
-    virtual ~InsertParagraphSeparatorCommand();
+    InsertParagraphSeparatorCommand(DocumentImpl*);
 
     virtual void doApply();
 
 private:
-    DOM::ElementImpl *createParagraphElement();
-    void calculateStyleBeforeInsertion(const DOM::Position &);
+    void calculateStyleBeforeInsertion(const Position&);
     void applyStyleAfterInsertion();
 
     virtual bool preservesTypingStyle() const;
 
-    QPtrList<DOM::NodeImpl> ancestors;
-    QPtrList<DOM::NodeImpl> clonedNodes;
-    RefPtr<DOM::CSSMutableStyleDeclarationImpl> m_style;
+    RefPtr<CSSMutableStyleDeclarationImpl> m_style;
 };
 
-} // namespace khtml
+}
 
-#endif // __insert_paragraph_separator_command_h__
+#endif
index 7757361c3fc52e82549e940c8f185eac9b827767..8959444abc66df82b387455d9958d5b52224c36d 100644 (file)
@@ -171,15 +171,15 @@ DOM::Position InsertTextCommand::insertTab(Position pos)
     }
     
     // create new tab span
-    DOM::ElementImpl * spanNode = createTabSpanElement(document());
+    RefPtr<ElementImpl> spanNode = createTabSpanElement(document());
     
     // place it
     if (!node->isTextNode()) {
-        insertNodeAt(spanNode, node, offset);
+        insertNodeAt(spanNode.get(), node, offset);
     } else {
         TextImpl *textNode = static_cast<TextImpl *>(node);
         if (offset >= textNode->length()) {
-            insertNodeAfter(spanNode, textNode);
+            insertNodeAfter(spanNode.get(), textNode);
         } else {
             // split node to make room for the span
             // NOTE: splitTextNode uses textNode for the
@@ -187,7 +187,7 @@ DOM::Position InsertTextCommand::insertTab(Position pos)
             // insert the span before it.
             if (offset > 0)
                 splitTextNode(textNode, offset);
-            insertNodeBefore(spanNode, textNode);
+            insertNodeBefore(spanNode.get(), textNode);
         }
     }
     
index 34c85bcb6730a58d76ae26ab7475f6fc47422453..323b062e1e8c563edb5e30069f4000d471eed181 100644 (file)
@@ -471,13 +471,13 @@ PassRefPtr<DocumentFragmentImpl> createFragmentFromMarkup(DocumentImpl *document
     // FIXME: What if the document element is not an HTML element?
     HTMLElementImpl *element = static_cast<HTMLElementImpl *>(document->documentElement());
 
-    PassRefPtr<DocumentFragmentImpl> fragment = element->createContextualFragment(markup);
+    RefPtr<DocumentFragmentImpl> fragment = element->createContextualFragment(markup);
     ASSERT(fragment);
 
     if (!baseURL.isEmpty() && baseURL != document->baseURL())
         completeURLs(fragment.get(), baseURL);
 
-    return fragment;
+    return fragment.release();
 }
 
 QString createMarkup(const DOM::NodeImpl *node, EChildrenOnly includeChildren,
@@ -492,8 +492,7 @@ static void createParagraphContentsFromString(DOM::DocumentImpl *document, Eleme
 {
     int exceptionCode = 0;
     if (string.isEmpty()) {
-        NodeImpl *placeHolder = createBlockPlaceholderElement(document);
-        paragraph->appendChild(placeHolder, exceptionCode);
+        paragraph->appendChild(createBlockPlaceholderElement(document), exceptionCode);
         ASSERT(exceptionCode == 0);
         return;
     }
@@ -509,7 +508,7 @@ static void createParagraphContentsFromString(DOM::DocumentImpl *document, Eleme
         // append the non-tab textual part
         if (!s.isEmpty()) {
             if (tabText != "") {
-                paragraph->appendChild(createTabSpanElement(document, &tabText), exceptionCode);
+                paragraph->appendChild(createTabSpanElement(document, tabText), exceptionCode);
                 ASSERT(exceptionCode == 0);
                 tabText = "";
             }
@@ -524,7 +523,7 @@ static void createParagraphContentsFromString(DOM::DocumentImpl *document, Eleme
         if (!tabList.isEmpty()) {
             tabText += '\t';
         } else if (tabText != "") {
-            paragraph->appendChild(createTabSpanElement(document, &tabText), exceptionCode);
+            paragraph->appendChild(createTabSpanElement(document, tabText), exceptionCode);
             ASSERT(exceptionCode == 0);
         }
     }
@@ -535,7 +534,7 @@ PassRefPtr<DocumentFragmentImpl> createFragmentFromText(DocumentImpl *document,
     if (!document)
         return 0;
 
-    PassRefPtr<DocumentFragmentImpl> fragment = document->createDocumentFragment();
+    RefPtr<DocumentFragmentImpl> fragment = document->createDocumentFragment();
     
     if (!text.isEmpty()) {
         QString string = text;
@@ -563,7 +562,7 @@ PassRefPtr<DocumentFragmentImpl> createFragmentFromText(DocumentImpl *document,
             ASSERT(exceptionCode == 0);
         }
     }
-    return fragment;
+    return fragment.release();
 }
 
 PassRefPtr<DocumentFragmentImpl> createFragmentFromNodeList(DocumentImpl *document, const QPtrList<NodeImpl> &nodeList)
@@ -571,18 +570,18 @@ PassRefPtr<DocumentFragmentImpl> createFragmentFromNodeList(DocumentImpl *docume
     if (!document)
         return 0;
     
-    PassRefPtr<DocumentFragmentImpl> fragment = document->createDocumentFragment();
-    
-    RefPtr<ElementImpl> element;
+    RefPtr<DocumentFragmentImpl> fragment = document->createDocumentFragment();
+
     int exceptionCode = 0;
     for (QPtrListIterator<NodeImpl> i(nodeList); i.current(); ++i) {
-        element = createDefaultParagraphElement(document);
+        RefPtr<ElementImpl> element = createDefaultParagraphElement(document);
         element->appendChild(i.current(), exceptionCode);
         ASSERT(exceptionCode == 0);
-        fragment->appendChild(element.get(), exceptionCode);
+        fragment->appendChild(element.release(), exceptionCode);
         ASSERT(exceptionCode == 0);
     }
-    return fragment;
+
+    return fragment.release();
 }
 
 }
index 26e9a6912e9b66f164a987103ab59cb4eea1c523..012f98a9680cf214ad29f1835094083976db2d67 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 #include "config.h"
 #include "rebalance_whitespace_command.h"
 
+#include "DocumentImpl.h"
+#include "dom_textimpl.h"
 #include "htmlediting.h"
 #include "visible_text.h"
-#include "dom_textimpl.h"
-
 #include <kxmlcore/Assertions.h>
 
-using DOM::DOMString;
-using DOM::DocumentImpl;
-using DOM::Position;
-using DOM::TextImpl;
-
-namespace khtml {
+namespace WebCore {
 
 RebalanceWhitespaceCommand::RebalanceWhitespaceCommand(DocumentImpl *document, const Position &pos)
     : EditCommand(document), m_position(pos), m_upstreamOffset(InvalidOffset)
index 401eb70cbb868082e5542550949cae71c677c5dd..3c6eafd6f6ab5633d899e3e0fa83ec81268eea62 100644 (file)
@@ -113,7 +113,7 @@ ReplacementFragment::ReplacementFragment(DocumentImpl *document, DocumentFragmen
     if (newlineAtEndNode)
         removeNode(newlineAtEndNode);
     
-    PassRefPtr<NodeImpl> holder = insertFragmentForTestRendering();
+    RefPtr<NodeImpl> holder = insertFragmentForTestRendering();
     if (!m_matchStyle)
         computeStylesUsingTestRendering(holder.get());
     removeUnrenderedNodesUsingTestRendering(holder.get());
@@ -232,7 +232,7 @@ PassRefPtr<NodeImpl> ReplacementFragment::insertFragmentForTestRendering()
     if (!body)
         return 0;
 
-    PassRefPtr<ElementImpl> holder = createDefaultParagraphElement(m_document.get());
+    RefPtr<ElementImpl> holder = createDefaultParagraphElement(m_document.get());
     
     int exceptionCode = 0;
     holder->appendChild(m_fragment.get(), exceptionCode);
@@ -243,7 +243,7 @@ PassRefPtr<NodeImpl> ReplacementFragment::insertFragmentForTestRendering()
     
     m_document->updateLayoutIgnorePendingStylesheets();
     
-    return holder;
+    return holder.release();
 }
 
 void ReplacementFragment::restoreTestRenderingNodesToFragment(NodeImpl *holder)
@@ -756,7 +756,7 @@ void ReplaceSelectionCommand::doApply()
                 bool hasTrailingBR = next && next->hasTagName(brTag) && m_lastNodeInserted->enclosingBlockFlowElement() == next->enclosingBlockFlowElement();
                 if (!hasTrailingBR) {
                     // Insert an "extra" BR at the end of the block. 
-                    insertNodeBefore(createBreakElement(document()), m_lastNodeInserted.get());
+                    insertNodeBefore(createBreakElement(document()).get(), m_lastNodeInserted.get());
                 }
             }
         }
index a4fa45ffa1fe495170498338abd8d5469f602df8..3fc19b47e238b463eaee56b4db1d98bcba3538dc 100644 (file)
@@ -738,7 +738,7 @@ CharacterIterator::CharacterIterator(const RangeImpl *r)
 
 PassRefPtr<RangeImpl> CharacterIterator::range() const
 {
-    PassRefPtr<RangeImpl> r = m_textIterator.range();
+    RefPtr<RangeImpl> r = m_textIterator.range();
     if (!m_textIterator.atEnd()) {
         if (m_textIterator.length() <= 1) {
             assert(m_runOffset == 0);
@@ -751,7 +751,7 @@ PassRefPtr<RangeImpl> CharacterIterator::range() const
             r->setEnd(n, offset + 1, exception);
         }
     }
-    return r;
+    return r.release();
 }
 
 void CharacterIterator::advance(int count)
@@ -1081,9 +1081,9 @@ PassRefPtr<RangeImpl> findPlainText(const RangeImpl *r, const QString &s, bool f
     // Once we fix those, we can remove this check.
     if (s.isEmpty() || s.find('\n') != -1) {
         int exception = 0;
-        RangeImpl *result = r->cloneRange(exception);
+        RefPtr<RangeImpl> result = r->cloneRange(exception);
         result->collapse(forward, exception);
-        return result;
+        return result.release();
     }
 
     CircularSearchBuffer buffer(s, caseSensitive);
@@ -1131,7 +1131,7 @@ PassRefPtr<RangeImpl> findPlainText(const RangeImpl *r, const QString &s, bool f
 
 done:
     int exception = 0;
-    RangeImpl *result = r->cloneRange(exception);
+    RefPtr<RangeImpl> result = r->cloneRange(exception);
     if (!found) {
         result->collapse(!forward, exception);
     } else {
@@ -1141,7 +1141,7 @@ done:
         it.advance(buffer.length() - 1);
         result->setEnd(it.range()->endContainer(exception), it.range()->endOffset(exception), exception);
     }
-    return result;
+    return result.release();
 }
 
 }
index 6fcd08dda1dd92f5b21bb95da1b26bfd0e62219e..03b6c2e60799cc582ad3bf0095a162f6f7e9f629 100644 (file)
@@ -92,7 +92,7 @@ int HTMLElementImpl::tagPriority() const
 
 PassRefPtr<NodeImpl> HTMLElementImpl::cloneNode(bool deep)
 {
-    PassRefPtr<HTMLElementImpl> clone = HTMLElementFactory::createHTMLElement(m_tagName.localName(), getDocument(), 0, false);
+    RefPtr<HTMLElementImpl> clone = HTMLElementFactory::createHTMLElement(m_tagName.localName(), getDocument(), 0, false);
     if (!clone)
         return 0;
 
@@ -107,7 +107,7 @@ PassRefPtr<NodeImpl> HTMLElementImpl::cloneNode(bool deep)
     if (deep)
         cloneChildNodes(clone.get());
 
-    return clone;
+    return clone.release();
 }
 
 bool HTMLElementImpl::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const
index dfb9a15c352f7bdcaf3fdd4bf90161e1bfd25206..e1d0a5f8447418cd2a6a6296e61189996079c1a9 100644 (file)
@@ -1051,7 +1051,7 @@ void HTMLParser::handleResidualStyleCloseTagAcrossBlocks(HTMLStackElem* elem)
         blockElem->parentNode()->removeChild(blockElem, exceptionCode);
         
     // Step 2: Clone |residualElem|.
-    PassRefPtr<NodeImpl> newNode = residualElem->cloneNode(false); // Shallow clone. We don't pick up the same kids.
+    RefPtr<NodeImpl> newNode = residualElem->cloneNode(false); // Shallow clone. We don't pick up the same kids.
 
     // Step 3: Place |blockElem|'s children under |newNode|.  Remove all of the children of |blockElem|
     // before we've put |newElem| into the document.  That way we'll only do one attachment of all
@@ -1065,7 +1065,7 @@ void HTMLParser::handleResidualStyleCloseTagAcrossBlocks(HTMLStackElem* elem)
 
     // Step 4: Place |newNode| under |blockElem|.  |blockElem| is still out of the document, so no
     // attachment can occur yet.
-    blockElem->appendChild(newNode, exceptionCode);
+    blockElem->appendChild(newNode.release(), exceptionCode);
     
     // Step 5: Reparent |blockElem|.  Now the full attachment of the fixed up tree takes place.
     if (isBlockStillInTree)
index 0f3d041064dbc190c4bff3304b246eb1a8bc590c..aabda859bbc61d14c8060ee88a6591013c30e808 100644 (file)
@@ -24,7 +24,7 @@
 #if SVG_SUPPORT
 #include <qregexp.h>
 #include <qstringlist.h>
-#include <kxmlcore/PassRefPtr.h>
+#include <kxmlcore/RefPtr.h>
 
 #include <kdom/core/AttrImpl.h>
 
@@ -83,7 +83,7 @@ void SVGTransformableImpl::parseTransformAttribute(SVGTransformListImpl *list, c
         if (subtransform[0].startsWith(";") || subtransform[0].startsWith(","))
             subtransform[0] = subtransform[0].right(subtransform[0].length() - 1);
 
-        PassRefPtr<SVGTransformImpl> t(new SVGTransformImpl());
+        RefPtr<SVGTransformImpl> t(new SVGTransformImpl());
 
         if (subtransform[0] == "rotate") {
             if (params.count() == 3)
@@ -119,7 +119,7 @@ void SVGTransformableImpl::parseTransformAttribute(SVGTransformListImpl *list, c
         if (t->type() == SVG_TRANSFORM_UNKNOWN)
             break; // failed to parse a valid transform, abort.
         
-        list->appendItem(t.release());
+        list->appendItem(t.release().release());
     }
 }
 
index fc46b49a700b2aae545f1244d5b2f4bf00cf3b0a..4d7202c5bf589a843aa3db8a385e459967242373 100644 (file)
@@ -118,7 +118,7 @@ void SVGUseElementImpl::closeRenderer()
     QString trans = QString::fromLatin1("translate(%1, %2)").arg(_x).arg(_y);
     if(target->hasTagName(SVGNames::symbolTag))
     {
-        SVGElementImpl *dummy = new SVGSVGElementImpl(SVGNames::svgTag, getDocument());
+        RefPtr<SVGElementImpl> dummy = new SVGSVGElementImpl(SVGNames::svgTag, getDocument());
         if(_w > 0)
             dummy->setAttribute(SVGNames::widthAttr, wString.impl());
         if(_h > 0)
@@ -129,9 +129,9 @@ void SVGUseElementImpl::closeRenderer()
             const KDOM::AtomicString& symbolViewBox = symbol->getAttribute(SVGNames::viewBoxAttr);
             dummy->setAttribute(SVGNames::viewBoxAttr, symbolViewBox);
         }
-        target->cloneChildNodes(dummy);
+        target->cloneChildNodes(dummy.get());
 
-        SVGElementImpl *dummy2 = new SVGDummyElementImpl(SVGNames::gTag, getDocument());
+        RefPtr<SVGElementImpl> dummy2 = new SVGDummyElementImpl(SVGNames::gTag, getDocument());
         dummy2->setAttribute(SVGNames::transformAttr, KDOM::DOMString(trans));
         
         appendChild(dummy2, exceptioncode);
@@ -139,10 +139,10 @@ void SVGUseElementImpl::closeRenderer()
     }
     else if(target->hasTagName(SVGNames::svgTag))
     {
-        SVGDummyElementImpl *dummy = new SVGDummyElementImpl(SVGNames::gTag, getDocument());
+        RefPtr<SVGDummyElementImpl> dummy = new SVGDummyElementImpl(SVGNames::gTag, getDocument());
         dummy->setAttribute(SVGNames::transformAttr, KDOM::DOMString(trans));
         
-        PassRefPtr<SVGElementImpl> root = static_pointer_cast<SVGElementImpl>(target->cloneNode(true));
+        RefPtr<SVGElementImpl> root = static_pointer_cast<SVGElementImpl>(target->cloneNode(true));
         if(hasAttribute(SVGNames::widthAttr))
             root->setAttribute(SVGNames::widthAttr, wString.impl());
             
@@ -150,17 +150,17 @@ void SVGUseElementImpl::closeRenderer()
             root->setAttribute(SVGNames::heightAttr, hString.impl());
             
         appendChild(dummy, exceptioncode);
-        dummy->appendChild(root, exceptioncode);
+        dummy->appendChild(root.release(), exceptioncode);
     }
     else
     {
-        SVGDummyElementImpl *dummy = new SVGDummyElementImpl(SVGNames::gTag, getDocument());
+        RefPtr<SVGDummyElementImpl> dummy = new SVGDummyElementImpl(SVGNames::gTag, getDocument());
         dummy->setAttribute(SVGNames::transformAttr, trans);
         
-        PassRefPtr<KDOM::NodeImpl> root = target->cloneNode(true);
+        RefPtr<KDOM::NodeImpl> root = target->cloneNode(true);
         
         appendChild(dummy, exceptioncode);
-        dummy->appendChild(root, exceptioncode);
+        dummy->appendChild(root.release(), exceptioncode);
     }
 
     SVGElementImpl::closeRenderer();