Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(69)

Side by Side Diff: third_party/WebKit/Source/bindings/templates/union_container.cpp

Issue 1961883002: Generate separate files for union type containers (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 {% from 'utilities.cpp' import declare_enum_validation_variable %} 1 {% from 'utilities.cpp' import declare_enum_validation_variable %}
2 {% include 'copyright_block.txt' %} 2 {% include 'copyright_block.txt' %}
3 #include "{{header_filename}}" 3 #include "{{cpp_class}}.h"
4 4
5 {% from 'utilities.cpp' import v8_value_to_local_cpp_value %} 5 {% from 'utilities.cpp' import v8_value_to_local_cpp_value %}
6 {% macro assign_and_return_if_hasinstance(member) %} 6 {% macro assign_and_return_if_hasinstance(member) %}
7 if (V8{{member.type_name}}::hasInstance(v8Value, isolate)) { 7 if (V8{{member.type_name}}::hasInstance(v8Value, isolate)) {
8 {{member.cpp_local_type}} cppValue = V8{{member.type_name}}::toImpl(v8::Loca l<v8::Object>::Cast(v8Value)); 8 {{member.cpp_local_type}} cppValue = V8{{member.type_name}}::toImpl(v8::Loca l<v8::Object>::Cast(v8Value));
9 impl.set{{member.type_name}}(cppValue); 9 impl.set{{member.type_name}}(cppValue);
10 return; 10 return;
11 } 11 }
12 {% endmacro %} 12 {% endmacro %}
13 {% for filename in cpp_includes %} 13 {% for filename in cpp_includes %}
14 #include "{{filename}}" 14 #include "{{filename}}"
15 {% endfor %} 15 {% endfor %}
16 16
17 namespace blink { 17 namespace blink {
18 18
19 {% for container in containers %} 19 {{cpp_class}}::{{cpp_class}}()
20 {{container.cpp_class}}::{{container.cpp_class}}()
21 : m_type(SpecificTypeNone) 20 : m_type(SpecificTypeNone)
22 { 21 {
23 } 22 }
24 23
25 {% for member in container.members %} 24 {% for member in members %}
26 {{member.rvalue_cpp_type}} {{container.cpp_class}}::getAs{{member.type_name}}() const 25 {{member.rvalue_cpp_type}} {{cpp_class}}::getAs{{member.type_name}}() const
27 { 26 {
28 ASSERT(is{{member.type_name}}()); 27 ASSERT(is{{member.type_name}}());
29 return m_{{member.cpp_name}}; 28 return m_{{member.cpp_name}};
30 } 29 }
31 30
32 void {{container.cpp_class}}::set{{member.type_name}}({{member.rvalue_cpp_type}} value) 31 void {{cpp_class}}::set{{member.type_name}}({{member.rvalue_cpp_type}} value)
33 { 32 {
34 ASSERT(isNull()); 33 ASSERT(isNull());
35 {% if member.enum_values %} 34 {% if member.enum_values %}
36 NonThrowableExceptionState exceptionState; 35 NonThrowableExceptionState exceptionState;
37 {{declare_enum_validation_variable(member.enum_values) | indent}} 36 {{declare_enum_validation_variable(member.enum_values) | indent}}
38 if (!isValidEnum(value, validValues, WTF_ARRAY_LENGTH(validValues), "{{membe r.type_name}}", exceptionState)) { 37 if (!isValidEnum(value, validValues, WTF_ARRAY_LENGTH(validValues), "{{membe r.type_name}}", exceptionState)) {
39 ASSERT_NOT_REACHED(); 38 ASSERT_NOT_REACHED();
40 return; 39 return;
41 } 40 }
42 {% endif %} 41 {% endif %}
43 m_{{member.cpp_name}} = value; 42 m_{{member.cpp_name}} = value;
44 m_type = {{member.specific_type_enum}}; 43 m_type = {{member.specific_type_enum}};
45 } 44 }
46 45
47 {{container.cpp_class}} {{container.cpp_class}}::from{{member.type_name}}({{memb er.rvalue_cpp_type}} value) 46 {{cpp_class}} {{cpp_class}}::from{{member.type_name}}({{member.rvalue_cpp_type}} value)
48 { 47 {
49 {{container.cpp_class}} container; 48 {{cpp_class}} container;
50 container.set{{member.type_name}}(value); 49 container.set{{member.type_name}}(value);
51 return container; 50 return container;
52 } 51 }
53 52
54 {% endfor %} 53 {% endfor %}
55 {{container.cpp_class}}::{{container.cpp_class}}(const {{container.cpp_class}}&) = default; 54 {{cpp_class}}::{{cpp_class}}(const {{cpp_class}}&) = default;
56 {{container.cpp_class}}::~{{container.cpp_class}}() = default; 55 {{cpp_class}}::~{{cpp_class}}() = default;
57 {{container.cpp_class}}& {{container.cpp_class}}::operator=(const {{container.cp p_class}}&) = default; 56 {{cpp_class}}& {{cpp_class}}::operator=(const {{cpp_class}}&) = default;
58 57
59 DEFINE_TRACE({{container.cpp_class}}) 58 DEFINE_TRACE({{cpp_class}})
60 { 59 {
61 {% for member in container.members if member.is_traceable %} 60 {% for member in members if member.is_traceable %}
62 visitor->trace(m_{{member.cpp_name}}); 61 visitor->trace(m_{{member.cpp_name}});
63 {% endfor %} 62 {% endfor %}
64 } 63 }
65 64
66 void V8{{container.cpp_class}}::toImpl(v8::Isolate* isolate, v8::Local<v8::Value > v8Value, {{container.cpp_class}}& impl, UnionTypeConversionMode conversionMode , ExceptionState& exceptionState) 65 void {{v8_class}}::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, {{ cpp_class}}& impl, UnionTypeConversionMode conversionMode, ExceptionState& excep tionState)
67 { 66 {
68 if (v8Value.IsEmpty()) 67 if (v8Value.IsEmpty())
69 return; 68 return;
70 69
71 {# The numbers in the following comments refer to the steps described in 70 {# The numbers in the following comments refer to the steps described in
72 http://heycam.github.io/webidl/#es-union #} 71 http://heycam.github.io/webidl/#es-union #}
73 {# 1. null or undefined #} 72 {# 1. null or undefined #}
74 if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull (v8Value)) 73 if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull (v8Value))
75 return; 74 return;
76 75
77 {# 3. Platform objects (interfaces) #} 76 {# 3. Platform objects (interfaces) #}
78 {% for interface in container.interface_types %} 77 {% for interface in interface_types %}
79 {{assign_and_return_if_hasinstance(interface) | indent}} 78 {{assign_and_return_if_hasinstance(interface) | indent}}
80 79
81 {% endfor %} 80 {% endfor %}
82 {# 8. ArrayBuffer #} 81 {# 8. ArrayBuffer #}
83 {% if container.array_buffer_type %} 82 {% if array_buffer_type %}
84 {{assign_and_return_if_hasinstance(container.array_buffer_type) | indent}} 83 {{assign_and_return_if_hasinstance(array_buffer_type) | indent}}
85 84
86 {% endif %} 85 {% endif %}
87 {# 9., 10. ArrayBufferView #} 86 {# 9., 10. ArrayBufferView #}
88 {# FIXME: Individual typed arrays (e.g. Uint8Array) aren't supported yet. #} 87 {# FIXME: Individual typed arrays (e.g. Uint8Array) aren't supported yet. #}
89 {% if container.array_buffer_view_type %} 88 {% if array_buffer_view_type %}
90 {{assign_and_return_if_hasinstance(container.array_buffer_view_type) | inden t}} 89 {{assign_and_return_if_hasinstance(array_buffer_view_type) | indent}}
91 90
92 {% endif %} 91 {% endif %}
93 {% if container.dictionary_type %} 92 {% if dictionary_type %}
94 {# 12. Dictionaries #} 93 {# 12. Dictionaries #}
95 {# FIXME: This should also check "object but not Date or RegExp". Add checks 94 {# FIXME: This should also check "object but not Date or RegExp". Add checks
96 when we implement conversions for Date and RegExp. #} 95 when we implement conversions for Date and RegExp. #}
97 if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) { 96 if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) {
98 {{v8_value_to_local_cpp_value(container.dictionary_type) | indent(8)}} 97 {{v8_value_to_local_cpp_value(dictionary_type) | indent(8)}}
99 impl.set{{container.dictionary_type.type_name}}(cppValue); 98 impl.set{{dictionary_type.type_name}}(cppValue);
100 return; 99 return;
101 } 100 }
102 101
103 {% endif %} 102 {% endif %}
104 {% if container.array_or_sequence_type %} 103 {% if array_or_sequence_type %}
105 {# 13.1, 13.2. Arrays and Sequences #} 104 {# 13.1, 13.2. Arrays and Sequences #}
106 {# FIXME: This should also check "object but not Date or RegExp". Add checks 105 {# FIXME: This should also check "object but not Date or RegExp". Add checks
107 when we implement conversions for Date and RegExp. #} 106 when we implement conversions for Date and RegExp. #}
108 {# FIXME: Should check for sequences too, not just Array instances. #} 107 {# FIXME: Should check for sequences too, not just Array instances. #}
109 if (v8Value->IsArray()) { 108 if (v8Value->IsArray()) {
110 {{v8_value_to_local_cpp_value(container.array_or_sequence_type) | indent (8)}} 109 {{v8_value_to_local_cpp_value(array_or_sequence_type) | indent(8)}}
111 impl.set{{container.array_or_sequence_type.type_name}}(cppValue); 110 impl.set{{array_or_sequence_type.type_name}}(cppValue);
112 return; 111 return;
113 } 112 }
114 113
115 {% endif %} 114 {% endif %}
116 {# TODO(bashi): Support 13.3 Callback interface when we need it #} 115 {# TODO(bashi): Support 13.3 Callback interface when we need it #}
117 {# 13.4. Objects #} 116 {# 13.4. Objects #}
118 {% if container.object_type %} 117 {% if object_type %}
119 if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) { 118 if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) {
120 {{v8_value_to_local_cpp_value(container.object_type) | indent(8)}} 119 {{v8_value_to_local_cpp_value(object_type) | indent(8)}}
121 impl.set{{container.object_type.type_name}}(cppValue); 120 impl.set{{object_type.type_name}}(cppValue);
122 return; 121 return;
123 } 122 }
124 123
125 {% endif %} 124 {% endif %}
126 {# FIXME: In some cases, we can omit boolean and numeric type checks because 125 {# FIXME: In some cases, we can omit boolean and numeric type checks because
127 we have fallback conversions. (step 17 and 18) #} 126 we have fallback conversions. (step 17 and 18) #}
128 {% if container.boolean_type %} 127 {% if boolean_type %}
129 {# 14. Boolean #} 128 {# 14. Boolean #}
130 if (v8Value->IsBoolean()) { 129 if (v8Value->IsBoolean()) {
131 impl.setBoolean(v8Value.As<v8::Boolean>()->Value()); 130 impl.setBoolean(v8Value.As<v8::Boolean>()->Value());
132 return; 131 return;
133 } 132 }
134 133
135 {% endif %} 134 {% endif %}
136 {% if container.numeric_type %} 135 {% if numeric_type %}
137 {# 15. Number #} 136 {# 15. Number #}
138 if (v8Value->IsNumber()) { 137 if (v8Value->IsNumber()) {
139 {{v8_value_to_local_cpp_value(container.numeric_type) | indent(8)}} 138 {{v8_value_to_local_cpp_value(numeric_type) | indent(8)}}
140 impl.set{{container.numeric_type.type_name}}(cppValue); 139 impl.set{{numeric_type.type_name}}(cppValue);
141 return; 140 return;
142 } 141 }
143 142
144 {% endif %} 143 {% endif %}
145 {% if container.string_type %} 144 {% if string_type %}
146 {# 16. String #} 145 {# 16. String #}
147 { 146 {
148 {{v8_value_to_local_cpp_value(container.string_type) | indent(8)}} 147 {{v8_value_to_local_cpp_value(string_type) | indent(8)}}
149 {% if container.string_type.enum_values %} 148 {% if string_type.enum_values %}
150 {{declare_enum_validation_variable(container.string_type.enum_values) | indent(8)}} 149 {{declare_enum_validation_variable(string_type.enum_values) | indent(8)} }
151 if (!isValidEnum(cppValue, validValues, WTF_ARRAY_LENGTH(validValues), " {{container.string_type.type_name}}", exceptionState)) 150 if (!isValidEnum(cppValue, validValues, WTF_ARRAY_LENGTH(validValues), " {{string_type.type_name}}", exceptionState))
152 return; 151 return;
153 {% endif %} 152 {% endif %}
154 impl.set{{container.string_type.type_name}}(cppValue); 153 impl.set{{string_type.type_name}}(cppValue);
155 return; 154 return;
156 } 155 }
157 156
158 {# 17. Number (fallback) #} 157 {# 17. Number (fallback) #}
159 {% elif container.numeric_type %} 158 {% elif numeric_type %}
160 { 159 {
161 {{v8_value_to_local_cpp_value(container.numeric_type) | indent(8)}} 160 {{v8_value_to_local_cpp_value(numeric_type) | indent(8)}}
162 impl.set{{container.numeric_type.type_name}}(cppValue); 161 impl.set{{numeric_type.type_name}}(cppValue);
163 return; 162 return;
164 } 163 }
165 164
166 {# 18. Boolean (fallback) #} 165 {# 18. Boolean (fallback) #}
167 {% elif container.boolean_type %} 166 {% elif boolean_type %}
168 { 167 {
169 impl.setBoolean(v8Value->BooleanValue()); 168 impl.setBoolean(v8Value->BooleanValue());
170 return; 169 return;
171 } 170 }
172 171
173 {% else %} 172 {% else %}
174 {# 19. TypeError #} 173 {# 19. TypeError #}
175 exceptionState.throwTypeError("The provided value is not of type '{{containe r.type_string}}'"); 174 exceptionState.throwTypeError("The provided value is not of type '{{type_str ing}}'");
176 {% endif %} 175 {% endif %}
177 } 176 }
178 177
179 v8::Local<v8::Value> toV8(const {{container.cpp_class}}& impl, v8::Local<v8::Obj ect> creationContext, v8::Isolate* isolate) 178 v8::Local<v8::Value> toV8(const {{cpp_class}}& impl, v8::Local<v8::Object> creat ionContext, v8::Isolate* isolate)
180 { 179 {
181 switch (impl.m_type) { 180 switch (impl.m_type) {
182 case {{container.cpp_class}}::SpecificTypeNone: 181 case {{cpp_class}}::SpecificTypeNone:
183 {# FIXME: We might want to return undefined in some cases #} 182 {# FIXME: We might want to return undefined in some cases #}
184 return v8::Null(isolate); 183 return v8::Null(isolate);
185 {% for member in container.members %} 184 {% for member in members %}
186 case {{container.cpp_class}}::{{member.specific_type_enum}}: 185 case {{cpp_class}}::{{member.specific_type_enum}}:
187 return {{member.cpp_value_to_v8_value}}; 186 return {{member.cpp_value_to_v8_value}};
188 {% endfor %} 187 {% endfor %}
189 default: 188 default:
190 ASSERT_NOT_REACHED(); 189 ASSERT_NOT_REACHED();
191 } 190 }
192 return v8::Local<v8::Value>(); 191 return v8::Local<v8::Value>();
193 } 192 }
194 193
195 {{container.cpp_class}} NativeValueTraits<{{container.cpp_class}}>::nativeValue( v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState ) 194 {{cpp_class}} NativeValueTraits<{{cpp_class}}>::nativeValue(v8::Isolate* isolate , v8::Local<v8::Value> value, ExceptionState& exceptionState)
196 { 195 {
197 {{container.cpp_class}} impl; 196 {{cpp_class}} impl;
198 V8{{container.cpp_class}}::toImpl(isolate, value, impl, UnionTypeConversionM ode::NotNullable, exceptionState); 197 {{v8_class}}::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNulla ble, exceptionState);
199 return impl; 198 return impl;
200 } 199 }
201 200
202 {% endfor %}
203 } // namespace blink 201 } // namespace blink
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698