#include "config.h"
#include "core/inspector/DOMEditor.h"
-#include "bindings/v8/ExceptionState.h"
-#include "bindings/v8/ExceptionStatePlaceholder.h"
+#include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/ExceptionStatePlaceholder.h"
#include "core/dom/DOMException.h"
#include "core/dom/Element.h"
#include "core/dom/Node.h"
#include "core/inspector/InspectorHistory.h"
#include "wtf/RefPtr.h"
-using namespace std;
+namespace blink {
-namespace WebCore {
-
-class DOMEditor::RemoveChildAction : public InspectorHistory::Action {
+class DOMEditor::RemoveChildAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(RemoveChildAction);
public:
RemoveChildAction(Node* parentNode, Node* node)
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
{
m_anchorNode = m_node->nextSibling();
- return redo(es);
+ return redo(exceptionState);
+ }
+
+ virtual bool undo(ExceptionState& exceptionState) override
+ {
+ m_parentNode->insertBefore(m_node.get(), m_anchorNode.get(), exceptionState);
+ return !exceptionState.hadException();
}
- virtual bool undo(ExceptionState& es)
+ virtual bool redo(ExceptionState& exceptionState) override
{
- m_parentNode->insertBefore(m_node.get(), m_anchorNode.get(), es);
- return !es.hadException();
+ m_parentNode->removeChild(m_node.get(), exceptionState);
+ return !exceptionState.hadException();
}
- virtual bool redo(ExceptionState& es)
+ virtual void trace(Visitor* visitor) override
{
- m_parentNode->removeChild(m_node.get(), es);
- return !es.hadException();
+ visitor->trace(m_parentNode);
+ visitor->trace(m_node);
+ visitor->trace(m_anchorNode);
+ InspectorHistory::Action::trace(visitor);
}
private:
- RefPtr<Node> m_parentNode;
- RefPtr<Node> m_node;
- RefPtr<Node> m_anchorNode;
+ RefPtrWillBeMember<Node> m_parentNode;
+ RefPtrWillBeMember<Node> m_node;
+ RefPtrWillBeMember<Node> m_anchorNode;
};
-class DOMEditor::InsertBeforeAction : public InspectorHistory::Action {
+class DOMEditor::InsertBeforeAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(InsertBeforeAction);
public:
- InsertBeforeAction(Node* parentNode, PassRefPtr<Node> node, Node* anchorNode)
+ InsertBeforeAction(Node* parentNode, PassRefPtrWillBeRawPtr<Node> node, Node* anchorNode)
: InspectorHistory::Action("InsertBefore")
, m_parentNode(parentNode)
, m_node(node)
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
{
if (m_node->parentNode()) {
- m_removeChildAction = adoptPtr(new RemoveChildAction(m_node->parentNode(), m_node.get()));
- if (!m_removeChildAction->perform(es))
+ m_removeChildAction = adoptRefWillBeNoop(new RemoveChildAction(m_node->parentNode(), m_node.get()));
+ if (!m_removeChildAction->perform(exceptionState))
return false;
}
- m_parentNode->insertBefore(m_node.get(), m_anchorNode.get(), es);
- return !es.hadException();
+ m_parentNode->insertBefore(m_node.get(), m_anchorNode.get(), exceptionState);
+ return !exceptionState.hadException();
}
- virtual bool undo(ExceptionState& es)
+ virtual bool undo(ExceptionState& exceptionState) override
{
- m_parentNode->removeChild(m_node.get(), es);
- if (es.hadException())
+ m_parentNode->removeChild(m_node.get(), exceptionState);
+ if (exceptionState.hadException())
return false;
if (m_removeChildAction)
- return m_removeChildAction->undo(es);
+ return m_removeChildAction->undo(exceptionState);
return true;
}
- virtual bool redo(ExceptionState& es)
+ virtual bool redo(ExceptionState& exceptionState) override
{
- if (m_removeChildAction && !m_removeChildAction->redo(es))
+ if (m_removeChildAction && !m_removeChildAction->redo(exceptionState))
return false;
- m_parentNode->insertBefore(m_node.get(), m_anchorNode.get(), es);
- return !es.hadException();
+ m_parentNode->insertBefore(m_node.get(), m_anchorNode.get(), exceptionState);
+ return !exceptionState.hadException();
+ }
+
+ virtual void trace(Visitor* visitor) override
+ {
+ visitor->trace(m_parentNode);
+ visitor->trace(m_node);
+ visitor->trace(m_anchorNode);
+ visitor->trace(m_removeChildAction);
+ InspectorHistory::Action::trace(visitor);
}
private:
- RefPtr<Node> m_parentNode;
- RefPtr<Node> m_node;
- RefPtr<Node> m_anchorNode;
- OwnPtr<RemoveChildAction> m_removeChildAction;
+ RefPtrWillBeMember<Node> m_parentNode;
+ RefPtrWillBeMember<Node> m_node;
+ RefPtrWillBeMember<Node> m_anchorNode;
+ RefPtrWillBeMember<RemoveChildAction> m_removeChildAction;
};
-class DOMEditor::RemoveAttributeAction : public InspectorHistory::Action {
+class DOMEditor::RemoveAttributeAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(RemoveAttributeAction);
public:
- RemoveAttributeAction(Element* element, const String& name)
+ RemoveAttributeAction(Element* element, const AtomicString& name)
: InspectorHistory::Action("RemoveAttribute")
, m_element(element)
, m_name(name)
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
{
m_value = m_element->getAttribute(m_name);
- return redo(es);
+ return redo(exceptionState);
}
- virtual bool undo(ExceptionState& es)
+ virtual bool undo(ExceptionState& exceptionState) override
{
- m_element->setAttribute(m_name, m_value, es);
+ m_element->setAttribute(m_name, m_value, exceptionState);
return true;
}
- virtual bool redo(ExceptionState&)
+ virtual bool redo(ExceptionState&) override
{
m_element->removeAttribute(m_name);
return true;
}
+ virtual void trace(Visitor* visitor) override
+ {
+ visitor->trace(m_element);
+ InspectorHistory::Action::trace(visitor);
+ }
+
private:
- RefPtr<Element> m_element;
- String m_name;
- String m_value;
+ RefPtrWillBeMember<Element> m_element;
+ AtomicString m_name;
+ AtomicString m_value;
};
-class DOMEditor::SetAttributeAction : public InspectorHistory::Action {
+class DOMEditor::SetAttributeAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(SetAttributeAction);
public:
- SetAttributeAction(Element* element, const String& name, const String& value)
+ SetAttributeAction(Element* element, const AtomicString& name, const AtomicString& value)
: InspectorHistory::Action("SetAttribute")
, m_element(element)
, m_name(name)
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
{
- m_hadAttribute = m_element->hasAttribute(m_name);
+ const AtomicString& value = m_element->getAttribute(m_name);
+ m_hadAttribute = !value.isNull();
if (m_hadAttribute)
- m_oldValue = m_element->getAttribute(m_name);
- return redo(es);
+ m_oldValue = value;
+ return redo(exceptionState);
}
- virtual bool undo(ExceptionState& es)
+ virtual bool undo(ExceptionState& exceptionState) override
{
if (m_hadAttribute)
- m_element->setAttribute(m_name, m_oldValue, es);
+ m_element->setAttribute(m_name, m_oldValue, exceptionState);
else
m_element->removeAttribute(m_name);
return true;
}
- virtual bool redo(ExceptionState& es)
+ virtual bool redo(ExceptionState& exceptionState) override
{
- m_element->setAttribute(m_name, m_value, es);
+ m_element->setAttribute(m_name, m_value, exceptionState);
return true;
}
+ virtual void trace(Visitor* visitor) override
+ {
+ visitor->trace(m_element);
+ InspectorHistory::Action::trace(visitor);
+ }
+
private:
- RefPtr<Element> m_element;
- String m_name;
- String m_value;
+ RefPtrWillBeMember<Element> m_element;
+ AtomicString m_name;
+ AtomicString m_value;
bool m_hadAttribute;
- String m_oldValue;
+ AtomicString m_oldValue;
};
-class DOMEditor::SetOuterHTMLAction : public InspectorHistory::Action {
+class DOMEditor::SetOuterHTMLAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(SetOuterHTMLAction);
public:
SetOuterHTMLAction(Node* node, const String& html)
, m_node(node)
, m_nextSibling(node->nextSibling())
, m_html(html)
- , m_newNode(0)
- , m_history(adoptPtr(new InspectorHistory()))
- , m_domEditor(adoptPtr(new DOMEditor(m_history.get())))
+ , m_newNode(nullptr)
+ , m_history(adoptPtrWillBeNoop(new InspectorHistory()))
+ , m_domEditor(adoptPtrWillBeNoop(new DOMEditor(m_history.get())))
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
{
m_oldHTML = createMarkup(m_node.get());
ASSERT(m_node->ownerDocument());
DOMPatchSupport domPatchSupport(m_domEditor.get(), *m_node->ownerDocument());
- m_newNode = domPatchSupport.patchNode(m_node.get(), m_html, es);
- return !es.hadException();
+ m_newNode = domPatchSupport.patchNode(m_node.get(), m_html, exceptionState);
+ return !exceptionState.hadException();
}
- virtual bool undo(ExceptionState& es)
+ virtual bool undo(ExceptionState& exceptionState) override
{
- return m_history->undo(es);
+ return m_history->undo(exceptionState);
}
- virtual bool redo(ExceptionState& es)
+ virtual bool redo(ExceptionState& exceptionState) override
{
- return m_history->redo(es);
+ return m_history->redo(exceptionState);
}
Node* newNode()
return m_newNode;
}
+ virtual void trace(Visitor* visitor) override
+ {
+ visitor->trace(m_node);
+ visitor->trace(m_nextSibling);
+ visitor->trace(m_newNode);
+ visitor->trace(m_history);
+ visitor->trace(m_domEditor);
+ InspectorHistory::Action::trace(visitor);
+ }
+
private:
- RefPtr<Node> m_node;
- RefPtr<Node> m_nextSibling;
+ RefPtrWillBeMember<Node> m_node;
+ RefPtrWillBeMember<Node> m_nextSibling;
String m_html;
String m_oldHTML;
- Node* m_newNode;
- OwnPtr<InspectorHistory> m_history;
- OwnPtr<DOMEditor> m_domEditor;
+ RawPtrWillBeMember<Node> m_newNode;
+ OwnPtrWillBeMember<InspectorHistory> m_history;
+ OwnPtrWillBeMember<DOMEditor> m_domEditor;
};
-class DOMEditor::ReplaceWholeTextAction : public InspectorHistory::Action {
+class DOMEditor::ReplaceWholeTextAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(ReplaceWholeTextAction);
public:
ReplaceWholeTextAction(Text* textNode, const String& text)
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
{
m_oldText = m_textNode->wholeText();
- return redo(es);
+ return redo(exceptionState);
}
- virtual bool undo(ExceptionState&)
+ virtual bool undo(ExceptionState&) override
{
m_textNode->replaceWholeText(m_oldText);
return true;
}
- virtual bool redo(ExceptionState&)
+ virtual bool redo(ExceptionState&) override
{
m_textNode->replaceWholeText(m_text);
return true;
}
+ virtual void trace(Visitor* visitor) override
+ {
+ visitor->trace(m_textNode);
+ InspectorHistory::Action::trace(visitor);
+ }
+
private:
- RefPtr<Text> m_textNode;
+ RefPtrWillBeMember<Text> m_textNode;
String m_text;
String m_oldText;
};
-class DOMEditor::ReplaceChildNodeAction : public InspectorHistory::Action {
+class DOMEditor::ReplaceChildNodeAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(ReplaceChildNodeAction);
public:
- ReplaceChildNodeAction(Node* parentNode, PassRefPtr<Node> newNode, Node* oldNode)
+ ReplaceChildNodeAction(Node* parentNode, PassRefPtrWillBeRawPtr<Node> newNode, Node* oldNode)
: InspectorHistory::Action("ReplaceChildNode")
, m_parentNode(parentNode)
, m_newNode(newNode)
{
}
- virtual bool perform(ExceptionState& es)
+ virtual bool perform(ExceptionState& exceptionState) override
+ {
+ return redo(exceptionState);
+ }
+
+ virtual bool undo(ExceptionState& exceptionState) override
{
- return redo(es);
+ m_parentNode->replaceChild(m_oldNode, m_newNode.get(), exceptionState);
+ return !exceptionState.hadException();
}
- virtual bool undo(ExceptionState& es)
+ virtual bool redo(ExceptionState& exceptionState) override
{
- m_parentNode->replaceChild(m_oldNode, m_newNode.get(), es);
- return !es.hadException();
+ m_parentNode->replaceChild(m_newNode, m_oldNode.get(), exceptionState);
+ return !exceptionState.hadException();
}
- virtual bool redo(ExceptionState& es)
+ virtual void trace(Visitor* visitor) override
{
- m_parentNode->replaceChild(m_newNode, m_oldNode.get(), es);
- return !es.hadException();
+ visitor->trace(m_parentNode);
+ visitor->trace(m_newNode);
+ visitor->trace(m_oldNode);
+ InspectorHistory::Action::trace(visitor);
}
private:
- RefPtr<Node> m_parentNode;
- RefPtr<Node> m_newNode;
- RefPtr<Node> m_oldNode;
+ RefPtrWillBeMember<Node> m_parentNode;
+ RefPtrWillBeMember<Node> m_newNode;
+ RefPtrWillBeMember<Node> m_oldNode;
};
-class DOMEditor::SetNodeValueAction : public InspectorHistory::Action {
+class DOMEditor::SetNodeValueAction final : public InspectorHistory::Action {
WTF_MAKE_NONCOPYABLE(SetNodeValueAction);
public:
SetNodeValueAction(Node* node, const String& value)
{
}
- virtual bool perform(ExceptionState&)
+ virtual bool perform(ExceptionState&) override
{
m_oldValue = m_node->nodeValue();
return redo(IGNORE_EXCEPTION);
}
- virtual bool undo(ExceptionState&)
+ virtual bool undo(ExceptionState&) override
{
m_node->setNodeValue(m_oldValue);
return true;
}
- virtual bool redo(ExceptionState&)
+ virtual bool redo(ExceptionState&) override
{
m_node->setNodeValue(m_value);
return true;
}
+ virtual void trace(Visitor* visitor) override
+ {
+ visitor->trace(m_node);
+ InspectorHistory::Action::trace(visitor);
+ }
+
private:
- RefPtr<Node> m_node;
+ RefPtrWillBeMember<Node> m_node;
String m_value;
String m_oldValue;
};
DOMEditor::DOMEditor(InspectorHistory* history) : m_history(history) { }
-DOMEditor::~DOMEditor() { }
-
-bool DOMEditor::insertBefore(Node* parentNode, PassRefPtr<Node> node, Node* anchorNode, ExceptionState& es)
+bool DOMEditor::insertBefore(Node* parentNode, PassRefPtrWillBeRawPtr<Node> node, Node* anchorNode, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new InsertBeforeAction(parentNode, node, anchorNode)), es);
+ return m_history->perform(adoptRefWillBeNoop(new InsertBeforeAction(parentNode, node, anchorNode)), exceptionState);
}
-bool DOMEditor::removeChild(Node* parentNode, Node* node, ExceptionState& es)
+bool DOMEditor::removeChild(Node* parentNode, Node* node, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new RemoveChildAction(parentNode, node)), es);
+ return m_history->perform(adoptRefWillBeNoop(new RemoveChildAction(parentNode, node)), exceptionState);
}
-bool DOMEditor::setAttribute(Element* element, const String& name, const String& value, ExceptionState& es)
+bool DOMEditor::setAttribute(Element* element, const String& name, const String& value, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new SetAttributeAction(element, name, value)), es);
+ return m_history->perform(adoptRefWillBeNoop(new SetAttributeAction(element, AtomicString(name), AtomicString(value))), exceptionState);
}
-bool DOMEditor::removeAttribute(Element* element, const String& name, ExceptionState& es)
+bool DOMEditor::removeAttribute(Element* element, const String& name, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new RemoveAttributeAction(element, name)), es);
+ return m_history->perform(adoptRefWillBeNoop(new RemoveAttributeAction(element, AtomicString(name))), exceptionState);
}
-bool DOMEditor::setOuterHTML(Node* node, const String& html, Node** newNode, ExceptionState& es)
+bool DOMEditor::setOuterHTML(Node* node, const String& html, Node** newNode, ExceptionState& exceptionState)
{
- OwnPtr<SetOuterHTMLAction> action = adoptPtr(new SetOuterHTMLAction(node, html));
- SetOuterHTMLAction* rawAction = action.get();
- bool result = m_history->perform(action.release(), es);
+ RefPtrWillBeRawPtr<SetOuterHTMLAction> action = adoptRefWillBeNoop(new SetOuterHTMLAction(node, html));
+ bool result = m_history->perform(action, exceptionState);
if (result)
- *newNode = rawAction->newNode();
+ *newNode = action->newNode();
return result;
}
-bool DOMEditor::replaceWholeText(Text* textNode, const String& text, ExceptionState& es)
+bool DOMEditor::replaceWholeText(Text* textNode, const String& text, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new ReplaceWholeTextAction(textNode, text)), es);
+ return m_history->perform(adoptRefWillBeNoop(new ReplaceWholeTextAction(textNode, text)), exceptionState);
}
-bool DOMEditor::replaceChild(Node* parentNode, PassRefPtr<Node> newNode, Node* oldNode, ExceptionState& es)
+bool DOMEditor::replaceChild(Node* parentNode, PassRefPtrWillBeRawPtr<Node> newNode, Node* oldNode, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new ReplaceChildNodeAction(parentNode, newNode, oldNode)), es);
+ return m_history->perform(adoptRefWillBeNoop(new ReplaceChildNodeAction(parentNode, newNode, oldNode)), exceptionState);
}
-bool DOMEditor::setNodeValue(Node* node, const String& value, ExceptionState& es)
+bool DOMEditor::setNodeValue(Node* node, const String& value, ExceptionState& exceptionState)
{
- return m_history->perform(adoptPtr(new SetNodeValueAction(node, value)), es);
+ return m_history->perform(adoptRefWillBeNoop(new SetNodeValueAction(node, value)), exceptionState);
}
-static void populateErrorString(ExceptionState& es, ErrorString* errorString)
+static void populateErrorString(ExceptionState& exceptionState, ErrorString* errorString)
{
- if (es.hadException())
- *errorString = DOMException::getErrorName(es.code());
+ if (exceptionState.hadException())
+ *errorString = DOMException::getErrorName(exceptionState.code());
}
-bool DOMEditor::insertBefore(Node* parentNode, PassRefPtr<Node> node, Node* anchorNode, ErrorString* errorString)
+bool DOMEditor::insertBefore(Node* parentNode, PassRefPtrWillBeRawPtr<Node> node, Node* anchorNode, ErrorString* errorString)
{
- TrackExceptionState es;
- bool result = insertBefore(parentNode, node, anchorNode, es);
- populateErrorString(es, errorString);
+ TrackExceptionState exceptionState;
+ bool result = insertBefore(parentNode, node, anchorNode, exceptionState);
+ populateErrorString(exceptionState, errorString);
return result;
}
bool DOMEditor::removeChild(Node* parentNode, Node* node, ErrorString* errorString)
{
- TrackExceptionState es;
- bool result = removeChild(parentNode, node, es);
- populateErrorString(es, errorString);
+ TrackExceptionState exceptionState;
+ bool result = removeChild(parentNode, node, exceptionState);
+ populateErrorString(exceptionState, errorString);
return result;
}
bool DOMEditor::setAttribute(Element* element, const String& name, const String& value, ErrorString* errorString)
{
- TrackExceptionState es;
- bool result = setAttribute(element, name, value, es);
- populateErrorString(es, errorString);
+ TrackExceptionState exceptionState;
+ bool result = setAttribute(element, name, value, exceptionState);
+ populateErrorString(exceptionState, errorString);
return result;
}
bool DOMEditor::removeAttribute(Element* element, const String& name, ErrorString* errorString)
{
- TrackExceptionState es;
- bool result = removeAttribute(element, name, es);
- populateErrorString(es, errorString);
+ TrackExceptionState exceptionState;
+ bool result = removeAttribute(element, name, exceptionState);
+ populateErrorString(exceptionState, errorString);
return result;
}
bool DOMEditor::setOuterHTML(Node* node, const String& html, Node** newNode, ErrorString* errorString)
{
- TrackExceptionState es;
- bool result = setOuterHTML(node, html, newNode, es);
- populateErrorString(es, errorString);
+ TrackExceptionState exceptionState;
+ bool result = setOuterHTML(node, html, newNode, exceptionState);
+ populateErrorString(exceptionState, errorString);
return result;
}
bool DOMEditor::replaceWholeText(Text* textNode, const String& text, ErrorString* errorString)
{
- TrackExceptionState es;
- bool result = replaceWholeText(textNode, text, es);
- populateErrorString(es, errorString);
+ TrackExceptionState exceptionState;
+ bool result = replaceWholeText(textNode, text, exceptionState);
+ populateErrorString(exceptionState, errorString);
return result;
}
-} // namespace WebCore
+void DOMEditor::trace(Visitor* visitor)
+{
+ visitor->trace(m_history);
+}
+
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff