1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CustomElementTestHelpers_h
#define CustomElementTestHelpers_h
#include "bindings/core/v8/ExceptionState.h"
#include "core/dom/Document.h"
#include "core/dom/Element.h"
#include "core/dom/ElementDefinitionOptions.h"
#include "core/dom/QualifiedName.h"
#include "core/dom/custom/CEReactionsScope.h"
#include "core/dom/custom/CustomElementDefinition.h"
#include "core/dom/custom/CustomElementDefinitionBuilder.h"
#include "core/html/HTMLDocument.h"
#include "platform/heap/Handle.h"
#include "wtf/text/AtomicString.h"
#include <utility>
#include <vector>
namespace blink {
class CustomElementDescriptor;
class TestCustomElementDefinitionBuilder
: public CustomElementDefinitionBuilder {
STACK_ALLOCATED();
WTF_MAKE_NONCOPYABLE(TestCustomElementDefinitionBuilder);
public:
TestCustomElementDefinitionBuilder() {}
bool checkConstructorIntrinsics() override { return true; }
bool checkConstructorNotRegistered() override { return true; }
bool checkPrototype() override { return true; }
bool rememberOriginalProperties() override { return true; }
CustomElementDefinition* build(const CustomElementDescriptor&) override;
};
class TestCustomElementDefinition : public CustomElementDefinition {
WTF_MAKE_NONCOPYABLE(TestCustomElementDefinition);
public:
TestCustomElementDefinition(const CustomElementDescriptor& descriptor)
: CustomElementDefinition(descriptor) {}
TestCustomElementDefinition(const CustomElementDescriptor& descriptor,
const HashSet<AtomicString>& observedAttributes)
: CustomElementDefinition(descriptor, observedAttributes) {}
~TestCustomElementDefinition() override = default;
ScriptValue getConstructorForScript() override { return ScriptValue(); }
bool runConstructor(Element* element) override {
if (constructionStack().isEmpty() || constructionStack().back() != element)
return false;
constructionStack().back().clear();
return true;
}
HTMLElement* createElementSync(Document& document,
const QualifiedName&) override {
return createElementForConstructor(document);
}
bool hasConnectedCallback() const override { return false; }
bool hasDisconnectedCallback() const override { return false; }
bool hasAdoptedCallback() const override { return false; }
void runConnectedCallback(Element*) override {
NOTREACHED() << "definition does not have connected callback";
}
void runDisconnectedCallback(Element*) override {
NOTREACHED() << "definition does not have disconnected callback";
}
void runAdoptedCallback(Element*,
Document* oldOwner,
Document* newOwner) override {
NOTREACHED() << "definition does not have adopted callback";
}
void runAttributeChangedCallback(Element*,
const QualifiedName&,
const AtomicString& oldValue,
const AtomicString& newValue) override {
NOTREACHED() << "definition does not have attribute changed callback";
}
};
class CreateElement {
STACK_ALLOCATED()
public:
CreateElement(const AtomicString& localName)
: m_namespaceURI(HTMLNames::xhtmlNamespaceURI), m_localName(localName) {}
CreateElement& inDocument(Document* document) {
m_document = document;
return *this;
}
CreateElement& inNamespace(const AtomicString& uri) {
m_namespaceURI = uri;
return *this;
}
CreateElement& withId(const AtomicString& id) {
m_attributes.push_back(std::make_pair(HTMLNames::idAttr, id));
return *this;
}
CreateElement& withIsAttribute(const AtomicString& value) {
m_attributes.push_back(std::make_pair(HTMLNames::isAttr, value));
return *this;
}
operator Element*() const {
Document* document = m_document.get();
if (!document)
document = HTMLDocument::create();
NonThrowableExceptionState noExceptions;
Element* element =
document->createElementNS(m_namespaceURI, m_localName, noExceptions);
for (const auto& attribute : m_attributes)
element->setAttribute(attribute.first, attribute.second);
return element;
}
private:
Member<Document> m_document;
AtomicString m_namespaceURI;
AtomicString m_localName;
std::vector<std::pair<QualifiedName, AtomicString>> m_attributes;
};
} // namespace blink
#endif // CustomElementTestHelpers_h
|
