Line data Source code
1 : /* THIS FILE IS AUTOGENERATED FROM WebComponents.webidl BY Codegen.py - DO NOT EDIT */
2 :
3 : #ifndef mozilla_dom_WebComponentsBinding_h
4 : #define mozilla_dom_WebComponentsBinding_h
5 :
6 : #include "js/RootingAPI.h"
7 : #include "jspubtd.h"
8 : #include "mozilla/ErrorResult.h"
9 : #include "mozilla/dom/BindingDeclarations.h"
10 : #include "mozilla/dom/CallbackFunction.h"
11 : #include "mozilla/dom/Nullable.h"
12 : #include "mozilla/dom/ToJSValue.h"
13 :
14 : namespace mozilla {
15 : namespace dom {
16 :
17 : struct ElementRegistrationOptionsAtoms;
18 : class LifecycleAttachedCallback;
19 : class LifecycleAttributeChangedCallback;
20 : struct LifecycleCallbacksAtoms;
21 : class LifecycleCreatedCallback;
22 : class LifecycleDetachedCallback;
23 : struct NativePropertyHooks;
24 : class ProtoAndIfaceCache;
25 :
26 : } // namespace dom
27 : } // namespace mozilla
28 :
29 : namespace mozilla {
30 : namespace dom {
31 :
32 0 : struct ElementRegistrationOptions : public DictionaryBase
33 : {
34 : MOZ_INIT_OUTSIDE_CTOR nsString mExtends;
35 : MOZ_INIT_OUTSIDE_CTOR JSObject* mPrototype;
36 :
37 : ElementRegistrationOptions();
38 :
39 0 : explicit inline ElementRegistrationOptions(const FastDictionaryInitializer& )
40 0 : : mPrototype(nullptr)
41 : {
42 : // Do nothing here; this is used by our "Fast" subclass
43 0 : }
44 :
45 : private:
46 : ElementRegistrationOptions(const ElementRegistrationOptions&) = delete;
47 : ElementRegistrationOptions& operator=(const ElementRegistrationOptions&) = delete;
48 :
49 : static bool
50 : InitIds(JSContext* cx, ElementRegistrationOptionsAtoms* atomsCache);
51 :
52 : public:
53 : bool
54 : Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
55 :
56 : bool
57 : ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
58 :
59 : void
60 : TraceDictionary(JSTracer* trc);
61 : };
62 :
63 : namespace binding_detail {
64 0 : struct FastElementRegistrationOptions : public ElementRegistrationOptions
65 : {
66 0 : inline FastElementRegistrationOptions()
67 0 : : ElementRegistrationOptions(FastDictionaryInitializer())
68 : {
69 : // Doesn't matter what int we pass to the parent constructor
70 0 : }
71 : };
72 : } // namespace binding_detail
73 :
74 :
75 0 : struct LifecycleCallbacks : public DictionaryBase
76 : {
77 : MOZ_INIT_OUTSIDE_CTOR Optional<RefPtr<LifecycleAttachedCallback>> mAttachedCallback;
78 : MOZ_INIT_OUTSIDE_CTOR Optional<RefPtr<LifecycleAttributeChangedCallback>> mAttributeChangedCallback;
79 : MOZ_INIT_OUTSIDE_CTOR Optional<RefPtr<LifecycleCreatedCallback>> mCreatedCallback;
80 : MOZ_INIT_OUTSIDE_CTOR Optional<RefPtr<LifecycleDetachedCallback>> mDetachedCallback;
81 :
82 : LifecycleCallbacks();
83 :
84 : explicit inline LifecycleCallbacks(const FastDictionaryInitializer& )
85 : {
86 : // Do nothing here; this is used by our "Fast" subclass
87 : }
88 :
89 : private:
90 : LifecycleCallbacks(const LifecycleCallbacks&) = delete;
91 : LifecycleCallbacks& operator=(const LifecycleCallbacks&) = delete;
92 :
93 : static bool
94 : InitIds(JSContext* cx, LifecycleCallbacksAtoms* atomsCache);
95 :
96 : public:
97 : bool
98 : Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
99 :
100 : bool
101 : ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
102 :
103 : void
104 : TraceDictionary(JSTracer* trc);
105 : };
106 :
107 : namespace binding_detail {
108 : struct FastLifecycleCallbacks : public LifecycleCallbacks
109 : {
110 : inline FastLifecycleCallbacks()
111 : : LifecycleCallbacks(FastDictionaryInitializer())
112 : {
113 : // Doesn't matter what int we pass to the parent constructor
114 : }
115 : };
116 : } // namespace binding_detail
117 :
118 :
119 0 : class LifecycleCreatedCallback : public CallbackFunction
120 : {
121 : public:
122 0 : explicit inline LifecycleCreatedCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
123 0 : : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
124 : {
125 0 : MOZ_ASSERT(JS::IsCallable(mCallback));
126 0 : }
127 :
128 : explicit inline LifecycleCreatedCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
129 : : CallbackFunction(aCallback, FastCallbackConstructor())
130 : {
131 : MOZ_ASSERT(JS::IsCallable(mCallback));
132 : }
133 :
134 : explicit inline LifecycleCreatedCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
135 : : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
136 : {
137 : MOZ_ASSERT(JS::IsCallable(mCallback));
138 : }
139 :
140 : explicit inline LifecycleCreatedCallback(CallbackFunction* aOther)
141 : : CallbackFunction(aOther)
142 : {
143 : }
144 :
145 : template <typename T>
146 : inline void
147 0 : Call(const T& thisVal, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
148 : {
149 0 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
150 0 : if (!aExecutionReason) {
151 0 : aExecutionReason = "LifecycleCreatedCallback";
152 : }
153 0 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
154 0 : if (!s.GetContext()) {
155 0 : MOZ_ASSERT(aRv.Failed());
156 0 : return;
157 : }
158 0 : JS::Rooted<JS::Value> thisValJS(s.GetContext());
159 0 : if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
160 0 : aRv.Throw(NS_ERROR_FAILURE);
161 0 : return;
162 : }
163 0 : return Call(s.GetContext(), thisValJS, aRv);
164 : }
165 :
166 : inline void
167 : Call(ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
168 : {
169 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
170 : if (!aExecutionReason) {
171 : aExecutionReason = "LifecycleCreatedCallback";
172 : }
173 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
174 : if (!s.GetContext()) {
175 : MOZ_ASSERT(aRv.Failed());
176 : return;
177 : }
178 : return Call(s.GetContext(), JS::UndefinedHandleValue, aRv);
179 : }
180 :
181 : template <typename T>
182 : inline void
183 : Call(const T& thisVal, const char* aExecutionReason = nullptr)
184 : {
185 : IgnoredErrorResult rv;
186 : return Call(thisVal, rv, aExecutionReason);
187 : }
188 :
189 : inline void
190 : Call(const char* aExecutionReason = nullptr)
191 : {
192 : IgnoredErrorResult rv;
193 : return Call(rv, aExecutionReason, eReportExceptions, nullptr);
194 : }
195 :
196 : inline bool
197 : operator==(const LifecycleCreatedCallback& aOther) const
198 : {
199 : return CallbackFunction::operator==(aOther);
200 : }
201 :
202 : private:
203 : void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, ErrorResult& aRv);
204 : };
205 :
206 :
207 0 : class LifecycleAttachedCallback : public CallbackFunction
208 : {
209 : public:
210 0 : explicit inline LifecycleAttachedCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
211 0 : : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
212 : {
213 0 : MOZ_ASSERT(JS::IsCallable(mCallback));
214 0 : }
215 :
216 : explicit inline LifecycleAttachedCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
217 : : CallbackFunction(aCallback, FastCallbackConstructor())
218 : {
219 : MOZ_ASSERT(JS::IsCallable(mCallback));
220 : }
221 :
222 : explicit inline LifecycleAttachedCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
223 : : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
224 : {
225 : MOZ_ASSERT(JS::IsCallable(mCallback));
226 : }
227 :
228 : explicit inline LifecycleAttachedCallback(CallbackFunction* aOther)
229 : : CallbackFunction(aOther)
230 : {
231 : }
232 :
233 : template <typename T>
234 : inline void
235 0 : Call(const T& thisVal, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
236 : {
237 0 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
238 0 : if (!aExecutionReason) {
239 0 : aExecutionReason = "LifecycleAttachedCallback";
240 : }
241 0 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
242 0 : if (!s.GetContext()) {
243 0 : MOZ_ASSERT(aRv.Failed());
244 0 : return;
245 : }
246 0 : JS::Rooted<JS::Value> thisValJS(s.GetContext());
247 0 : if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
248 0 : aRv.Throw(NS_ERROR_FAILURE);
249 0 : return;
250 : }
251 0 : return Call(s.GetContext(), thisValJS, aRv);
252 : }
253 :
254 : inline void
255 : Call(ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
256 : {
257 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
258 : if (!aExecutionReason) {
259 : aExecutionReason = "LifecycleAttachedCallback";
260 : }
261 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
262 : if (!s.GetContext()) {
263 : MOZ_ASSERT(aRv.Failed());
264 : return;
265 : }
266 : return Call(s.GetContext(), JS::UndefinedHandleValue, aRv);
267 : }
268 :
269 : template <typename T>
270 : inline void
271 : Call(const T& thisVal, const char* aExecutionReason = nullptr)
272 : {
273 : IgnoredErrorResult rv;
274 : return Call(thisVal, rv, aExecutionReason);
275 : }
276 :
277 : inline void
278 : Call(const char* aExecutionReason = nullptr)
279 : {
280 : IgnoredErrorResult rv;
281 : return Call(rv, aExecutionReason, eReportExceptions, nullptr);
282 : }
283 :
284 : inline bool
285 : operator==(const LifecycleAttachedCallback& aOther) const
286 : {
287 : return CallbackFunction::operator==(aOther);
288 : }
289 :
290 : private:
291 : void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, ErrorResult& aRv);
292 : };
293 :
294 :
295 0 : class LifecycleDetachedCallback : public CallbackFunction
296 : {
297 : public:
298 0 : explicit inline LifecycleDetachedCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
299 0 : : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
300 : {
301 0 : MOZ_ASSERT(JS::IsCallable(mCallback));
302 0 : }
303 :
304 : explicit inline LifecycleDetachedCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
305 : : CallbackFunction(aCallback, FastCallbackConstructor())
306 : {
307 : MOZ_ASSERT(JS::IsCallable(mCallback));
308 : }
309 :
310 : explicit inline LifecycleDetachedCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
311 : : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
312 : {
313 : MOZ_ASSERT(JS::IsCallable(mCallback));
314 : }
315 :
316 : explicit inline LifecycleDetachedCallback(CallbackFunction* aOther)
317 : : CallbackFunction(aOther)
318 : {
319 : }
320 :
321 : template <typename T>
322 : inline void
323 0 : Call(const T& thisVal, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
324 : {
325 0 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
326 0 : if (!aExecutionReason) {
327 0 : aExecutionReason = "LifecycleDetachedCallback";
328 : }
329 0 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
330 0 : if (!s.GetContext()) {
331 0 : MOZ_ASSERT(aRv.Failed());
332 0 : return;
333 : }
334 0 : JS::Rooted<JS::Value> thisValJS(s.GetContext());
335 0 : if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
336 0 : aRv.Throw(NS_ERROR_FAILURE);
337 0 : return;
338 : }
339 0 : return Call(s.GetContext(), thisValJS, aRv);
340 : }
341 :
342 : inline void
343 : Call(ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
344 : {
345 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
346 : if (!aExecutionReason) {
347 : aExecutionReason = "LifecycleDetachedCallback";
348 : }
349 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
350 : if (!s.GetContext()) {
351 : MOZ_ASSERT(aRv.Failed());
352 : return;
353 : }
354 : return Call(s.GetContext(), JS::UndefinedHandleValue, aRv);
355 : }
356 :
357 : template <typename T>
358 : inline void
359 : Call(const T& thisVal, const char* aExecutionReason = nullptr)
360 : {
361 : IgnoredErrorResult rv;
362 : return Call(thisVal, rv, aExecutionReason);
363 : }
364 :
365 : inline void
366 : Call(const char* aExecutionReason = nullptr)
367 : {
368 : IgnoredErrorResult rv;
369 : return Call(rv, aExecutionReason, eReportExceptions, nullptr);
370 : }
371 :
372 : inline bool
373 : operator==(const LifecycleDetachedCallback& aOther) const
374 : {
375 : return CallbackFunction::operator==(aOther);
376 : }
377 :
378 : private:
379 : void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, ErrorResult& aRv);
380 : };
381 :
382 :
383 0 : class LifecycleAttributeChangedCallback : public CallbackFunction
384 : {
385 : public:
386 0 : explicit inline LifecycleAttributeChangedCallback(JSContext* aCx, JS::Handle<JSObject*> aCallback, nsIGlobalObject* aIncumbentGlobal)
387 0 : : CallbackFunction(aCx, aCallback, aIncumbentGlobal)
388 : {
389 0 : MOZ_ASSERT(JS::IsCallable(mCallback));
390 0 : }
391 :
392 : explicit inline LifecycleAttributeChangedCallback(JS::Handle<JSObject*> aCallback, const FastCallbackConstructor& )
393 : : CallbackFunction(aCallback, FastCallbackConstructor())
394 : {
395 : MOZ_ASSERT(JS::IsCallable(mCallback));
396 : }
397 :
398 : explicit inline LifecycleAttributeChangedCallback(JS::Handle<JSObject*> aCallback, JS::Handle<JSObject*> aAsyncStack, nsIGlobalObject* aIncumbentGlobal)
399 : : CallbackFunction(aCallback, aAsyncStack, aIncumbentGlobal)
400 : {
401 : MOZ_ASSERT(JS::IsCallable(mCallback));
402 : }
403 :
404 : explicit inline LifecycleAttributeChangedCallback(CallbackFunction* aOther)
405 : : CallbackFunction(aOther)
406 : {
407 : }
408 :
409 : template <typename T>
410 : inline void
411 0 : Call(const T& thisVal, const nsAString& attrName, const nsAString& oldValue, const nsAString& newValue, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
412 : {
413 0 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
414 0 : if (!aExecutionReason) {
415 0 : aExecutionReason = "LifecycleAttributeChangedCallback";
416 : }
417 0 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
418 0 : if (!s.GetContext()) {
419 0 : MOZ_ASSERT(aRv.Failed());
420 0 : return;
421 : }
422 0 : JS::Rooted<JS::Value> thisValJS(s.GetContext());
423 0 : if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
424 0 : aRv.Throw(NS_ERROR_FAILURE);
425 0 : return;
426 : }
427 0 : return Call(s.GetContext(), thisValJS, attrName, oldValue, newValue, aRv);
428 : }
429 :
430 : inline void
431 : Call(const nsAString& attrName, const nsAString& oldValue, const nsAString& newValue, ErrorResult& aRv, const char* aExecutionReason = nullptr, ExceptionHandling aExceptionHandling = eReportExceptions, JSCompartment* aCompartment = nullptr)
432 : {
433 : MOZ_ASSERT(!aRv.Failed(), "Don't pass an already-failed ErrorResult to a callback!");
434 : if (!aExecutionReason) {
435 : aExecutionReason = "LifecycleAttributeChangedCallback";
436 : }
437 : CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
438 : if (!s.GetContext()) {
439 : MOZ_ASSERT(aRv.Failed());
440 : return;
441 : }
442 : return Call(s.GetContext(), JS::UndefinedHandleValue, attrName, oldValue, newValue, aRv);
443 : }
444 :
445 : template <typename T>
446 : inline void
447 : Call(const T& thisVal, const nsAString& attrName, const nsAString& oldValue, const nsAString& newValue, const char* aExecutionReason = nullptr)
448 : {
449 : IgnoredErrorResult rv;
450 : return Call(thisVal, attrName, oldValue, newValue, rv, aExecutionReason);
451 : }
452 :
453 : inline void
454 : Call(const nsAString& attrName, const nsAString& oldValue, const nsAString& newValue, const char* aExecutionReason = nullptr)
455 : {
456 : IgnoredErrorResult rv;
457 : return Call(attrName, oldValue, newValue, rv, aExecutionReason, eReportExceptions, nullptr);
458 : }
459 :
460 : inline bool
461 : operator==(const LifecycleAttributeChangedCallback& aOther) const
462 : {
463 : return CallbackFunction::operator==(aOther);
464 : }
465 :
466 : private:
467 : void Call(JSContext* cx, JS::Handle<JS::Value> aThisVal, const nsAString& attrName, const nsAString& oldValue, const nsAString& newValue, ErrorResult& aRv);
468 : };
469 :
470 :
471 : namespace binding_detail {
472 : class FastLifecycleCreatedCallback : public LifecycleCreatedCallback
473 : {
474 : public:
475 : explicit inline FastLifecycleCreatedCallback(JS::Handle<JSObject*> aCallback)
476 : : LifecycleCreatedCallback(aCallback, FastCallbackConstructor())
477 : {
478 : }
479 :
480 : inline void
481 : Trace(JSTracer* aTracer)
482 : {
483 : LifecycleCreatedCallback::Trace(aTracer);
484 : }
485 :
486 : inline void
487 : FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
488 : {
489 : LifecycleCreatedCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
490 : }
491 : };
492 : } // namespace binding_detail
493 :
494 :
495 : namespace binding_detail {
496 : class FastLifecycleAttachedCallback : public LifecycleAttachedCallback
497 : {
498 : public:
499 : explicit inline FastLifecycleAttachedCallback(JS::Handle<JSObject*> aCallback)
500 : : LifecycleAttachedCallback(aCallback, FastCallbackConstructor())
501 : {
502 : }
503 :
504 : inline void
505 : Trace(JSTracer* aTracer)
506 : {
507 : LifecycleAttachedCallback::Trace(aTracer);
508 : }
509 :
510 : inline void
511 : FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
512 : {
513 : LifecycleAttachedCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
514 : }
515 : };
516 : } // namespace binding_detail
517 :
518 :
519 : namespace binding_detail {
520 : class FastLifecycleDetachedCallback : public LifecycleDetachedCallback
521 : {
522 : public:
523 : explicit inline FastLifecycleDetachedCallback(JS::Handle<JSObject*> aCallback)
524 : : LifecycleDetachedCallback(aCallback, FastCallbackConstructor())
525 : {
526 : }
527 :
528 : inline void
529 : Trace(JSTracer* aTracer)
530 : {
531 : LifecycleDetachedCallback::Trace(aTracer);
532 : }
533 :
534 : inline void
535 : FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
536 : {
537 : LifecycleDetachedCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
538 : }
539 : };
540 : } // namespace binding_detail
541 :
542 :
543 : namespace binding_detail {
544 : class FastLifecycleAttributeChangedCallback : public LifecycleAttributeChangedCallback
545 : {
546 : public:
547 : explicit inline FastLifecycleAttributeChangedCallback(JS::Handle<JSObject*> aCallback)
548 : : LifecycleAttributeChangedCallback(aCallback, FastCallbackConstructor())
549 : {
550 : }
551 :
552 : inline void
553 : Trace(JSTracer* aTracer)
554 : {
555 : LifecycleAttributeChangedCallback::Trace(aTracer);
556 : }
557 :
558 : inline void
559 : FinishSlowJSInitIfMoreThanOneOwner(JSContext* aCx)
560 : {
561 : LifecycleAttributeChangedCallback::FinishSlowJSInitIfMoreThanOneOwner(aCx);
562 : }
563 : };
564 : } // namespace binding_detail
565 :
566 :
567 : } // namespace dom
568 : } // namespace mozilla
569 :
570 : #endif // mozilla_dom_WebComponentsBinding_h
|
