| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2011, Google Inc. | |
| 2 // All rights reserved. | |
| 3 // | |
| 4 // Redistribution and use in source and binary forms, with or without | |
| 5 // modification, are permitted provided that the following conditions are | |
| 6 // met: | |
| 7 // | |
| 8 // * Redistributions of source code must retain the above copyright | |
| 9 // notice, this list of conditions and the following disclaimer. | |
| 10 // * Redistributions in binary form must reproduce the above | |
| 11 // copyright notice, this list of conditions and the following disclaimer | |
| 12 // in the documentation and/or other materials provided with the | |
| 13 // distribution. | |
| 14 // * Neither the name of Google Inc. nor the names of its | |
| 15 // contributors may be used to endorse or promote products derived from | |
| 16 // this software without specific prior written permission. | |
| 17 // | |
| 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 | |
| 30 #include "config.h" | |
| 31 #include "DartNode.h" | |
| 32 | |
| 33 #include "DartAttr.h" | |
| 34 #include "DartCDATASection.h" | |
| 35 #include "DartComment.h" | |
| 36 #include "DartDOMWrapper.h" | |
| 37 #include "DartDocument.h" | |
| 38 #include "DartDocumentFragment.h" | |
| 39 #include "DartDocumentType.h" | |
| 40 #include "DartElement.h" | |
| 41 #include "DartEntity.h" | |
| 42 #include "DartEntityReference.h" | |
| 43 #include "DartNode.h" | |
| 44 #include "DartNotation.h" | |
| 45 #include "DartProcessingInstruction.h" | |
| 46 #include "DartText.h" | |
| 47 | |
| 48 namespace WebCore { | |
| 49 | |
| 50 namespace DartNodeInternal { | |
| 51 | |
| 52 // This function is customized to take advantage of the optional 4th argument: s
houldLazyAttach. | |
| 53 void insertBeforeCallback(Dart_NativeArguments args) | |
| 54 { | |
| 55 DartApiScope dartApiScope; | |
| 56 Dart_Handle exception; | |
| 57 { | |
| 58 Node* receiver = DartDOMWrapper::receiver<Node>(args); | |
| 59 | |
| 60 const ParameterAdapter<RefPtr<Node>, DartNode> newChild(Dart_GetNativeAr
gument(args, 1)); | |
| 61 if (!newChild.conversionSuccessful()) { | |
| 62 exception = newChild.exception(); | |
| 63 goto fail; | |
| 64 } | |
| 65 | |
| 66 const ParameterAdapter<RefPtr<Node>, DartNode> refChild(Dart_GetNativeAr
gument(args, 2)); | |
| 67 if (!refChild.conversionSuccessful()) { | |
| 68 exception = refChild.exception(); | |
| 69 goto fail; | |
| 70 } | |
| 71 | |
| 72 ExceptionCode ec = 0; | |
| 73 bool success = receiver->insertBefore(newChild, refChild, ec, true); | |
| 74 if (ec) { | |
| 75 exception = DartDOMWrapper::exceptionCodeToDartException(ec); | |
| 76 goto fail; | |
| 77 } | |
| 78 | |
| 79 if (success) | |
| 80 DartDOMWrapper::returnValue<Node*>(args, newChild); | |
| 81 return; | |
| 82 } | |
| 83 | |
| 84 fail: | |
| 85 Dart_ThrowException(exception); | |
| 86 ASSERT_NOT_REACHED(); | |
| 87 } | |
| 88 | |
| 89 // This function is customized to take advantage of the optional 4th argument: s
houldLazyAttach. | |
| 90 void replaceChildCallback(Dart_NativeArguments args) | |
| 91 { | |
| 92 DartApiScope dartApiScope; | |
| 93 Dart_Handle exception; | |
| 94 { | |
| 95 Node* receiver = DartDOMWrapper::receiver<Node>(args); | |
| 96 | |
| 97 const ParameterAdapter<RefPtr<Node>, DartNode> newChild(Dart_GetNativeAr
gument(args, 1)); | |
| 98 if (!newChild.conversionSuccessful()) { | |
| 99 exception = newChild.exception(); | |
| 100 goto fail; | |
| 101 } | |
| 102 | |
| 103 const ParameterAdapter<RefPtr<Node>, DartNode> oldChild(Dart_GetNativeAr
gument(args, 2)); | |
| 104 if (!oldChild.conversionSuccessful()) { | |
| 105 exception = oldChild.exception(); | |
| 106 goto fail; | |
| 107 } | |
| 108 | |
| 109 ExceptionCode ec = 0; | |
| 110 bool success = receiver->replaceChild(newChild, oldChild, ec, true); | |
| 111 if (ec) { | |
| 112 exception = DartDOMWrapper::exceptionCodeToDartException(ec); | |
| 113 goto fail; | |
| 114 } | |
| 115 | |
| 116 if (success) | |
| 117 DartDOMWrapper::returnValue<Node*>(args, newChild); | |
| 118 return; | |
| 119 } | |
| 120 | |
| 121 fail: | |
| 122 Dart_ThrowException(exception); | |
| 123 ASSERT_NOT_REACHED(); | |
| 124 } | |
| 125 | |
| 126 // Custom handling of the return value. | |
| 127 void removeChildCallback(Dart_NativeArguments args) | |
| 128 { | |
| 129 DartApiScope dartApiScope; | |
| 130 Dart_Handle exception; | |
| 131 { | |
| 132 Node* receiver = DartDOMWrapper::receiver<Node>(args); | |
| 133 | |
| 134 const ParameterAdapter<RefPtr<Node>, DartNode> child(Dart_GetNativeArgum
ent(args, 1)); | |
| 135 if (!child.conversionSuccessful()) { | |
| 136 exception = child.exception(); | |
| 137 goto fail; | |
| 138 } | |
| 139 | |
| 140 ExceptionCode ec = 0; | |
| 141 bool success = receiver->removeChild(child, ec); | |
| 142 if (ec) { | |
| 143 exception = DartDOMWrapper::exceptionCodeToDartException(ec); | |
| 144 goto fail; | |
| 145 } | |
| 146 | |
| 147 if (success) | |
| 148 DartDOMWrapper::returnValue<Node*>(args, child); | |
| 149 return; | |
| 150 } | |
| 151 | |
| 152 fail: | |
| 153 Dart_ThrowException(exception); | |
| 154 ASSERT_NOT_REACHED(); | |
| 155 } | |
| 156 | |
| 157 // This function is customized to enable lazy attaching - see the last argument
to appendChild. | |
| 158 void appendChildCallback(Dart_NativeArguments args) | |
| 159 { | |
| 160 DartApiScope dartApiScope; | |
| 161 Dart_Handle exception; | |
| 162 { | |
| 163 Node* receiver = DartDOMWrapper::receiver<Node>(args); | |
| 164 | |
| 165 const ParameterAdapter<RefPtr<Node>, DartNode> child(Dart_GetNativeArgum
ent(args, 1)); | |
| 166 if (!child.conversionSuccessful()) { | |
| 167 exception = child.exception(); | |
| 168 goto fail; | |
| 169 } | |
| 170 | |
| 171 ExceptionCode ec = 0; | |
| 172 bool success = receiver->appendChild(child, ec, true); | |
| 173 if (ec) { | |
| 174 exception = DartDOMWrapper::exceptionCodeToDartException(ec); | |
| 175 goto fail; | |
| 176 } | |
| 177 | |
| 178 if (success) | |
| 179 DartDOMWrapper::returnValue<Node*>(args, child); | |
| 180 return; | |
| 181 } | |
| 182 | |
| 183 fail: | |
| 184 Dart_ThrowException(exception); | |
| 185 ASSERT_NOT_REACHED(); | |
| 186 } | |
| 187 | |
| 188 } | |
| 189 | |
| 190 Dart_Handle toDartValue(Node* node) | |
| 191 { | |
| 192 if (!node) | |
| 193 return 0; | |
| 194 | |
| 195 switch (node->nodeType()) { | |
| 196 case Node::ELEMENT_NODE: | |
| 197 return toDartValue(static_cast<Element*>(node)); | |
| 198 case Node::ATTRIBUTE_NODE: | |
| 199 return toDartValue(static_cast<Attr*>(node)); | |
| 200 case Node::TEXT_NODE: | |
| 201 return toDartValue(static_cast<Text*>(node)); | |
| 202 case Node::CDATA_SECTION_NODE: | |
| 203 return toDartValue(static_cast<CDATASection*>(node)); | |
| 204 case Node::ENTITY_REFERENCE_NODE: | |
| 205 return toDartValue(static_cast<EntityReference*>(node)); | |
| 206 case Node::ENTITY_NODE: | |
| 207 return toDartValue(static_cast<Entity*>(node)); | |
| 208 case Node::PROCESSING_INSTRUCTION_NODE: | |
| 209 return toDartValue(static_cast<ProcessingInstruction*>(node)); | |
| 210 case Node::COMMENT_NODE: | |
| 211 return toDartValue(static_cast<Comment*>(node)); | |
| 212 case Node::DOCUMENT_NODE: | |
| 213 return toDartValue(static_cast<Document*>(node)); | |
| 214 case Node::DOCUMENT_TYPE_NODE: | |
| 215 return toDartValue(static_cast<DocumentType*>(node)); | |
| 216 case Node::DOCUMENT_FRAGMENT_NODE: | |
| 217 return toDartValue(static_cast<DocumentFragment*>(node)); | |
| 218 case Node::NOTATION_NODE: | |
| 219 return toDartValue(static_cast<Notation*>(node)); | |
| 220 case Node::SHADOW_ROOT_NODE: // There's no IDL class for ShadowRoot, fall-th
rough to default and use Node instead. | |
| 221 default: break; // XPATH_NAMESPACE_NODE | |
| 222 } | |
| 223 return DartDOMWrapper::toDart<DartNode>(node); | |
| 224 } | |
| 225 | |
| 226 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
