1use crate::codegen::DomTypes::DomTypes;
4use crate::codegen::GenericBindings::AudioContextBinding::AudioContextLatencyCategory;
5use crate::codegen::GenericBindings::AudioContextBinding::AudioContextLatencyCategoryValues;
6use crate::codegen::GenericBindings::DocumentBinding::ElementCreationOptions;
7use crate::codegen::GenericBindings::ElementBinding::ScrollIntoViewOptions;
8use crate::codegen::GenericBindings::EventTargetBinding::AddEventListenerOptions;
9use crate::codegen::GenericBindings::EventTargetBinding::EventListenerOptions;
10use crate::codegen::GenericBindings::FunctionBinding::Function;
11use crate::codegen::GenericBindings::MediaDevicesBinding::ConstrainDoubleRange;
12use crate::codegen::GenericBindings::MediaDevicesBinding::ConstrainULongRange;
13use crate::codegen::GenericBindings::MediaDevicesBinding::MediaTrackConstraints;
14use crate::codegen::GenericBindings::PasswordCredentialBinding::PasswordCredentialData;
15use crate::codegen::GenericBindings::SubtleCryptoBinding::JsonWebKey;
16use crate::codegen::GenericBindings::TestBindingBinding::NotUsedAnyWhereElse;
17use crate::codegen::GenericBindings::TestBindingBinding::TestDictionary;
18use crate::codegen::GenericBindings::URLPatternBinding::URLPatternInit;
19use crate::codegen::GenericBindings::VTTCueBinding::AutoKeyword;
20use crate::codegen::GenericBindings::VTTCueBinding::AutoKeywordValues;
21use crate::codegen::GenericBindings::WebGPUBinding::GPUAutoLayoutMode;
22use crate::codegen::GenericBindings::WebGPUBinding::GPUAutoLayoutModeValues;
23use crate::codegen::GenericBindings::WebGPUBinding::GPUBufferBinding;
24use crate::codegen::GenericBindings::WebGPUBinding::GPUColorDict;
25use crate::codegen::GenericBindings::WebGPUBinding::GPUExtent3DDict;
26use crate::codegen::GenericBindings::WebGPUBinding::GPUOrigin2DDict;
27use crate::codegen::GenericBindings::WebGPUBinding::GPUOrigin3DDict;
28use crate::conversions::windowproxy_from_handlevalue;
29use crate::import::base::*;
30use crate::record::Record;
31use js::typedarray;
32
33
34#[derive(JSTraceable)]
35pub enum AddEventListenerOptionsOrBoolean<D: DomTypes> {
36 AddEventListenerOptions(AddEventListenerOptions<D>),
37 Boolean(bool),
38}
39
40impl<D: DomTypes> ToJSValConvertible for AddEventListenerOptionsOrBoolean<D> {
41 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
42 match *self {
43 AddEventListenerOptionsOrBoolean::AddEventListenerOptions(ref inner) => inner.to_jsval(cx, rval),
44 AddEventListenerOptionsOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
45 }
46 }
47}
48
49
50
51impl<D: DomTypes> FromJSValConvertible for AddEventListenerOptionsOrBoolean<D> {
52 type Config = ();
53 unsafe fn from_jsval(cx: *mut RawJSContext,
54 value: HandleValue,
55 _option: ())
56 -> Result<ConversionResult<AddEventListenerOptionsOrBoolean<D>>, ()> {
57 match AddEventListenerOptionsOrBoolean::<D>::TryConvertToAddEventListenerOptions(SafeJSContext::from_ptr(cx), value) {
58 Err(_) => return Err(()),
59 Ok(Some(value)) => return Ok(ConversionResult::Success(AddEventListenerOptionsOrBoolean::AddEventListenerOptions(value))),
60 Ok(None) => (),
61 }
62
63
64 match AddEventListenerOptionsOrBoolean::<D>::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
65 Err(_) => return Err(()),
66 Ok(Some(value)) => return Ok(ConversionResult::Success(AddEventListenerOptionsOrBoolean::Boolean(value))),
67 Ok(None) => (),
68 }
69
70
71 Ok(ConversionResult::Failure("argument could not be converted to any of: AddEventListenerOptions".into()))
72 }
73}
74
75impl<D: DomTypes> AddEventListenerOptionsOrBoolean<D> {
76 unsafe fn TryConvertToAddEventListenerOptions(cx: SafeJSContext, value: HandleValue) -> Result<Option<AddEventListenerOptions<D>>, ()> {
77 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
78 Ok(ConversionResult::Success(value)) => value,
79 Ok(ConversionResult::Failure(error)) => {
80 return Ok(None);
81 }
82 _ => {
83 return Err(());
84 },
85 }
86 ))
87 }
88
89 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
90 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
91 Ok(ConversionResult::Success(value)) => value,
92 Ok(ConversionResult::Failure(error)) => {
93 return Ok(None);
94 }
95 _ => {
96 return Err(());
97 },
98 }
99 ))
100 }
101}
102
103
104
105#[derive(JSTraceable)]
106pub enum ArrayBufferOrArrayBufferView {
107 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
108 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
109}
110
111impl ToJSValConvertible for ArrayBufferOrArrayBufferView {
112 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
113 match *self {
114 ArrayBufferOrArrayBufferView::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
115 ArrayBufferOrArrayBufferView::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
116 }
117 }
118}
119
120
121
122impl FromJSValConvertible for ArrayBufferOrArrayBufferView {
123 type Config = ();
124 unsafe fn from_jsval(cx: *mut RawJSContext,
125 value: HandleValue,
126 _option: ())
127 -> Result<ConversionResult<ArrayBufferOrArrayBufferView>, ()> {
128 if value.get().is_object() {
129 match ArrayBufferOrArrayBufferView::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
130 Err(_) => return Err(()),
131 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferOrArrayBufferView::ArrayBuffer(value))),
132 Ok(None) => (),
133 }
134 match ArrayBufferOrArrayBufferView::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
135 Err(_) => return Err(()),
136 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferOrArrayBufferView::ArrayBufferView(value))),
137 Ok(None) => (),
138 }
139
140 }
141
142 Ok(ConversionResult::Failure("argument could not be converted to any of: ArrayBuffer, ArrayBufferView".into()))
143 }
144}
145
146impl ArrayBufferOrArrayBufferView {
147 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
148 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
149 Ok(val) => val,
150 Err(()) => {
151 return Ok(None);
152 }
153 }
154 ))
155 }
156
157 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
158 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
159 Ok(val) => val,
160 Err(()) => {
161 return Ok(None);
162 }
163 }
164 ))
165 }
166}
167
168
169
170#[derive(JSTraceable)]
171pub enum ArrayBufferOrArrayBufferViewOrBlobOrString<D: DomTypes> {
172 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
173 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
174 Blob(DomRoot<D::Blob>),
175 String(DOMString),
176}
177
178impl<D: DomTypes> ToJSValConvertible for ArrayBufferOrArrayBufferViewOrBlobOrString<D> {
179 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
180 match *self {
181 ArrayBufferOrArrayBufferViewOrBlobOrString::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
182 ArrayBufferOrArrayBufferViewOrBlobOrString::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
183 ArrayBufferOrArrayBufferViewOrBlobOrString::Blob(ref inner) => inner.to_jsval(cx, rval),
184 ArrayBufferOrArrayBufferViewOrBlobOrString::String(ref inner) => inner.to_jsval(cx, rval),
185 }
186 }
187}
188
189
190
191impl<D: DomTypes> FromJSValConvertible for ArrayBufferOrArrayBufferViewOrBlobOrString<D> {
192 type Config = ();
193 unsafe fn from_jsval(cx: *mut RawJSContext,
194 value: HandleValue,
195 _option: ())
196 -> Result<ConversionResult<ArrayBufferOrArrayBufferViewOrBlobOrString<D>>, ()> {
197 if value.get().is_object() {
198 match ArrayBufferOrArrayBufferViewOrBlobOrString::<D>::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
199 Err(_) => return Err(()),
200 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferOrArrayBufferViewOrBlobOrString::ArrayBuffer(value))),
201 Ok(None) => (),
202 }
203 match ArrayBufferOrArrayBufferViewOrBlobOrString::<D>::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
204 Err(_) => return Err(()),
205 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferOrArrayBufferViewOrBlobOrString::ArrayBufferView(value))),
206 Ok(None) => (),
207 }
208 match ArrayBufferOrArrayBufferViewOrBlobOrString::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
209 Err(_) => return Err(()),
210 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferOrArrayBufferViewOrBlobOrString::Blob(value))),
211 Ok(None) => (),
212 }
213
214 }
215
216 match ArrayBufferOrArrayBufferViewOrBlobOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
217 Err(_) => return Err(()),
218 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferOrArrayBufferViewOrBlobOrString::String(value))),
219 Ok(None) => (),
220 }
221
222
223 Ok(ConversionResult::Failure("argument could not be converted to any of: ArrayBuffer, ArrayBufferView, Blob".into()))
224 }
225}
226
227impl<D: DomTypes> ArrayBufferOrArrayBufferViewOrBlobOrString<D> {
228 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
229 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
230 Ok(val) => val,
231 Err(()) => {
232 return Ok(None);
233 }
234 }
235 ))
236 }
237
238 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
239 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
240 Ok(val) => val,
241 Err(()) => {
242 return Ok(None);
243 }
244 }
245 ))
246 }
247
248 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
249 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
250 Ok(val) => val,
251 Err(()) => {
252 return Ok(None);
253 }
254 }
255 ))
256 }
257
258 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
259 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
260 Ok(ConversionResult::Success(value)) => value,
261 Ok(ConversionResult::Failure(error)) => {
262 return Ok(None);
263 }
264 _ => {
265 return Err(());
266 },
267 }
268 ))
269 }
270}
271
272
273
274#[derive(JSTraceable)]
275pub enum ArrayBufferViewOrArrayBuffer {
276 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
277 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
278}
279
280impl ToJSValConvertible for ArrayBufferViewOrArrayBuffer {
281 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
282 match *self {
283 ArrayBufferViewOrArrayBuffer::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
284 ArrayBufferViewOrArrayBuffer::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
285 }
286 }
287}
288
289
290
291impl FromJSValConvertible for ArrayBufferViewOrArrayBuffer {
292 type Config = ();
293 unsafe fn from_jsval(cx: *mut RawJSContext,
294 value: HandleValue,
295 _option: ())
296 -> Result<ConversionResult<ArrayBufferViewOrArrayBuffer>, ()> {
297 if value.get().is_object() {
298 match ArrayBufferViewOrArrayBuffer::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
299 Err(_) => return Err(()),
300 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferViewOrArrayBuffer::ArrayBufferView(value))),
301 Ok(None) => (),
302 }
303 match ArrayBufferViewOrArrayBuffer::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
304 Err(_) => return Err(()),
305 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferViewOrArrayBuffer::ArrayBuffer(value))),
306 Ok(None) => (),
307 }
308
309 }
310
311 Ok(ConversionResult::Failure("argument could not be converted to any of: ArrayBufferView, ArrayBuffer".into()))
312 }
313}
314
315impl ArrayBufferViewOrArrayBuffer {
316 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
317 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
318 Ok(val) => val,
319 Err(()) => {
320 return Ok(None);
321 }
322 }
323 ))
324 }
325
326 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
327 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
328 Ok(val) => val,
329 Err(()) => {
330 return Ok(None);
331 }
332 }
333 ))
334 }
335}
336
337
338
339#[derive(JSTraceable)]
340pub enum ArrayBufferViewOrArrayBufferOrJsonWebKey {
341 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
342 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
343 JsonWebKey(JsonWebKey),
344}
345
346impl ToJSValConvertible for ArrayBufferViewOrArrayBufferOrJsonWebKey {
347 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
348 match *self {
349 ArrayBufferViewOrArrayBufferOrJsonWebKey::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
350 ArrayBufferViewOrArrayBufferOrJsonWebKey::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
351 ArrayBufferViewOrArrayBufferOrJsonWebKey::JsonWebKey(ref inner) => inner.to_jsval(cx, rval),
352 }
353 }
354}
355
356
357
358impl FromJSValConvertible for ArrayBufferViewOrArrayBufferOrJsonWebKey {
359 type Config = ();
360 unsafe fn from_jsval(cx: *mut RawJSContext,
361 value: HandleValue,
362 _option: ())
363 -> Result<ConversionResult<ArrayBufferViewOrArrayBufferOrJsonWebKey>, ()> {
364 if value.get().is_object() {
365 match ArrayBufferViewOrArrayBufferOrJsonWebKey::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
366 Err(_) => return Err(()),
367 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferViewOrArrayBufferOrJsonWebKey::ArrayBufferView(value))),
368 Ok(None) => (),
369 }
370 match ArrayBufferViewOrArrayBufferOrJsonWebKey::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
371 Err(_) => return Err(()),
372 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferViewOrArrayBufferOrJsonWebKey::ArrayBuffer(value))),
373 Ok(None) => (),
374 }
375
376 }
377
378 match ArrayBufferViewOrArrayBufferOrJsonWebKey::TryConvertToJsonWebKey(SafeJSContext::from_ptr(cx), value) {
379 Err(_) => return Err(()),
380 Ok(Some(value)) => return Ok(ConversionResult::Success(ArrayBufferViewOrArrayBufferOrJsonWebKey::JsonWebKey(value))),
381 Ok(None) => (),
382 }
383
384
385 Ok(ConversionResult::Failure("argument could not be converted to any of: ArrayBufferView, ArrayBuffer, JsonWebKey".into()))
386 }
387}
388
389impl ArrayBufferViewOrArrayBufferOrJsonWebKey {
390 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
391 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
392 Ok(val) => val,
393 Err(()) => {
394 return Ok(None);
395 }
396 }
397 ))
398 }
399
400 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
401 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
402 Ok(val) => val,
403 Err(()) => {
404 return Ok(None);
405 }
406 }
407 ))
408 }
409
410 unsafe fn TryConvertToJsonWebKey(cx: SafeJSContext, value: HandleValue) -> Result<Option<JsonWebKey>, ()> {
411 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
412 Ok(ConversionResult::Success(value)) => value,
413 Ok(ConversionResult::Failure(error)) => {
414 return Ok(None);
415 }
416 _ => {
417 return Err(());
418 },
419 }
420 ))
421 }
422}
423
424
425
426#[derive(JSTraceable)]
427pub enum AudioContextLatencyCategoryOrDouble {
428 AudioContextLatencyCategory(AudioContextLatencyCategory),
429 Double(Finite<f64>),
430}
431
432impl ToJSValConvertible for AudioContextLatencyCategoryOrDouble {
433 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
434 match *self {
435 AudioContextLatencyCategoryOrDouble::AudioContextLatencyCategory(ref inner) => inner.to_jsval(cx, rval),
436 AudioContextLatencyCategoryOrDouble::Double(ref inner) => inner.to_jsval(cx, rval),
437 }
438 }
439}
440
441
442
443impl FromJSValConvertible for AudioContextLatencyCategoryOrDouble {
444 type Config = ();
445 unsafe fn from_jsval(cx: *mut RawJSContext,
446 value: HandleValue,
447 _option: ())
448 -> Result<ConversionResult<AudioContextLatencyCategoryOrDouble>, ()> {
449 if value.get().is_number() {
450 match AudioContextLatencyCategoryOrDouble::TryConvertToDouble(SafeJSContext::from_ptr(cx), value) {
451 Err(_) => return Err(()),
452 Ok(Some(value)) => return Ok(ConversionResult::Success(AudioContextLatencyCategoryOrDouble::Double(value))),
453 Ok(None) => (),
454 }
455
456 }
457
458 match AudioContextLatencyCategoryOrDouble::TryConvertToAudioContextLatencyCategory(SafeJSContext::from_ptr(cx), value) {
459 Err(_) => return Err(()),
460 Ok(Some(value)) => return Ok(ConversionResult::Success(AudioContextLatencyCategoryOrDouble::AudioContextLatencyCategory(value))),
461 Ok(None) => (),
462 }
463
464
465 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
466 }
467}
468
469impl AudioContextLatencyCategoryOrDouble {
470 unsafe fn TryConvertToAudioContextLatencyCategory(cx: SafeJSContext, value: HandleValue) -> Result<Option<AudioContextLatencyCategory>, ()> {
471 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
472 Ok(ConversionResult::Success(value)) => value,
473 Ok(ConversionResult::Failure(error)) => {
474 return Ok(None);
475 }
476 _ => {
477 return Err(());
478 },
479 }
480 ))
481 }
482
483 unsafe fn TryConvertToDouble(cx: SafeJSContext, value: HandleValue) -> Result<Option<Finite<f64>>, ()> {
484 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
485 Ok(ConversionResult::Success(value)) => value,
486 Ok(ConversionResult::Failure(error)) => {
487 return Ok(None);
488 }
489 _ => {
490 return Err(());
491 },
492 }
493 ))
494 }
495}
496
497
498
499#[derive(JSTraceable)]
500pub enum BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D: DomTypes> {
501 Blob(DomRoot<D::Blob>),
502 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
503 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
504 FormData(DomRoot<D::FormData>),
505 String(DOMString),
506 URLSearchParams(DomRoot<D::URLSearchParams>),
507}
508
509impl<D: DomTypes> ToJSValConvertible for BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
510 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
511 match *self {
512 BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Blob(ref inner) => inner.to_jsval(cx, rval),
513 BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
514 BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
515 BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::FormData(ref inner) => inner.to_jsval(cx, rval),
516 BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::String(ref inner) => inner.to_jsval(cx, rval),
517 BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::URLSearchParams(ref inner) => inner.to_jsval(cx, rval),
518 }
519 }
520}
521
522
523
524impl<D: DomTypes> FromJSValConvertible for BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
525 type Config = ();
526 unsafe fn from_jsval(cx: *mut RawJSContext,
527 value: HandleValue,
528 _option: ())
529 -> Result<ConversionResult<BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D>>, ()> {
530 if value.get().is_object() {
531 match BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
532 Err(_) => return Err(()),
533 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Blob(value))),
534 Ok(None) => (),
535 }
536 match BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
537 Err(_) => return Err(()),
538 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBufferView(value))),
539 Ok(None) => (),
540 }
541 match BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
542 Err(_) => return Err(()),
543 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBuffer(value))),
544 Ok(None) => (),
545 }
546 match BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToFormData(SafeJSContext::from_ptr(cx), value) {
547 Err(_) => return Err(()),
548 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::FormData(value))),
549 Ok(None) => (),
550 }
551 match BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToURLSearchParams(SafeJSContext::from_ptr(cx), value) {
552 Err(_) => return Err(()),
553 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::URLSearchParams(value))),
554 Ok(None) => (),
555 }
556
557 }
558
559 match BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
560 Err(_) => return Err(()),
561 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::String(value))),
562 Ok(None) => (),
563 }
564
565
566 Ok(ConversionResult::Failure("argument could not be converted to any of: Blob, ArrayBufferView, ArrayBuffer, FormData, URLSearchParams".into()))
567 }
568}
569
570impl<D: DomTypes> BlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
571 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
572 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
573 Ok(val) => val,
574 Err(()) => {
575 return Ok(None);
576 }
577 }
578 ))
579 }
580
581 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
582 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
583 Ok(val) => val,
584 Err(()) => {
585 return Ok(None);
586 }
587 }
588 ))
589 }
590
591 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
592 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
593 Ok(val) => val,
594 Err(()) => {
595 return Ok(None);
596 }
597 }
598 ))
599 }
600
601 unsafe fn TryConvertToFormData(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::FormData>>, ()> {
602 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
603 Ok(val) => val,
604 Err(()) => {
605 return Ok(None);
606 }
607 }
608 ))
609 }
610
611 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
612 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
613 Ok(ConversionResult::Success(value)) => value,
614 Ok(ConversionResult::Failure(error)) => {
615 return Ok(None);
616 }
617 _ => {
618 return Err(());
619 },
620 }
621 ))
622 }
623
624 unsafe fn TryConvertToURLSearchParams(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::URLSearchParams>>, ()> {
625 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
626 Ok(val) => val,
627 Err(()) => {
628 return Ok(None);
629 }
630 }
631 ))
632 }
633}
634
635
636
637#[derive(JSTraceable)]
638pub enum BlobOrBlobSequence<D: DomTypes> {
639 Blob(DomRoot<D::Blob>),
640 BlobSequence(Vec<DomRoot<D::Blob>>),
641}
642
643impl<D: DomTypes> ToJSValConvertible for BlobOrBlobSequence<D> {
644 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
645 match *self {
646 BlobOrBlobSequence::Blob(ref inner) => inner.to_jsval(cx, rval),
647 BlobOrBlobSequence::BlobSequence(ref inner) => inner.to_jsval(cx, rval),
648 }
649 }
650}
651
652
653
654impl<D: DomTypes> FromJSValConvertible for BlobOrBlobSequence<D> {
655 type Config = ();
656 unsafe fn from_jsval(cx: *mut RawJSContext,
657 value: HandleValue,
658 _option: ())
659 -> Result<ConversionResult<BlobOrBlobSequence<D>>, ()> {
660 if value.get().is_object() {
661 match BlobOrBlobSequence::<D>::TryConvertToBlobSequence(SafeJSContext::from_ptr(cx), value) {
662 Err(_) => return Err(()),
663 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrBlobSequence::BlobSequence(value))),
664 Ok(None) => (),
665 }
666
667 match BlobOrBlobSequence::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
668 Err(_) => return Err(()),
669 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrBlobSequence::Blob(value))),
670 Ok(None) => (),
671 }
672
673 }
674
675 Ok(ConversionResult::Failure("argument could not be converted to any of: Blob, BlobSequence".into()))
676 }
677}
678
679impl<D: DomTypes> BlobOrBlobSequence<D> {
680 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
681 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
682 Ok(val) => val,
683 Err(()) => {
684 return Ok(None);
685 }
686 }
687 ))
688 }
689
690 unsafe fn TryConvertToBlobSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<DomRoot<D::Blob>>>, ()> {
691 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
692 Ok(ConversionResult::Success(value)) => value,
693 Ok(ConversionResult::Failure(error)) => {
694 return Ok(None);
695 }
696 _ => {
697 return Err(());
698 },
699 }
700 ))
701 }
702}
703
704
705
706#[derive(JSTraceable)]
707pub enum BlobOrBoolean<D: DomTypes> {
708 Blob(DomRoot<D::Blob>),
709 Boolean(bool),
710}
711
712impl<D: DomTypes> ToJSValConvertible for BlobOrBoolean<D> {
713 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
714 match *self {
715 BlobOrBoolean::Blob(ref inner) => inner.to_jsval(cx, rval),
716 BlobOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
717 }
718 }
719}
720
721
722
723impl<D: DomTypes> FromJSValConvertible for BlobOrBoolean<D> {
724 type Config = ();
725 unsafe fn from_jsval(cx: *mut RawJSContext,
726 value: HandleValue,
727 _option: ())
728 -> Result<ConversionResult<BlobOrBoolean<D>>, ()> {
729 if value.get().is_object() {
730 match BlobOrBoolean::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
731 Err(_) => return Err(()),
732 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrBoolean::Blob(value))),
733 Ok(None) => (),
734 }
735
736 }
737
738 match BlobOrBoolean::<D>::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
739 Err(_) => return Err(()),
740 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrBoolean::Boolean(value))),
741 Ok(None) => (),
742 }
743
744
745 Ok(ConversionResult::Failure("argument could not be converted to any of: Blob".into()))
746 }
747}
748
749impl<D: DomTypes> BlobOrBoolean<D> {
750 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
751 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
752 Ok(val) => val,
753 Err(()) => {
754 return Ok(None);
755 }
756 }
757 ))
758 }
759
760 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
761 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
762 Ok(ConversionResult::Success(value)) => value,
763 Ok(ConversionResult::Failure(error)) => {
764 return Ok(None);
765 }
766 _ => {
767 return Err(());
768 },
769 }
770 ))
771 }
772}
773
774
775
776#[derive(JSTraceable)]
777pub enum BlobOrString<D: DomTypes> {
778 Blob(DomRoot<D::Blob>),
779 String(DOMString),
780}
781
782impl<D: DomTypes> ToJSValConvertible for BlobOrString<D> {
783 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
784 match *self {
785 BlobOrString::Blob(ref inner) => inner.to_jsval(cx, rval),
786 BlobOrString::String(ref inner) => inner.to_jsval(cx, rval),
787 }
788 }
789}
790
791
792
793impl<D: DomTypes> FromJSValConvertible for BlobOrString<D> {
794 type Config = ();
795 unsafe fn from_jsval(cx: *mut RawJSContext,
796 value: HandleValue,
797 _option: ())
798 -> Result<ConversionResult<BlobOrString<D>>, ()> {
799 if value.get().is_object() {
800 match BlobOrString::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
801 Err(_) => return Err(()),
802 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrString::Blob(value))),
803 Ok(None) => (),
804 }
805
806 }
807
808 match BlobOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
809 Err(_) => return Err(()),
810 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrString::String(value))),
811 Ok(None) => (),
812 }
813
814
815 Ok(ConversionResult::Failure("argument could not be converted to any of: Blob".into()))
816 }
817}
818
819impl<D: DomTypes> BlobOrString<D> {
820 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
821 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
822 Ok(val) => val,
823 Err(()) => {
824 return Ok(None);
825 }
826 }
827 ))
828 }
829
830 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
831 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
832 Ok(ConversionResult::Success(value)) => value,
833 Ok(ConversionResult::Failure(error)) => {
834 return Ok(None);
835 }
836 _ => {
837 return Err(());
838 },
839 }
840 ))
841 }
842}
843
844
845
846#[derive(JSTraceable)]
847pub enum BlobOrUnsignedLong<D: DomTypes> {
848 Blob(DomRoot<D::Blob>),
849 UnsignedLong(u32),
850}
851
852impl<D: DomTypes> ToJSValConvertible for BlobOrUnsignedLong<D> {
853 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
854 match *self {
855 BlobOrUnsignedLong::Blob(ref inner) => inner.to_jsval(cx, rval),
856 BlobOrUnsignedLong::UnsignedLong(ref inner) => inner.to_jsval(cx, rval),
857 }
858 }
859}
860
861
862
863impl<D: DomTypes> FromJSValConvertible for BlobOrUnsignedLong<D> {
864 type Config = ();
865 unsafe fn from_jsval(cx: *mut RawJSContext,
866 value: HandleValue,
867 _option: ())
868 -> Result<ConversionResult<BlobOrUnsignedLong<D>>, ()> {
869 if value.get().is_object() {
870 match BlobOrUnsignedLong::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
871 Err(_) => return Err(()),
872 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrUnsignedLong::Blob(value))),
873 Ok(None) => (),
874 }
875
876 }
877
878 match BlobOrUnsignedLong::<D>::TryConvertToUnsignedLong(SafeJSContext::from_ptr(cx), value) {
879 Err(_) => return Err(()),
880 Ok(Some(value)) => return Ok(ConversionResult::Success(BlobOrUnsignedLong::UnsignedLong(value))),
881 Ok(None) => (),
882 }
883
884
885 Ok(ConversionResult::Failure("argument could not be converted to any of: Blob".into()))
886 }
887}
888
889impl<D: DomTypes> BlobOrUnsignedLong<D> {
890 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
891 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
892 Ok(val) => val,
893 Err(()) => {
894 return Ok(None);
895 }
896 }
897 ))
898 }
899
900 unsafe fn TryConvertToUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
901 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
902 Ok(ConversionResult::Success(value)) => value,
903 Ok(ConversionResult::Failure(error)) => {
904 return Ok(None);
905 }
906 _ => {
907 return Err(());
908 },
909 }
910 ))
911 }
912}
913
914
915
916#[derive(JSTraceable)]
917pub enum BooleanOrMediaTrackConstraints {
918 Boolean(bool),
919 MediaTrackConstraints(MediaTrackConstraints),
920}
921
922impl ToJSValConvertible for BooleanOrMediaTrackConstraints {
923 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
924 match *self {
925 BooleanOrMediaTrackConstraints::Boolean(ref inner) => inner.to_jsval(cx, rval),
926 BooleanOrMediaTrackConstraints::MediaTrackConstraints(ref inner) => inner.to_jsval(cx, rval),
927 }
928 }
929}
930
931
932
933impl FromJSValConvertible for BooleanOrMediaTrackConstraints {
934 type Config = ();
935 unsafe fn from_jsval(cx: *mut RawJSContext,
936 value: HandleValue,
937 _option: ())
938 -> Result<ConversionResult<BooleanOrMediaTrackConstraints>, ()> {
939 match BooleanOrMediaTrackConstraints::TryConvertToMediaTrackConstraints(SafeJSContext::from_ptr(cx), value) {
940 Err(_) => return Err(()),
941 Ok(Some(value)) => return Ok(ConversionResult::Success(BooleanOrMediaTrackConstraints::MediaTrackConstraints(value))),
942 Ok(None) => (),
943 }
944
945
946 match BooleanOrMediaTrackConstraints::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
947 Err(_) => return Err(()),
948 Ok(Some(value)) => return Ok(ConversionResult::Success(BooleanOrMediaTrackConstraints::Boolean(value))),
949 Ok(None) => (),
950 }
951
952
953 Ok(ConversionResult::Failure("argument could not be converted to any of: MediaTrackConstraints".into()))
954 }
955}
956
957impl BooleanOrMediaTrackConstraints {
958 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
959 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
960 Ok(ConversionResult::Success(value)) => value,
961 Ok(ConversionResult::Failure(error)) => {
962 return Ok(None);
963 }
964 _ => {
965 return Err(());
966 },
967 }
968 ))
969 }
970
971 unsafe fn TryConvertToMediaTrackConstraints(cx: SafeJSContext, value: HandleValue) -> Result<Option<MediaTrackConstraints>, ()> {
972 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
973 Ok(ConversionResult::Success(value)) => value,
974 Ok(ConversionResult::Failure(error)) => {
975 return Ok(None);
976 }
977 _ => {
978 return Err(());
979 },
980 }
981 ))
982 }
983}
984
985
986
987#[derive(JSTraceable)]
988pub enum BooleanOrScrollIntoViewOptions {
989 Boolean(bool),
990 ScrollIntoViewOptions(ScrollIntoViewOptions),
991}
992
993impl ToJSValConvertible for BooleanOrScrollIntoViewOptions {
994 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
995 match *self {
996 BooleanOrScrollIntoViewOptions::Boolean(ref inner) => inner.to_jsval(cx, rval),
997 BooleanOrScrollIntoViewOptions::ScrollIntoViewOptions(ref inner) => inner.to_jsval(cx, rval),
998 }
999 }
1000}
1001
1002
1003
1004impl FromJSValConvertible for BooleanOrScrollIntoViewOptions {
1005 type Config = ();
1006 unsafe fn from_jsval(cx: *mut RawJSContext,
1007 value: HandleValue,
1008 _option: ())
1009 -> Result<ConversionResult<BooleanOrScrollIntoViewOptions>, ()> {
1010 match BooleanOrScrollIntoViewOptions::TryConvertToScrollIntoViewOptions(SafeJSContext::from_ptr(cx), value) {
1011 Err(_) => return Err(()),
1012 Ok(Some(value)) => return Ok(ConversionResult::Success(BooleanOrScrollIntoViewOptions::ScrollIntoViewOptions(value))),
1013 Ok(None) => (),
1014 }
1015
1016
1017 match BooleanOrScrollIntoViewOptions::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
1018 Err(_) => return Err(()),
1019 Ok(Some(value)) => return Ok(ConversionResult::Success(BooleanOrScrollIntoViewOptions::Boolean(value))),
1020 Ok(None) => (),
1021 }
1022
1023
1024 Ok(ConversionResult::Failure("argument could not be converted to any of: ScrollIntoViewOptions".into()))
1025 }
1026}
1027
1028impl BooleanOrScrollIntoViewOptions {
1029 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
1030 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1031 Ok(ConversionResult::Success(value)) => value,
1032 Ok(ConversionResult::Failure(error)) => {
1033 return Ok(None);
1034 }
1035 _ => {
1036 return Err(());
1037 },
1038 }
1039 ))
1040 }
1041
1042 unsafe fn TryConvertToScrollIntoViewOptions(cx: SafeJSContext, value: HandleValue) -> Result<Option<ScrollIntoViewOptions>, ()> {
1043 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1044 Ok(ConversionResult::Success(value)) => value,
1045 Ok(ConversionResult::Failure(error)) => {
1046 return Ok(None);
1047 }
1048 _ => {
1049 return Err(());
1050 },
1051 }
1052 ))
1053 }
1054}
1055
1056
1057
1058#[derive(JSTraceable)]
1059pub enum ByteStringOrLong {
1060 ByteString(ByteString),
1061 Long(i32),
1062}
1063
1064impl ToJSValConvertible for ByteStringOrLong {
1065 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1066 match *self {
1067 ByteStringOrLong::ByteString(ref inner) => inner.to_jsval(cx, rval),
1068 ByteStringOrLong::Long(ref inner) => inner.to_jsval(cx, rval),
1069 }
1070 }
1071}
1072
1073
1074
1075impl FromJSValConvertible for ByteStringOrLong {
1076 type Config = ();
1077 unsafe fn from_jsval(cx: *mut RawJSContext,
1078 value: HandleValue,
1079 _option: ())
1080 -> Result<ConversionResult<ByteStringOrLong>, ()> {
1081 if value.get().is_number() {
1082 match ByteStringOrLong::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
1083 Err(_) => return Err(()),
1084 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringOrLong::Long(value))),
1085 Ok(None) => (),
1086 }
1087
1088 }
1089
1090 match ByteStringOrLong::TryConvertToByteString(SafeJSContext::from_ptr(cx), value) {
1091 Err(_) => return Err(()),
1092 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringOrLong::ByteString(value))),
1093 Ok(None) => (),
1094 }
1095
1096
1097 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
1098 }
1099}
1100
1101impl ByteStringOrLong {
1102 unsafe fn TryConvertToByteString(cx: SafeJSContext, value: HandleValue) -> Result<Option<ByteString>, ()> {
1103 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1104 Ok(ConversionResult::Success(value)) => value,
1105 Ok(ConversionResult::Failure(error)) => {
1106 return Ok(None);
1107 }
1108 _ => {
1109 return Err(());
1110 },
1111 }
1112 ))
1113 }
1114
1115 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
1116 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
1117 Ok(ConversionResult::Success(value)) => value,
1118 Ok(ConversionResult::Failure(error)) => {
1119 return Ok(None);
1120 }
1121 _ => {
1122 return Err(());
1123 },
1124 }
1125 ))
1126 }
1127}
1128
1129
1130
1131#[derive(JSTraceable)]
1132pub enum ByteStringSequenceOrLong {
1133 ByteStringSequence(Vec<ByteString>),
1134 Long(i32),
1135}
1136
1137impl ToJSValConvertible for ByteStringSequenceOrLong {
1138 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1139 match *self {
1140 ByteStringSequenceOrLong::ByteStringSequence(ref inner) => inner.to_jsval(cx, rval),
1141 ByteStringSequenceOrLong::Long(ref inner) => inner.to_jsval(cx, rval),
1142 }
1143 }
1144}
1145
1146
1147
1148impl FromJSValConvertible for ByteStringSequenceOrLong {
1149 type Config = ();
1150 unsafe fn from_jsval(cx: *mut RawJSContext,
1151 value: HandleValue,
1152 _option: ())
1153 -> Result<ConversionResult<ByteStringSequenceOrLong>, ()> {
1154 if value.get().is_object() {
1155 match ByteStringSequenceOrLong::TryConvertToByteStringSequence(SafeJSContext::from_ptr(cx), value) {
1156 Err(_) => return Err(()),
1157 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceOrLong::ByteStringSequence(value))),
1158 Ok(None) => (),
1159 }
1160
1161 }
1162
1163 match ByteStringSequenceOrLong::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
1164 Err(_) => return Err(()),
1165 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceOrLong::Long(value))),
1166 Ok(None) => (),
1167 }
1168
1169
1170 Ok(ConversionResult::Failure("argument could not be converted to any of: ByteStringSequence".into()))
1171 }
1172}
1173
1174impl ByteStringSequenceOrLong {
1175 unsafe fn TryConvertToByteStringSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<ByteString>>, ()> {
1176 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1177 Ok(ConversionResult::Success(value)) => value,
1178 Ok(ConversionResult::Failure(error)) => {
1179 return Ok(None);
1180 }
1181 _ => {
1182 return Err(());
1183 },
1184 }
1185 ))
1186 }
1187
1188 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
1189 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
1190 Ok(ConversionResult::Success(value)) => value,
1191 Ok(ConversionResult::Failure(error)) => {
1192 return Ok(None);
1193 }
1194 _ => {
1195 return Err(());
1196 },
1197 }
1198 ))
1199 }
1200}
1201
1202
1203
1204#[derive(JSTraceable)]
1205pub enum ByteStringSequenceOrLongOrString {
1206 ByteStringSequence(Vec<ByteString>),
1207 Long(i32),
1208 String(DOMString),
1209}
1210
1211impl ToJSValConvertible for ByteStringSequenceOrLongOrString {
1212 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1213 match *self {
1214 ByteStringSequenceOrLongOrString::ByteStringSequence(ref inner) => inner.to_jsval(cx, rval),
1215 ByteStringSequenceOrLongOrString::Long(ref inner) => inner.to_jsval(cx, rval),
1216 ByteStringSequenceOrLongOrString::String(ref inner) => inner.to_jsval(cx, rval),
1217 }
1218 }
1219}
1220
1221
1222
1223impl FromJSValConvertible for ByteStringSequenceOrLongOrString {
1224 type Config = ();
1225 unsafe fn from_jsval(cx: *mut RawJSContext,
1226 value: HandleValue,
1227 _option: ())
1228 -> Result<ConversionResult<ByteStringSequenceOrLongOrString>, ()> {
1229 if value.get().is_object() {
1230 match ByteStringSequenceOrLongOrString::TryConvertToByteStringSequence(SafeJSContext::from_ptr(cx), value) {
1231 Err(_) => return Err(()),
1232 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceOrLongOrString::ByteStringSequence(value))),
1233 Ok(None) => (),
1234 }
1235
1236 }
1237
1238 if value.get().is_number() {
1239 match ByteStringSequenceOrLongOrString::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
1240 Err(_) => return Err(()),
1241 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceOrLongOrString::Long(value))),
1242 Ok(None) => (),
1243 }
1244
1245 }
1246
1247 match ByteStringSequenceOrLongOrString::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
1248 Err(_) => return Err(()),
1249 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceOrLongOrString::String(value))),
1250 Ok(None) => (),
1251 }
1252
1253
1254 Ok(ConversionResult::Failure("argument could not be converted to any of: ByteStringSequence".into()))
1255 }
1256}
1257
1258impl ByteStringSequenceOrLongOrString {
1259 unsafe fn TryConvertToByteStringSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<ByteString>>, ()> {
1260 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1261 Ok(ConversionResult::Success(value)) => value,
1262 Ok(ConversionResult::Failure(error)) => {
1263 return Ok(None);
1264 }
1265 _ => {
1266 return Err(());
1267 },
1268 }
1269 ))
1270 }
1271
1272 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
1273 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
1274 Ok(ConversionResult::Success(value)) => value,
1275 Ok(ConversionResult::Failure(error)) => {
1276 return Ok(None);
1277 }
1278 _ => {
1279 return Err(());
1280 },
1281 }
1282 ))
1283 }
1284
1285 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
1286 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
1287 Ok(ConversionResult::Success(value)) => value,
1288 Ok(ConversionResult::Failure(error)) => {
1289 return Ok(None);
1290 }
1291 _ => {
1292 return Err(());
1293 },
1294 }
1295 ))
1296 }
1297}
1298
1299
1300
1301#[derive(JSTraceable, Clone)]
1302pub enum ByteStringSequenceSequenceOrByteStringByteStringRecord {
1303 ByteStringSequenceSequence(Vec<Vec<ByteString>>),
1304 ByteStringByteStringRecord(Record<ByteString, ByteString>),
1305}
1306
1307impl ToJSValConvertible for ByteStringSequenceSequenceOrByteStringByteStringRecord {
1308 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1309 match *self {
1310 ByteStringSequenceSequenceOrByteStringByteStringRecord::ByteStringSequenceSequence(ref inner) => inner.to_jsval(cx, rval),
1311 ByteStringSequenceSequenceOrByteStringByteStringRecord::ByteStringByteStringRecord(ref inner) => inner.to_jsval(cx, rval),
1312 }
1313 }
1314}
1315
1316
1317
1318impl FromJSValConvertible for ByteStringSequenceSequenceOrByteStringByteStringRecord {
1319 type Config = ();
1320 unsafe fn from_jsval(cx: *mut RawJSContext,
1321 value: HandleValue,
1322 _option: ())
1323 -> Result<ConversionResult<ByteStringSequenceSequenceOrByteStringByteStringRecord>, ()> {
1324 if value.get().is_object() {
1325 match ByteStringSequenceSequenceOrByteStringByteStringRecord::TryConvertToByteStringSequenceSequence(SafeJSContext::from_ptr(cx), value) {
1326 Err(_) => return Err(()),
1327 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceSequenceOrByteStringByteStringRecord::ByteStringSequenceSequence(value))),
1328 Ok(None) => (),
1329 }
1330
1331 match ByteStringSequenceSequenceOrByteStringByteStringRecord::TryConvertToByteStringByteStringRecord(SafeJSContext::from_ptr(cx), value) {
1332 Err(_) => return Err(()),
1333 Ok(Some(value)) => return Ok(ConversionResult::Success(ByteStringSequenceSequenceOrByteStringByteStringRecord::ByteStringByteStringRecord(value))),
1334 Ok(None) => (),
1335 }
1336
1337 }
1338
1339 Ok(ConversionResult::Failure("argument could not be converted to any of: ByteStringSequenceSequence, ByteStringByteStringRecord".into()))
1340 }
1341}
1342
1343impl ByteStringSequenceSequenceOrByteStringByteStringRecord {
1344 unsafe fn TryConvertToByteStringSequenceSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<Vec<ByteString>>>, ()> {
1345 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1346 Ok(ConversionResult::Success(value)) => value,
1347 Ok(ConversionResult::Failure(error)) => {
1348 return Ok(None);
1349 }
1350 _ => {
1351 return Err(());
1352 },
1353 }
1354 ))
1355 }
1356
1357 unsafe fn TryConvertToByteStringByteStringRecord(cx: SafeJSContext, value: HandleValue) -> Result<Option<Record<ByteString, ByteString>>, ()> {
1358 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1359 Ok(ConversionResult::Success(value)) => value,
1360 Ok(ConversionResult::Failure(error)) => {
1361 return Ok(None);
1362 }
1363 _ => {
1364 return Err(());
1365 },
1366 }
1367 ))
1368 }
1369}
1370
1371
1372
1373#[derive(JSTraceable)]
1374pub enum CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext<D: DomTypes> {
1375 CanvasRenderingContext2D(DomRoot<D::CanvasRenderingContext2D>),
1376 ImageBitmapRenderingContext(DomRoot<D::ImageBitmapRenderingContext>),
1377 WebGLRenderingContext(DomRoot<D::WebGLRenderingContext>),
1378 WebGL2RenderingContext(DomRoot<D::WebGL2RenderingContext>),
1379 GPUCanvasContext(DomRoot<D::GPUCanvasContext>),
1380}
1381
1382impl<D: DomTypes> ToJSValConvertible for CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext<D> {
1383 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1384 match *self {
1385 CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::CanvasRenderingContext2D(ref inner) => inner.to_jsval(cx, rval),
1386 CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::ImageBitmapRenderingContext(ref inner) => inner.to_jsval(cx, rval),
1387 CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::WebGLRenderingContext(ref inner) => inner.to_jsval(cx, rval),
1388 CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::WebGL2RenderingContext(ref inner) => inner.to_jsval(cx, rval),
1389 CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::GPUCanvasContext(ref inner) => inner.to_jsval(cx, rval),
1390 }
1391 }
1392}
1393
1394
1395
1396impl<D: DomTypes> FromJSValConvertible for CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext<D> {
1397 type Config = ();
1398 unsafe fn from_jsval(cx: *mut RawJSContext,
1399 value: HandleValue,
1400 _option: ())
1401 -> Result<ConversionResult<CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext<D>>, ()> {
1402 if value.get().is_object() {
1403 match CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::<D>::TryConvertToCanvasRenderingContext2D(SafeJSContext::from_ptr(cx), value) {
1404 Err(_) => return Err(()),
1405 Ok(Some(value)) => return Ok(ConversionResult::Success(CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::CanvasRenderingContext2D(value))),
1406 Ok(None) => (),
1407 }
1408 match CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::<D>::TryConvertToImageBitmapRenderingContext(SafeJSContext::from_ptr(cx), value) {
1409 Err(_) => return Err(()),
1410 Ok(Some(value)) => return Ok(ConversionResult::Success(CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::ImageBitmapRenderingContext(value))),
1411 Ok(None) => (),
1412 }
1413 match CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::<D>::TryConvertToWebGLRenderingContext(SafeJSContext::from_ptr(cx), value) {
1414 Err(_) => return Err(()),
1415 Ok(Some(value)) => return Ok(ConversionResult::Success(CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::WebGLRenderingContext(value))),
1416 Ok(None) => (),
1417 }
1418 match CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::<D>::TryConvertToWebGL2RenderingContext(SafeJSContext::from_ptr(cx), value) {
1419 Err(_) => return Err(()),
1420 Ok(Some(value)) => return Ok(ConversionResult::Success(CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::WebGL2RenderingContext(value))),
1421 Ok(None) => (),
1422 }
1423 match CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::<D>::TryConvertToGPUCanvasContext(SafeJSContext::from_ptr(cx), value) {
1424 Err(_) => return Err(()),
1425 Ok(Some(value)) => return Ok(ConversionResult::Success(CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext::GPUCanvasContext(value))),
1426 Ok(None) => (),
1427 }
1428
1429 }
1430
1431 Ok(ConversionResult::Failure("argument could not be converted to any of: CanvasRenderingContext2D, ImageBitmapRenderingContext, WebGLRenderingContext, WebGL2RenderingContext, GPUCanvasContext".into()))
1432 }
1433}
1434
1435impl<D: DomTypes> CanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContextOrGPUCanvasContext<D> {
1436 unsafe fn TryConvertToCanvasRenderingContext2D(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::CanvasRenderingContext2D>>, ()> {
1437 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1438 Ok(val) => val,
1439 Err(()) => {
1440 return Ok(None);
1441 }
1442 }
1443 ))
1444 }
1445
1446 unsafe fn TryConvertToImageBitmapRenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageBitmapRenderingContext>>, ()> {
1447 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1448 Ok(val) => val,
1449 Err(()) => {
1450 return Ok(None);
1451 }
1452 }
1453 ))
1454 }
1455
1456 unsafe fn TryConvertToWebGLRenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WebGLRenderingContext>>, ()> {
1457 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1458 Ok(val) => val,
1459 Err(()) => {
1460 return Ok(None);
1461 }
1462 }
1463 ))
1464 }
1465
1466 unsafe fn TryConvertToWebGL2RenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WebGL2RenderingContext>>, ()> {
1467 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1468 Ok(val) => val,
1469 Err(()) => {
1470 return Ok(None);
1471 }
1472 }
1473 ))
1474 }
1475
1476 unsafe fn TryConvertToGPUCanvasContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::GPUCanvasContext>>, ()> {
1477 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1478 Ok(val) => val,
1479 Err(()) => {
1480 return Ok(None);
1481 }
1482 }
1483 ))
1484 }
1485}
1486
1487
1488
1489#[derive(JSTraceable)]
1490pub enum ClampedUnsignedLongOrConstrainULongRange {
1491 ClampedUnsignedLong(u32),
1492 ConstrainULongRange(ConstrainULongRange),
1493}
1494
1495impl ToJSValConvertible for ClampedUnsignedLongOrConstrainULongRange {
1496 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1497 match *self {
1498 ClampedUnsignedLongOrConstrainULongRange::ClampedUnsignedLong(ref inner) => inner.to_jsval(cx, rval),
1499 ClampedUnsignedLongOrConstrainULongRange::ConstrainULongRange(ref inner) => inner.to_jsval(cx, rval),
1500 }
1501 }
1502}
1503
1504
1505
1506impl FromJSValConvertible for ClampedUnsignedLongOrConstrainULongRange {
1507 type Config = ();
1508 unsafe fn from_jsval(cx: *mut RawJSContext,
1509 value: HandleValue,
1510 _option: ())
1511 -> Result<ConversionResult<ClampedUnsignedLongOrConstrainULongRange>, ()> {
1512 match ClampedUnsignedLongOrConstrainULongRange::TryConvertToConstrainULongRange(SafeJSContext::from_ptr(cx), value) {
1513 Err(_) => return Err(()),
1514 Ok(Some(value)) => return Ok(ConversionResult::Success(ClampedUnsignedLongOrConstrainULongRange::ConstrainULongRange(value))),
1515 Ok(None) => (),
1516 }
1517
1518
1519 match ClampedUnsignedLongOrConstrainULongRange::TryConvertToClampedUnsignedLong(SafeJSContext::from_ptr(cx), value) {
1520 Err(_) => return Err(()),
1521 Ok(Some(value)) => return Ok(ConversionResult::Success(ClampedUnsignedLongOrConstrainULongRange::ClampedUnsignedLong(value))),
1522 Ok(None) => (),
1523 }
1524
1525
1526 Ok(ConversionResult::Failure("argument could not be converted to any of: ConstrainULongRange".into()))
1527 }
1528}
1529
1530impl ClampedUnsignedLongOrConstrainULongRange {
1531 unsafe fn TryConvertToClampedUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
1532 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Clamp) {
1533 Ok(ConversionResult::Success(value)) => value,
1534 Ok(ConversionResult::Failure(error)) => {
1535 return Ok(None);
1536 }
1537 _ => {
1538 return Err(());
1539 },
1540 }
1541 ))
1542 }
1543
1544 unsafe fn TryConvertToConstrainULongRange(cx: SafeJSContext, value: HandleValue) -> Result<Option<ConstrainULongRange>, ()> {
1545 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1546 Ok(ConversionResult::Success(value)) => value,
1547 Ok(ConversionResult::Failure(error)) => {
1548 return Ok(None);
1549 }
1550 _ => {
1551 return Err(());
1552 },
1553 }
1554 ))
1555 }
1556}
1557
1558
1559
1560#[derive(JSTraceable)]
1561pub enum DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D: DomTypes> {
1562 Document(DomRoot<D::Document>),
1563 Blob(DomRoot<D::Blob>),
1564 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
1565 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
1566 FormData(DomRoot<D::FormData>),
1567 String(DOMString),
1568 URLSearchParams(DomRoot<D::URLSearchParams>),
1569}
1570
1571impl<D: DomTypes> ToJSValConvertible for DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
1572 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1573 match *self {
1574 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Document(ref inner) => inner.to_jsval(cx, rval),
1575 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Blob(ref inner) => inner.to_jsval(cx, rval),
1576 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
1577 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
1578 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::FormData(ref inner) => inner.to_jsval(cx, rval),
1579 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::String(ref inner) => inner.to_jsval(cx, rval),
1580 DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::URLSearchParams(ref inner) => inner.to_jsval(cx, rval),
1581 }
1582 }
1583}
1584
1585
1586
1587impl<D: DomTypes> FromJSValConvertible for DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
1588 type Config = ();
1589 unsafe fn from_jsval(cx: *mut RawJSContext,
1590 value: HandleValue,
1591 _option: ())
1592 -> Result<ConversionResult<DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D>>, ()> {
1593 if value.get().is_object() {
1594 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToDocument(SafeJSContext::from_ptr(cx), value) {
1595 Err(_) => return Err(()),
1596 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Document(value))),
1597 Ok(None) => (),
1598 }
1599 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
1600 Err(_) => return Err(()),
1601 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Blob(value))),
1602 Ok(None) => (),
1603 }
1604 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
1605 Err(_) => return Err(()),
1606 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBufferView(value))),
1607 Ok(None) => (),
1608 }
1609 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
1610 Err(_) => return Err(()),
1611 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBuffer(value))),
1612 Ok(None) => (),
1613 }
1614 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToFormData(SafeJSContext::from_ptr(cx), value) {
1615 Err(_) => return Err(()),
1616 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::FormData(value))),
1617 Ok(None) => (),
1618 }
1619 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToURLSearchParams(SafeJSContext::from_ptr(cx), value) {
1620 Err(_) => return Err(()),
1621 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::URLSearchParams(value))),
1622 Ok(None) => (),
1623 }
1624
1625 }
1626
1627 match DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
1628 Err(_) => return Err(()),
1629 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::String(value))),
1630 Ok(None) => (),
1631 }
1632
1633
1634 Ok(ConversionResult::Failure("argument could not be converted to any of: Document, Blob, ArrayBufferView, ArrayBuffer, FormData, URLSearchParams".into()))
1635 }
1636}
1637
1638impl<D: DomTypes> DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
1639 unsafe fn TryConvertToDocument(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Document>>, ()> {
1640 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1641 Ok(val) => val,
1642 Err(()) => {
1643 return Ok(None);
1644 }
1645 }
1646 ))
1647 }
1648
1649 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
1650 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1651 Ok(val) => val,
1652 Err(()) => {
1653 return Ok(None);
1654 }
1655 }
1656 ))
1657 }
1658
1659 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
1660 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
1661 Ok(val) => val,
1662 Err(()) => {
1663 return Ok(None);
1664 }
1665 }
1666 ))
1667 }
1668
1669 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
1670 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
1671 Ok(val) => val,
1672 Err(()) => {
1673 return Ok(None);
1674 }
1675 }
1676 ))
1677 }
1678
1679 unsafe fn TryConvertToFormData(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::FormData>>, ()> {
1680 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1681 Ok(val) => val,
1682 Err(()) => {
1683 return Ok(None);
1684 }
1685 }
1686 ))
1687 }
1688
1689 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
1690 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
1691 Ok(ConversionResult::Success(value)) => value,
1692 Ok(ConversionResult::Failure(error)) => {
1693 return Ok(None);
1694 }
1695 _ => {
1696 return Err(());
1697 },
1698 }
1699 ))
1700 }
1701
1702 unsafe fn TryConvertToURLSearchParams(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::URLSearchParams>>, ()> {
1703 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1704 Ok(val) => val,
1705 Err(()) => {
1706 return Ok(None);
1707 }
1708 }
1709 ))
1710 }
1711}
1712
1713
1714
1715#[derive(JSTraceable)]
1716pub enum DocumentOrStringOrURLOrBlob<D: DomTypes> {
1717 Document(DomRoot<D::Document>),
1718 String(DOMString),
1719 URL(DomRoot<D::URL>),
1720 Blob(DomRoot<D::Blob>),
1721}
1722
1723impl<D: DomTypes> ToJSValConvertible for DocumentOrStringOrURLOrBlob<D> {
1724 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1725 match *self {
1726 DocumentOrStringOrURLOrBlob::Document(ref inner) => inner.to_jsval(cx, rval),
1727 DocumentOrStringOrURLOrBlob::String(ref inner) => inner.to_jsval(cx, rval),
1728 DocumentOrStringOrURLOrBlob::URL(ref inner) => inner.to_jsval(cx, rval),
1729 DocumentOrStringOrURLOrBlob::Blob(ref inner) => inner.to_jsval(cx, rval),
1730 }
1731 }
1732}
1733
1734
1735
1736impl<D: DomTypes> FromJSValConvertible for DocumentOrStringOrURLOrBlob<D> {
1737 type Config = ();
1738 unsafe fn from_jsval(cx: *mut RawJSContext,
1739 value: HandleValue,
1740 _option: ())
1741 -> Result<ConversionResult<DocumentOrStringOrURLOrBlob<D>>, ()> {
1742 if value.get().is_object() {
1743 match DocumentOrStringOrURLOrBlob::<D>::TryConvertToDocument(SafeJSContext::from_ptr(cx), value) {
1744 Err(_) => return Err(()),
1745 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrStringOrURLOrBlob::Document(value))),
1746 Ok(None) => (),
1747 }
1748 match DocumentOrStringOrURLOrBlob::<D>::TryConvertToURL(SafeJSContext::from_ptr(cx), value) {
1749 Err(_) => return Err(()),
1750 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrStringOrURLOrBlob::URL(value))),
1751 Ok(None) => (),
1752 }
1753 match DocumentOrStringOrURLOrBlob::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
1754 Err(_) => return Err(()),
1755 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrStringOrURLOrBlob::Blob(value))),
1756 Ok(None) => (),
1757 }
1758
1759 }
1760
1761 match DocumentOrStringOrURLOrBlob::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
1762 Err(_) => return Err(()),
1763 Ok(Some(value)) => return Ok(ConversionResult::Success(DocumentOrStringOrURLOrBlob::String(value))),
1764 Ok(None) => (),
1765 }
1766
1767
1768 Ok(ConversionResult::Failure("argument could not be converted to any of: Document, URL, Blob".into()))
1769 }
1770}
1771
1772impl<D: DomTypes> DocumentOrStringOrURLOrBlob<D> {
1773 unsafe fn TryConvertToDocument(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Document>>, ()> {
1774 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1775 Ok(val) => val,
1776 Err(()) => {
1777 return Ok(None);
1778 }
1779 }
1780 ))
1781 }
1782
1783 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
1784 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
1785 Ok(ConversionResult::Success(value)) => value,
1786 Ok(ConversionResult::Failure(error)) => {
1787 return Ok(None);
1788 }
1789 _ => {
1790 return Err(());
1791 },
1792 }
1793 ))
1794 }
1795
1796 unsafe fn TryConvertToURL(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::URL>>, ()> {
1797 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1798 Ok(val) => val,
1799 Err(()) => {
1800 return Ok(None);
1801 }
1802 }
1803 ))
1804 }
1805
1806 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
1807 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
1808 Ok(val) => val,
1809 Err(()) => {
1810 return Ok(None);
1811 }
1812 }
1813 ))
1814 }
1815}
1816
1817
1818
1819#[derive(JSTraceable)]
1820pub enum DoubleOrAutoKeyword {
1821 Double(Finite<f64>),
1822 AutoKeyword(AutoKeyword),
1823}
1824
1825impl ToJSValConvertible for DoubleOrAutoKeyword {
1826 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1827 match *self {
1828 DoubleOrAutoKeyword::Double(ref inner) => inner.to_jsval(cx, rval),
1829 DoubleOrAutoKeyword::AutoKeyword(ref inner) => inner.to_jsval(cx, rval),
1830 }
1831 }
1832}
1833
1834
1835
1836impl FromJSValConvertible for DoubleOrAutoKeyword {
1837 type Config = ();
1838 unsafe fn from_jsval(cx: *mut RawJSContext,
1839 value: HandleValue,
1840 _option: ())
1841 -> Result<ConversionResult<DoubleOrAutoKeyword>, ()> {
1842 if value.get().is_number() {
1843 match DoubleOrAutoKeyword::TryConvertToDouble(SafeJSContext::from_ptr(cx), value) {
1844 Err(_) => return Err(()),
1845 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleOrAutoKeyword::Double(value))),
1846 Ok(None) => (),
1847 }
1848
1849 }
1850
1851 match DoubleOrAutoKeyword::TryConvertToAutoKeyword(SafeJSContext::from_ptr(cx), value) {
1852 Err(_) => return Err(()),
1853 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleOrAutoKeyword::AutoKeyword(value))),
1854 Ok(None) => (),
1855 }
1856
1857
1858 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
1859 }
1860}
1861
1862impl DoubleOrAutoKeyword {
1863 unsafe fn TryConvertToDouble(cx: SafeJSContext, value: HandleValue) -> Result<Option<Finite<f64>>, ()> {
1864 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1865 Ok(ConversionResult::Success(value)) => value,
1866 Ok(ConversionResult::Failure(error)) => {
1867 return Ok(None);
1868 }
1869 _ => {
1870 return Err(());
1871 },
1872 }
1873 ))
1874 }
1875
1876 unsafe fn TryConvertToAutoKeyword(cx: SafeJSContext, value: HandleValue) -> Result<Option<AutoKeyword>, ()> {
1877 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1878 Ok(ConversionResult::Success(value)) => value,
1879 Ok(ConversionResult::Failure(error)) => {
1880 return Ok(None);
1881 }
1882 _ => {
1883 return Err(());
1884 },
1885 }
1886 ))
1887 }
1888}
1889
1890
1891
1892#[derive(JSTraceable)]
1893pub enum DoubleOrConstrainDoubleRange {
1894 Double(Finite<f64>),
1895 ConstrainDoubleRange(ConstrainDoubleRange),
1896}
1897
1898impl ToJSValConvertible for DoubleOrConstrainDoubleRange {
1899 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1900 match *self {
1901 DoubleOrConstrainDoubleRange::Double(ref inner) => inner.to_jsval(cx, rval),
1902 DoubleOrConstrainDoubleRange::ConstrainDoubleRange(ref inner) => inner.to_jsval(cx, rval),
1903 }
1904 }
1905}
1906
1907
1908
1909impl FromJSValConvertible for DoubleOrConstrainDoubleRange {
1910 type Config = ();
1911 unsafe fn from_jsval(cx: *mut RawJSContext,
1912 value: HandleValue,
1913 _option: ())
1914 -> Result<ConversionResult<DoubleOrConstrainDoubleRange>, ()> {
1915 match DoubleOrConstrainDoubleRange::TryConvertToConstrainDoubleRange(SafeJSContext::from_ptr(cx), value) {
1916 Err(_) => return Err(()),
1917 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleOrConstrainDoubleRange::ConstrainDoubleRange(value))),
1918 Ok(None) => (),
1919 }
1920
1921
1922 match DoubleOrConstrainDoubleRange::TryConvertToDouble(SafeJSContext::from_ptr(cx), value) {
1923 Err(_) => return Err(()),
1924 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleOrConstrainDoubleRange::Double(value))),
1925 Ok(None) => (),
1926 }
1927
1928
1929 Ok(ConversionResult::Failure("argument could not be converted to any of: ConstrainDoubleRange".into()))
1930 }
1931}
1932
1933impl DoubleOrConstrainDoubleRange {
1934 unsafe fn TryConvertToDouble(cx: SafeJSContext, value: HandleValue) -> Result<Option<Finite<f64>>, ()> {
1935 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1936 Ok(ConversionResult::Success(value)) => value,
1937 Ok(ConversionResult::Failure(error)) => {
1938 return Ok(None);
1939 }
1940 _ => {
1941 return Err(());
1942 },
1943 }
1944 ))
1945 }
1946
1947 unsafe fn TryConvertToConstrainDoubleRange(cx: SafeJSContext, value: HandleValue) -> Result<Option<ConstrainDoubleRange>, ()> {
1948 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
1949 Ok(ConversionResult::Success(value)) => value,
1950 Ok(ConversionResult::Failure(error)) => {
1951 return Ok(None);
1952 }
1953 _ => {
1954 return Err(());
1955 },
1956 }
1957 ))
1958 }
1959}
1960
1961
1962
1963#[derive(JSTraceable)]
1964pub enum DoubleOrDoubleSequence {
1965 Double(Finite<f64>),
1966 DoubleSequence(Vec<Finite<f64>>),
1967}
1968
1969impl ToJSValConvertible for DoubleOrDoubleSequence {
1970 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
1971 match *self {
1972 DoubleOrDoubleSequence::Double(ref inner) => inner.to_jsval(cx, rval),
1973 DoubleOrDoubleSequence::DoubleSequence(ref inner) => inner.to_jsval(cx, rval),
1974 }
1975 }
1976}
1977
1978
1979
1980impl FromJSValConvertible for DoubleOrDoubleSequence {
1981 type Config = ();
1982 unsafe fn from_jsval(cx: *mut RawJSContext,
1983 value: HandleValue,
1984 _option: ())
1985 -> Result<ConversionResult<DoubleOrDoubleSequence>, ()> {
1986 if value.get().is_object() {
1987 match DoubleOrDoubleSequence::TryConvertToDoubleSequence(SafeJSContext::from_ptr(cx), value) {
1988 Err(_) => return Err(()),
1989 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleOrDoubleSequence::DoubleSequence(value))),
1990 Ok(None) => (),
1991 }
1992
1993 }
1994
1995 match DoubleOrDoubleSequence::TryConvertToDouble(SafeJSContext::from_ptr(cx), value) {
1996 Err(_) => return Err(()),
1997 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleOrDoubleSequence::Double(value))),
1998 Ok(None) => (),
1999 }
2000
2001
2002 Ok(ConversionResult::Failure("argument could not be converted to any of: DoubleSequence".into()))
2003 }
2004}
2005
2006impl DoubleOrDoubleSequence {
2007 unsafe fn TryConvertToDouble(cx: SafeJSContext, value: HandleValue) -> Result<Option<Finite<f64>>, ()> {
2008 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2009 Ok(ConversionResult::Success(value)) => value,
2010 Ok(ConversionResult::Failure(error)) => {
2011 return Ok(None);
2012 }
2013 _ => {
2014 return Err(());
2015 },
2016 }
2017 ))
2018 }
2019
2020 unsafe fn TryConvertToDoubleSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<Finite<f64>>>, ()> {
2021 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2022 Ok(ConversionResult::Success(value)) => value,
2023 Ok(ConversionResult::Failure(error)) => {
2024 return Ok(None);
2025 }
2026 _ => {
2027 return Err(());
2028 },
2029 }
2030 ))
2031 }
2032}
2033
2034
2035
2036#[derive(JSTraceable)]
2037pub enum DoubleSequenceOrGPUColorDict {
2038 DoubleSequence(Vec<Finite<f64>>),
2039 GPUColorDict(GPUColorDict),
2040}
2041
2042impl ToJSValConvertible for DoubleSequenceOrGPUColorDict {
2043 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2044 match *self {
2045 DoubleSequenceOrGPUColorDict::DoubleSequence(ref inner) => inner.to_jsval(cx, rval),
2046 DoubleSequenceOrGPUColorDict::GPUColorDict(ref inner) => inner.to_jsval(cx, rval),
2047 }
2048 }
2049}
2050
2051
2052
2053impl FromJSValConvertible for DoubleSequenceOrGPUColorDict {
2054 type Config = ();
2055 unsafe fn from_jsval(cx: *mut RawJSContext,
2056 value: HandleValue,
2057 _option: ())
2058 -> Result<ConversionResult<DoubleSequenceOrGPUColorDict>, ()> {
2059 if value.get().is_object() {
2060 match DoubleSequenceOrGPUColorDict::TryConvertToDoubleSequence(SafeJSContext::from_ptr(cx), value) {
2061 Err(_) => return Err(()),
2062 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleSequenceOrGPUColorDict::DoubleSequence(value))),
2063 Ok(None) => (),
2064 }
2065
2066 }
2067
2068 match DoubleSequenceOrGPUColorDict::TryConvertToGPUColorDict(SafeJSContext::from_ptr(cx), value) {
2069 Err(_) => return Err(()),
2070 Ok(Some(value)) => return Ok(ConversionResult::Success(DoubleSequenceOrGPUColorDict::GPUColorDict(value))),
2071 Ok(None) => (),
2072 }
2073
2074
2075 Ok(ConversionResult::Failure("argument could not be converted to any of: DoubleSequence, GPUColorDict".into()))
2076 }
2077}
2078
2079impl DoubleSequenceOrGPUColorDict {
2080 unsafe fn TryConvertToDoubleSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<Finite<f64>>>, ()> {
2081 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2082 Ok(ConversionResult::Success(value)) => value,
2083 Ok(ConversionResult::Failure(error)) => {
2084 return Ok(None);
2085 }
2086 _ => {
2087 return Err(());
2088 },
2089 }
2090 ))
2091 }
2092
2093 unsafe fn TryConvertToGPUColorDict(cx: SafeJSContext, value: HandleValue) -> Result<Option<GPUColorDict>, ()> {
2094 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2095 Ok(ConversionResult::Success(value)) => value,
2096 Ok(ConversionResult::Failure(error)) => {
2097 return Ok(None);
2098 }
2099 _ => {
2100 return Err(());
2101 },
2102 }
2103 ))
2104 }
2105}
2106
2107
2108
2109#[derive(JSTraceable, MallocSizeOf)]
2110pub enum ElementOrDocument<D: DomTypes> {
2111 Element(DomRoot<D::Element>),
2112 Document(DomRoot<D::Document>),
2113}
2114
2115impl<D: DomTypes> ToJSValConvertible for ElementOrDocument<D> {
2116 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2117 match *self {
2118 ElementOrDocument::Element(ref inner) => inner.to_jsval(cx, rval),
2119 ElementOrDocument::Document(ref inner) => inner.to_jsval(cx, rval),
2120 }
2121 }
2122}
2123
2124
2125#[allow(clippy::clone_on_copy)]
2126impl<D: DomTypes> Clone for ElementOrDocument<D> {
2127 fn clone(&self) -> Self {
2128 match self {
2129 ElementOrDocument::Element(inner) => ElementOrDocument::Element(inner.clone()),
2130 ElementOrDocument::Document(inner) => ElementOrDocument::Document(inner.clone()),
2131 }
2132 }
2133}
2134
2135
2136impl<D: DomTypes> FromJSValConvertible for ElementOrDocument<D> {
2137 type Config = ();
2138 unsafe fn from_jsval(cx: *mut RawJSContext,
2139 value: HandleValue,
2140 _option: ())
2141 -> Result<ConversionResult<ElementOrDocument<D>>, ()> {
2142 if value.get().is_object() {
2143 match ElementOrDocument::<D>::TryConvertToElement(SafeJSContext::from_ptr(cx), value) {
2144 Err(_) => return Err(()),
2145 Ok(Some(value)) => return Ok(ConversionResult::Success(ElementOrDocument::Element(value))),
2146 Ok(None) => (),
2147 }
2148 match ElementOrDocument::<D>::TryConvertToDocument(SafeJSContext::from_ptr(cx), value) {
2149 Err(_) => return Err(()),
2150 Ok(Some(value)) => return Ok(ConversionResult::Success(ElementOrDocument::Document(value))),
2151 Ok(None) => (),
2152 }
2153
2154 }
2155
2156 Ok(ConversionResult::Failure("argument could not be converted to any of: Element, Document".into()))
2157 }
2158}
2159
2160impl<D: DomTypes> ElementOrDocument<D> {
2161 unsafe fn TryConvertToElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Element>>, ()> {
2162 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2163 Ok(val) => val,
2164 Err(()) => {
2165 return Ok(None);
2166 }
2167 }
2168 ))
2169 }
2170
2171 unsafe fn TryConvertToDocument(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Document>>, ()> {
2172 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2173 Ok(val) => val,
2174 Err(()) => {
2175 return Ok(None);
2176 }
2177 }
2178 ))
2179 }
2180}
2181
2182
2183
2184#[derive(JSTraceable)]
2185pub enum ElementOrText<D: DomTypes> {
2186 Element(DomRoot<D::Element>),
2187 Text(DomRoot<D::Text>),
2188}
2189
2190impl<D: DomTypes> ToJSValConvertible for ElementOrText<D> {
2191 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2192 match *self {
2193 ElementOrText::Element(ref inner) => inner.to_jsval(cx, rval),
2194 ElementOrText::Text(ref inner) => inner.to_jsval(cx, rval),
2195 }
2196 }
2197}
2198
2199
2200
2201impl<D: DomTypes> FromJSValConvertible for ElementOrText<D> {
2202 type Config = ();
2203 unsafe fn from_jsval(cx: *mut RawJSContext,
2204 value: HandleValue,
2205 _option: ())
2206 -> Result<ConversionResult<ElementOrText<D>>, ()> {
2207 if value.get().is_object() {
2208 match ElementOrText::<D>::TryConvertToElement(SafeJSContext::from_ptr(cx), value) {
2209 Err(_) => return Err(()),
2210 Ok(Some(value)) => return Ok(ConversionResult::Success(ElementOrText::Element(value))),
2211 Ok(None) => (),
2212 }
2213 match ElementOrText::<D>::TryConvertToText(SafeJSContext::from_ptr(cx), value) {
2214 Err(_) => return Err(()),
2215 Ok(Some(value)) => return Ok(ConversionResult::Success(ElementOrText::Text(value))),
2216 Ok(None) => (),
2217 }
2218
2219 }
2220
2221 Ok(ConversionResult::Failure("argument could not be converted to any of: Element, Text".into()))
2222 }
2223}
2224
2225impl<D: DomTypes> ElementOrText<D> {
2226 unsafe fn TryConvertToElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Element>>, ()> {
2227 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2228 Ok(val) => val,
2229 Err(()) => {
2230 return Ok(None);
2231 }
2232 }
2233 ))
2234 }
2235
2236 unsafe fn TryConvertToText(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Text>>, ()> {
2237 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2238 Ok(val) => val,
2239 Err(()) => {
2240 return Ok(None);
2241 }
2242 }
2243 ))
2244 }
2245}
2246
2247
2248
2249#[derive(JSTraceable)]
2250pub enum EventListenerOptionsOrBoolean {
2251 EventListenerOptions(EventListenerOptions),
2252 Boolean(bool),
2253}
2254
2255impl ToJSValConvertible for EventListenerOptionsOrBoolean {
2256 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2257 match *self {
2258 EventListenerOptionsOrBoolean::EventListenerOptions(ref inner) => inner.to_jsval(cx, rval),
2259 EventListenerOptionsOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
2260 }
2261 }
2262}
2263
2264
2265
2266impl FromJSValConvertible for EventListenerOptionsOrBoolean {
2267 type Config = ();
2268 unsafe fn from_jsval(cx: *mut RawJSContext,
2269 value: HandleValue,
2270 _option: ())
2271 -> Result<ConversionResult<EventListenerOptionsOrBoolean>, ()> {
2272 match EventListenerOptionsOrBoolean::TryConvertToEventListenerOptions(SafeJSContext::from_ptr(cx), value) {
2273 Err(_) => return Err(()),
2274 Ok(Some(value)) => return Ok(ConversionResult::Success(EventListenerOptionsOrBoolean::EventListenerOptions(value))),
2275 Ok(None) => (),
2276 }
2277
2278
2279 match EventListenerOptionsOrBoolean::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
2280 Err(_) => return Err(()),
2281 Ok(Some(value)) => return Ok(ConversionResult::Success(EventListenerOptionsOrBoolean::Boolean(value))),
2282 Ok(None) => (),
2283 }
2284
2285
2286 Ok(ConversionResult::Failure("argument could not be converted to any of: EventListenerOptions".into()))
2287 }
2288}
2289
2290impl EventListenerOptionsOrBoolean {
2291 unsafe fn TryConvertToEventListenerOptions(cx: SafeJSContext, value: HandleValue) -> Result<Option<EventListenerOptions>, ()> {
2292 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2293 Ok(ConversionResult::Success(value)) => value,
2294 Ok(ConversionResult::Failure(error)) => {
2295 return Ok(None);
2296 }
2297 _ => {
2298 return Err(());
2299 },
2300 }
2301 ))
2302 }
2303
2304 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
2305 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2306 Ok(ConversionResult::Success(value)) => value,
2307 Ok(ConversionResult::Failure(error)) => {
2308 return Ok(None);
2309 }
2310 _ => {
2311 return Err(());
2312 },
2313 }
2314 ))
2315 }
2316}
2317
2318
2319
2320#[derive(JSTraceable)]
2321pub enum EventOrString<D: DomTypes> {
2322 Event(DomRoot<D::Event>),
2323 String(DOMString),
2324}
2325
2326impl<D: DomTypes> ToJSValConvertible for EventOrString<D> {
2327 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2328 match *self {
2329 EventOrString::Event(ref inner) => inner.to_jsval(cx, rval),
2330 EventOrString::String(ref inner) => inner.to_jsval(cx, rval),
2331 }
2332 }
2333}
2334
2335
2336
2337impl<D: DomTypes> FromJSValConvertible for EventOrString<D> {
2338 type Config = ();
2339 unsafe fn from_jsval(cx: *mut RawJSContext,
2340 value: HandleValue,
2341 _option: ())
2342 -> Result<ConversionResult<EventOrString<D>>, ()> {
2343 if value.get().is_object() {
2344 match EventOrString::<D>::TryConvertToEvent(SafeJSContext::from_ptr(cx), value) {
2345 Err(_) => return Err(()),
2346 Ok(Some(value)) => return Ok(ConversionResult::Success(EventOrString::Event(value))),
2347 Ok(None) => (),
2348 }
2349
2350 }
2351
2352 match EventOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
2353 Err(_) => return Err(()),
2354 Ok(Some(value)) => return Ok(ConversionResult::Success(EventOrString::String(value))),
2355 Ok(None) => (),
2356 }
2357
2358
2359 Ok(ConversionResult::Failure("argument could not be converted to any of: Event".into()))
2360 }
2361}
2362
2363impl<D: DomTypes> EventOrString<D> {
2364 unsafe fn TryConvertToEvent(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Event>>, ()> {
2365 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2366 Ok(val) => val,
2367 Err(()) => {
2368 return Ok(None);
2369 }
2370 }
2371 ))
2372 }
2373
2374 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
2375 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
2376 Ok(ConversionResult::Success(value)) => value,
2377 Ok(ConversionResult::Failure(error)) => {
2378 return Ok(None);
2379 }
2380 _ => {
2381 return Err(());
2382 },
2383 }
2384 ))
2385 }
2386}
2387
2388
2389
2390#[derive(JSTraceable)]
2391pub enum EventOrUSVString<D: DomTypes> {
2392 Event(DomRoot<D::Event>),
2393 USVString(USVString),
2394}
2395
2396impl<D: DomTypes> ToJSValConvertible for EventOrUSVString<D> {
2397 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2398 match *self {
2399 EventOrUSVString::Event(ref inner) => inner.to_jsval(cx, rval),
2400 EventOrUSVString::USVString(ref inner) => inner.to_jsval(cx, rval),
2401 }
2402 }
2403}
2404
2405
2406
2407impl<D: DomTypes> FromJSValConvertible for EventOrUSVString<D> {
2408 type Config = ();
2409 unsafe fn from_jsval(cx: *mut RawJSContext,
2410 value: HandleValue,
2411 _option: ())
2412 -> Result<ConversionResult<EventOrUSVString<D>>, ()> {
2413 if value.get().is_object() {
2414 match EventOrUSVString::<D>::TryConvertToEvent(SafeJSContext::from_ptr(cx), value) {
2415 Err(_) => return Err(()),
2416 Ok(Some(value)) => return Ok(ConversionResult::Success(EventOrUSVString::Event(value))),
2417 Ok(None) => (),
2418 }
2419
2420 }
2421
2422 match EventOrUSVString::<D>::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
2423 Err(_) => return Err(()),
2424 Ok(Some(value)) => return Ok(ConversionResult::Success(EventOrUSVString::USVString(value))),
2425 Ok(None) => (),
2426 }
2427
2428
2429 Ok(ConversionResult::Failure("argument could not be converted to any of: Event".into()))
2430 }
2431}
2432
2433impl<D: DomTypes> EventOrUSVString<D> {
2434 unsafe fn TryConvertToEvent(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Event>>, ()> {
2435 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2436 Ok(val) => val,
2437 Err(()) => {
2438 return Ok(None);
2439 }
2440 }
2441 ))
2442 }
2443
2444 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
2445 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2446 Ok(ConversionResult::Success(value)) => value,
2447 Ok(ConversionResult::Failure(error)) => {
2448 return Ok(None);
2449 }
2450 _ => {
2451 return Err(());
2452 },
2453 }
2454 ))
2455 }
2456}
2457
2458
2459
2460#[derive(JSTraceable)]
2461pub enum FileOrUSVString<D: DomTypes> {
2462 File(DomRoot<D::File>),
2463 USVString(USVString),
2464}
2465
2466impl<D: DomTypes> ToJSValConvertible for FileOrUSVString<D> {
2467 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2468 match *self {
2469 FileOrUSVString::File(ref inner) => inner.to_jsval(cx, rval),
2470 FileOrUSVString::USVString(ref inner) => inner.to_jsval(cx, rval),
2471 }
2472 }
2473}
2474
2475
2476
2477impl<D: DomTypes> FromJSValConvertible for FileOrUSVString<D> {
2478 type Config = ();
2479 unsafe fn from_jsval(cx: *mut RawJSContext,
2480 value: HandleValue,
2481 _option: ())
2482 -> Result<ConversionResult<FileOrUSVString<D>>, ()> {
2483 if value.get().is_object() {
2484 match FileOrUSVString::<D>::TryConvertToFile(SafeJSContext::from_ptr(cx), value) {
2485 Err(_) => return Err(()),
2486 Ok(Some(value)) => return Ok(ConversionResult::Success(FileOrUSVString::File(value))),
2487 Ok(None) => (),
2488 }
2489
2490 }
2491
2492 match FileOrUSVString::<D>::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
2493 Err(_) => return Err(()),
2494 Ok(Some(value)) => return Ok(ConversionResult::Success(FileOrUSVString::USVString(value))),
2495 Ok(None) => (),
2496 }
2497
2498
2499 Ok(ConversionResult::Failure("argument could not be converted to any of: File".into()))
2500 }
2501}
2502
2503impl<D: DomTypes> FileOrUSVString<D> {
2504 unsafe fn TryConvertToFile(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::File>>, ()> {
2505 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2506 Ok(val) => val,
2507 Err(()) => {
2508 return Ok(None);
2509 }
2510 }
2511 ))
2512 }
2513
2514 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
2515 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2516 Ok(ConversionResult::Success(value)) => value,
2517 Ok(ConversionResult::Failure(error)) => {
2518 return Ok(None);
2519 }
2520 _ => {
2521 return Err(());
2522 },
2523 }
2524 ))
2525 }
2526}
2527
2528
2529
2530#[derive(JSTraceable)]
2531pub enum FileOrUSVStringOrFormData<D: DomTypes> {
2532 File(DomRoot<D::File>),
2533 USVString(USVString),
2534 FormData(DomRoot<D::FormData>),
2535}
2536
2537impl<D: DomTypes> ToJSValConvertible for FileOrUSVStringOrFormData<D> {
2538 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2539 match *self {
2540 FileOrUSVStringOrFormData::File(ref inner) => inner.to_jsval(cx, rval),
2541 FileOrUSVStringOrFormData::USVString(ref inner) => inner.to_jsval(cx, rval),
2542 FileOrUSVStringOrFormData::FormData(ref inner) => inner.to_jsval(cx, rval),
2543 }
2544 }
2545}
2546
2547
2548
2549impl<D: DomTypes> FromJSValConvertible for FileOrUSVStringOrFormData<D> {
2550 type Config = ();
2551 unsafe fn from_jsval(cx: *mut RawJSContext,
2552 value: HandleValue,
2553 _option: ())
2554 -> Result<ConversionResult<FileOrUSVStringOrFormData<D>>, ()> {
2555 if value.get().is_object() {
2556 match FileOrUSVStringOrFormData::<D>::TryConvertToFile(SafeJSContext::from_ptr(cx), value) {
2557 Err(_) => return Err(()),
2558 Ok(Some(value)) => return Ok(ConversionResult::Success(FileOrUSVStringOrFormData::File(value))),
2559 Ok(None) => (),
2560 }
2561 match FileOrUSVStringOrFormData::<D>::TryConvertToFormData(SafeJSContext::from_ptr(cx), value) {
2562 Err(_) => return Err(()),
2563 Ok(Some(value)) => return Ok(ConversionResult::Success(FileOrUSVStringOrFormData::FormData(value))),
2564 Ok(None) => (),
2565 }
2566
2567 }
2568
2569 match FileOrUSVStringOrFormData::<D>::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
2570 Err(_) => return Err(()),
2571 Ok(Some(value)) => return Ok(ConversionResult::Success(FileOrUSVStringOrFormData::USVString(value))),
2572 Ok(None) => (),
2573 }
2574
2575
2576 Ok(ConversionResult::Failure("argument could not be converted to any of: File, FormData".into()))
2577 }
2578}
2579
2580impl<D: DomTypes> FileOrUSVStringOrFormData<D> {
2581 unsafe fn TryConvertToFile(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::File>>, ()> {
2582 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2583 Ok(val) => val,
2584 Err(()) => {
2585 return Ok(None);
2586 }
2587 }
2588 ))
2589 }
2590
2591 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
2592 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2593 Ok(ConversionResult::Success(value)) => value,
2594 Ok(ConversionResult::Failure(error)) => {
2595 return Ok(None);
2596 }
2597 _ => {
2598 return Err(());
2599 },
2600 }
2601 ))
2602 }
2603
2604 unsafe fn TryConvertToFormData(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::FormData>>, ()> {
2605 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2606 Ok(val) => val,
2607 Err(()) => {
2608 return Ok(None);
2609 }
2610 }
2611 ))
2612 }
2613}
2614
2615
2616
2617#[derive(JSTraceable)]
2618pub enum Float32ArrayOrUnrestrictedFloatSequence {
2619 Float32Array(RootedTraceableBox<typedarray::HeapFloat32Array>),
2620 UnrestrictedFloatSequence(Vec<f32>),
2621}
2622
2623impl ToJSValConvertible for Float32ArrayOrUnrestrictedFloatSequence {
2624 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2625 match *self {
2626 Float32ArrayOrUnrestrictedFloatSequence::Float32Array(ref inner) => inner.to_jsval(cx, rval),
2627 Float32ArrayOrUnrestrictedFloatSequence::UnrestrictedFloatSequence(ref inner) => inner.to_jsval(cx, rval),
2628 }
2629 }
2630}
2631
2632
2633
2634impl FromJSValConvertible for Float32ArrayOrUnrestrictedFloatSequence {
2635 type Config = ();
2636 unsafe fn from_jsval(cx: *mut RawJSContext,
2637 value: HandleValue,
2638 _option: ())
2639 -> Result<ConversionResult<Float32ArrayOrUnrestrictedFloatSequence>, ()> {
2640 if value.get().is_object() {
2641 match Float32ArrayOrUnrestrictedFloatSequence::TryConvertToUnrestrictedFloatSequence(SafeJSContext::from_ptr(cx), value) {
2642 Err(_) => return Err(()),
2643 Ok(Some(value)) => return Ok(ConversionResult::Success(Float32ArrayOrUnrestrictedFloatSequence::UnrestrictedFloatSequence(value))),
2644 Ok(None) => (),
2645 }
2646
2647 match Float32ArrayOrUnrestrictedFloatSequence::TryConvertToFloat32Array(SafeJSContext::from_ptr(cx), value) {
2648 Err(_) => return Err(()),
2649 Ok(Some(value)) => return Ok(ConversionResult::Success(Float32ArrayOrUnrestrictedFloatSequence::Float32Array(value))),
2650 Ok(None) => (),
2651 }
2652
2653 }
2654
2655 Ok(ConversionResult::Failure("argument could not be converted to any of: Float32Array, UnrestrictedFloatSequence".into()))
2656 }
2657}
2658
2659impl Float32ArrayOrUnrestrictedFloatSequence {
2660 unsafe fn TryConvertToFloat32Array(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapFloat32Array>>, ()> {
2661 Ok(Some(match typedarray::HeapFloat32Array::from(value.get().to_object()).map(RootedTraceableBox::new) {
2662 Ok(val) => val,
2663 Err(()) => {
2664 return Ok(None);
2665 }
2666 }
2667 ))
2668 }
2669
2670 unsafe fn TryConvertToUnrestrictedFloatSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<f32>>, ()> {
2671 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2672 Ok(ConversionResult::Success(value)) => value,
2673 Ok(ConversionResult::Failure(error)) => {
2674 return Ok(None);
2675 }
2676 _ => {
2677 return Err(());
2678 },
2679 }
2680 ))
2681 }
2682}
2683
2684
2685
2686#[derive(JSTraceable)]
2687pub enum GPUPipelineLayoutOrGPUAutoLayoutMode<D: DomTypes> {
2688 GPUPipelineLayout(DomRoot<D::GPUPipelineLayout>),
2689 GPUAutoLayoutMode(GPUAutoLayoutMode),
2690}
2691
2692impl<D: DomTypes> ToJSValConvertible for GPUPipelineLayoutOrGPUAutoLayoutMode<D> {
2693 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2694 match *self {
2695 GPUPipelineLayoutOrGPUAutoLayoutMode::GPUPipelineLayout(ref inner) => inner.to_jsval(cx, rval),
2696 GPUPipelineLayoutOrGPUAutoLayoutMode::GPUAutoLayoutMode(ref inner) => inner.to_jsval(cx, rval),
2697 }
2698 }
2699}
2700
2701
2702
2703impl<D: DomTypes> FromJSValConvertible for GPUPipelineLayoutOrGPUAutoLayoutMode<D> {
2704 type Config = ();
2705 unsafe fn from_jsval(cx: *mut RawJSContext,
2706 value: HandleValue,
2707 _option: ())
2708 -> Result<ConversionResult<GPUPipelineLayoutOrGPUAutoLayoutMode<D>>, ()> {
2709 if value.get().is_object() {
2710 match GPUPipelineLayoutOrGPUAutoLayoutMode::<D>::TryConvertToGPUPipelineLayout(SafeJSContext::from_ptr(cx), value) {
2711 Err(_) => return Err(()),
2712 Ok(Some(value)) => return Ok(ConversionResult::Success(GPUPipelineLayoutOrGPUAutoLayoutMode::GPUPipelineLayout(value))),
2713 Ok(None) => (),
2714 }
2715
2716 }
2717
2718 match GPUPipelineLayoutOrGPUAutoLayoutMode::<D>::TryConvertToGPUAutoLayoutMode(SafeJSContext::from_ptr(cx), value) {
2719 Err(_) => return Err(()),
2720 Ok(Some(value)) => return Ok(ConversionResult::Success(GPUPipelineLayoutOrGPUAutoLayoutMode::GPUAutoLayoutMode(value))),
2721 Ok(None) => (),
2722 }
2723
2724
2725 Ok(ConversionResult::Failure("argument could not be converted to any of: GPUPipelineLayout".into()))
2726 }
2727}
2728
2729impl<D: DomTypes> GPUPipelineLayoutOrGPUAutoLayoutMode<D> {
2730 unsafe fn TryConvertToGPUPipelineLayout(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::GPUPipelineLayout>>, ()> {
2731 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2732 Ok(val) => val,
2733 Err(()) => {
2734 return Ok(None);
2735 }
2736 }
2737 ))
2738 }
2739
2740 unsafe fn TryConvertToGPUAutoLayoutMode(cx: SafeJSContext, value: HandleValue) -> Result<Option<GPUAutoLayoutMode>, ()> {
2741 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2742 Ok(ConversionResult::Success(value)) => value,
2743 Ok(ConversionResult::Failure(error)) => {
2744 return Ok(None);
2745 }
2746 _ => {
2747 return Err(());
2748 },
2749 }
2750 ))
2751 }
2752}
2753
2754
2755
2756#[derive(JSTraceable)]
2757pub enum GPUSamplerOrGPUTextureViewOrGPUBufferBinding<D: DomTypes> {
2758 GPUSampler(DomRoot<D::GPUSampler>),
2759 GPUTextureView(DomRoot<D::GPUTextureView>),
2760 GPUBufferBinding(GPUBufferBinding<D>),
2761}
2762
2763impl<D: DomTypes> ToJSValConvertible for GPUSamplerOrGPUTextureViewOrGPUBufferBinding<D> {
2764 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2765 match *self {
2766 GPUSamplerOrGPUTextureViewOrGPUBufferBinding::GPUSampler(ref inner) => inner.to_jsval(cx, rval),
2767 GPUSamplerOrGPUTextureViewOrGPUBufferBinding::GPUTextureView(ref inner) => inner.to_jsval(cx, rval),
2768 GPUSamplerOrGPUTextureViewOrGPUBufferBinding::GPUBufferBinding(ref inner) => inner.to_jsval(cx, rval),
2769 }
2770 }
2771}
2772
2773
2774
2775impl<D: DomTypes> FromJSValConvertible for GPUSamplerOrGPUTextureViewOrGPUBufferBinding<D> {
2776 type Config = ();
2777 unsafe fn from_jsval(cx: *mut RawJSContext,
2778 value: HandleValue,
2779 _option: ())
2780 -> Result<ConversionResult<GPUSamplerOrGPUTextureViewOrGPUBufferBinding<D>>, ()> {
2781 if value.get().is_object() {
2782 match GPUSamplerOrGPUTextureViewOrGPUBufferBinding::<D>::TryConvertToGPUSampler(SafeJSContext::from_ptr(cx), value) {
2783 Err(_) => return Err(()),
2784 Ok(Some(value)) => return Ok(ConversionResult::Success(GPUSamplerOrGPUTextureViewOrGPUBufferBinding::GPUSampler(value))),
2785 Ok(None) => (),
2786 }
2787 match GPUSamplerOrGPUTextureViewOrGPUBufferBinding::<D>::TryConvertToGPUTextureView(SafeJSContext::from_ptr(cx), value) {
2788 Err(_) => return Err(()),
2789 Ok(Some(value)) => return Ok(ConversionResult::Success(GPUSamplerOrGPUTextureViewOrGPUBufferBinding::GPUTextureView(value))),
2790 Ok(None) => (),
2791 }
2792
2793 }
2794
2795 match GPUSamplerOrGPUTextureViewOrGPUBufferBinding::<D>::TryConvertToGPUBufferBinding(SafeJSContext::from_ptr(cx), value) {
2796 Err(_) => return Err(()),
2797 Ok(Some(value)) => return Ok(ConversionResult::Success(GPUSamplerOrGPUTextureViewOrGPUBufferBinding::GPUBufferBinding(value))),
2798 Ok(None) => (),
2799 }
2800
2801
2802 Ok(ConversionResult::Failure("argument could not be converted to any of: GPUSampler, GPUTextureView, GPUBufferBinding".into()))
2803 }
2804}
2805
2806impl<D: DomTypes> GPUSamplerOrGPUTextureViewOrGPUBufferBinding<D> {
2807 unsafe fn TryConvertToGPUSampler(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::GPUSampler>>, ()> {
2808 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2809 Ok(val) => val,
2810 Err(()) => {
2811 return Ok(None);
2812 }
2813 }
2814 ))
2815 }
2816
2817 unsafe fn TryConvertToGPUTextureView(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::GPUTextureView>>, ()> {
2818 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2819 Ok(val) => val,
2820 Err(()) => {
2821 return Ok(None);
2822 }
2823 }
2824 ))
2825 }
2826
2827 unsafe fn TryConvertToGPUBufferBinding(cx: SafeJSContext, value: HandleValue) -> Result<Option<GPUBufferBinding<D>>, ()> {
2828 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
2829 Ok(ConversionResult::Success(value)) => value,
2830 Ok(ConversionResult::Failure(error)) => {
2831 return Ok(None);
2832 }
2833 _ => {
2834 return Err(());
2835 },
2836 }
2837 ))
2838 }
2839}
2840
2841
2842
2843#[derive(JSTraceable, MallocSizeOf)]
2844pub enum HTMLCanvasElementOrOffscreenCanvas<D: DomTypes> {
2845 HTMLCanvasElement(DomRoot<D::HTMLCanvasElement>),
2846 OffscreenCanvas(DomRoot<D::OffscreenCanvas>),
2847}
2848
2849impl<D: DomTypes> ToJSValConvertible for HTMLCanvasElementOrOffscreenCanvas<D> {
2850 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2851 match *self {
2852 HTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(ref inner) => inner.to_jsval(cx, rval),
2853 HTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(ref inner) => inner.to_jsval(cx, rval),
2854 }
2855 }
2856}
2857
2858
2859#[allow(clippy::clone_on_copy)]
2860impl<D: DomTypes> Clone for HTMLCanvasElementOrOffscreenCanvas<D> {
2861 fn clone(&self) -> Self {
2862 match self {
2863 HTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(inner) => HTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(inner.clone()),
2864 HTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(inner) => HTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(inner.clone()),
2865 }
2866 }
2867}
2868
2869
2870impl<D: DomTypes> FromJSValConvertible for HTMLCanvasElementOrOffscreenCanvas<D> {
2871 type Config = ();
2872 unsafe fn from_jsval(cx: *mut RawJSContext,
2873 value: HandleValue,
2874 _option: ())
2875 -> Result<ConversionResult<HTMLCanvasElementOrOffscreenCanvas<D>>, ()> {
2876 if value.get().is_object() {
2877 match HTMLCanvasElementOrOffscreenCanvas::<D>::TryConvertToHTMLCanvasElement(SafeJSContext::from_ptr(cx), value) {
2878 Err(_) => return Err(()),
2879 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(value))),
2880 Ok(None) => (),
2881 }
2882 match HTMLCanvasElementOrOffscreenCanvas::<D>::TryConvertToOffscreenCanvas(SafeJSContext::from_ptr(cx), value) {
2883 Err(_) => return Err(()),
2884 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(value))),
2885 Ok(None) => (),
2886 }
2887
2888 }
2889
2890 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLCanvasElement, OffscreenCanvas".into()))
2891 }
2892}
2893
2894impl<D: DomTypes> HTMLCanvasElementOrOffscreenCanvas<D> {
2895 unsafe fn TryConvertToHTMLCanvasElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLCanvasElement>>, ()> {
2896 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2897 Ok(val) => val,
2898 Err(()) => {
2899 return Ok(None);
2900 }
2901 }
2902 ))
2903 }
2904
2905 unsafe fn TryConvertToOffscreenCanvas(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::OffscreenCanvas>>, ()> {
2906 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2907 Ok(val) => val,
2908 Err(()) => {
2909 return Ok(None);
2910 }
2911 }
2912 ))
2913 }
2914}
2915
2916
2917
2918#[derive(JSTraceable)]
2919pub enum HTMLElementOrLong<D: DomTypes> {
2920 HTMLElement(DomRoot<D::HTMLElement>),
2921 Long(i32),
2922}
2923
2924impl<D: DomTypes> ToJSValConvertible for HTMLElementOrLong<D> {
2925 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2926 match *self {
2927 HTMLElementOrLong::HTMLElement(ref inner) => inner.to_jsval(cx, rval),
2928 HTMLElementOrLong::Long(ref inner) => inner.to_jsval(cx, rval),
2929 }
2930 }
2931}
2932
2933
2934
2935impl<D: DomTypes> FromJSValConvertible for HTMLElementOrLong<D> {
2936 type Config = ();
2937 unsafe fn from_jsval(cx: *mut RawJSContext,
2938 value: HandleValue,
2939 _option: ())
2940 -> Result<ConversionResult<HTMLElementOrLong<D>>, ()> {
2941 if value.get().is_object() {
2942 match HTMLElementOrLong::<D>::TryConvertToHTMLElement(SafeJSContext::from_ptr(cx), value) {
2943 Err(_) => return Err(()),
2944 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLElementOrLong::HTMLElement(value))),
2945 Ok(None) => (),
2946 }
2947
2948 }
2949
2950 match HTMLElementOrLong::<D>::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
2951 Err(_) => return Err(()),
2952 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLElementOrLong::Long(value))),
2953 Ok(None) => (),
2954 }
2955
2956
2957 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLElement".into()))
2958 }
2959}
2960
2961impl<D: DomTypes> HTMLElementOrLong<D> {
2962 unsafe fn TryConvertToHTMLElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLElement>>, ()> {
2963 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
2964 Ok(val) => val,
2965 Err(()) => {
2966 return Ok(None);
2967 }
2968 }
2969 ))
2970 }
2971
2972 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
2973 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
2974 Ok(ConversionResult::Success(value)) => value,
2975 Ok(ConversionResult::Failure(error)) => {
2976 return Ok(None);
2977 }
2978 _ => {
2979 return Err(());
2980 },
2981 }
2982 ))
2983 }
2984}
2985
2986
2987
2988#[derive(JSTraceable)]
2989pub enum HTMLElementOrUnsignedLongOrStringOrBoolean<D: DomTypes> {
2990 HTMLElement(DomRoot<D::HTMLElement>),
2991 UnsignedLong(u32),
2992 String(DOMString),
2993 Boolean(bool),
2994}
2995
2996impl<D: DomTypes> ToJSValConvertible for HTMLElementOrUnsignedLongOrStringOrBoolean<D> {
2997 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2998 match *self {
2999 HTMLElementOrUnsignedLongOrStringOrBoolean::HTMLElement(ref inner) => inner.to_jsval(cx, rval),
3000 HTMLElementOrUnsignedLongOrStringOrBoolean::UnsignedLong(ref inner) => inner.to_jsval(cx, rval),
3001 HTMLElementOrUnsignedLongOrStringOrBoolean::String(ref inner) => inner.to_jsval(cx, rval),
3002 HTMLElementOrUnsignedLongOrStringOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
3003 }
3004 }
3005}
3006
3007
3008
3009impl<D: DomTypes> FromJSValConvertible for HTMLElementOrUnsignedLongOrStringOrBoolean<D> {
3010 type Config = ();
3011 unsafe fn from_jsval(cx: *mut RawJSContext,
3012 value: HandleValue,
3013 _option: ())
3014 -> Result<ConversionResult<HTMLElementOrUnsignedLongOrStringOrBoolean<D>>, ()> {
3015 if value.get().is_object() {
3016 match HTMLElementOrUnsignedLongOrStringOrBoolean::<D>::TryConvertToHTMLElement(SafeJSContext::from_ptr(cx), value) {
3017 Err(_) => return Err(()),
3018 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLElementOrUnsignedLongOrStringOrBoolean::HTMLElement(value))),
3019 Ok(None) => (),
3020 }
3021
3022 }
3023
3024 if value.get().is_boolean() {
3025 match HTMLElementOrUnsignedLongOrStringOrBoolean::<D>::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
3026 Err(_) => return Err(()),
3027 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLElementOrUnsignedLongOrStringOrBoolean::Boolean(value))),
3028 Ok(None) => (),
3029 }
3030
3031 }
3032
3033 if value.get().is_number() {
3034 match HTMLElementOrUnsignedLongOrStringOrBoolean::<D>::TryConvertToUnsignedLong(SafeJSContext::from_ptr(cx), value) {
3035 Err(_) => return Err(()),
3036 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLElementOrUnsignedLongOrStringOrBoolean::UnsignedLong(value))),
3037 Ok(None) => (),
3038 }
3039
3040 }
3041
3042 match HTMLElementOrUnsignedLongOrStringOrBoolean::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
3043 Err(_) => return Err(()),
3044 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLElementOrUnsignedLongOrStringOrBoolean::String(value))),
3045 Ok(None) => (),
3046 }
3047
3048
3049 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLElement".into()))
3050 }
3051}
3052
3053impl<D: DomTypes> HTMLElementOrUnsignedLongOrStringOrBoolean<D> {
3054 unsafe fn TryConvertToHTMLElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLElement>>, ()> {
3055 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3056 Ok(val) => val,
3057 Err(()) => {
3058 return Ok(None);
3059 }
3060 }
3061 ))
3062 }
3063
3064 unsafe fn TryConvertToUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
3065 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
3066 Ok(ConversionResult::Success(value)) => value,
3067 Ok(ConversionResult::Failure(error)) => {
3068 return Ok(None);
3069 }
3070 _ => {
3071 return Err(());
3072 },
3073 }
3074 ))
3075 }
3076
3077 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
3078 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
3079 Ok(ConversionResult::Success(value)) => value,
3080 Ok(ConversionResult::Failure(error)) => {
3081 return Ok(None);
3082 }
3083 _ => {
3084 return Err(());
3085 },
3086 }
3087 ))
3088 }
3089
3090 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
3091 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
3092 Ok(ConversionResult::Success(value)) => value,
3093 Ok(ConversionResult::Failure(error)) => {
3094 return Ok(None);
3095 }
3096 _ => {
3097 return Err(());
3098 },
3099 }
3100 ))
3101 }
3102}
3103
3104
3105
3106#[derive(JSTraceable)]
3107pub enum HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue<D: DomTypes> {
3108 HTMLImageElement(DomRoot<D::HTMLImageElement>),
3109 HTMLVideoElement(DomRoot<D::HTMLVideoElement>),
3110 HTMLCanvasElement(DomRoot<D::HTMLCanvasElement>),
3111 ImageBitmap(DomRoot<D::ImageBitmap>),
3112 OffscreenCanvas(DomRoot<D::OffscreenCanvas>),
3113 CSSStyleValue(DomRoot<D::CSSStyleValue>),
3114}
3115
3116impl<D: DomTypes> ToJSValConvertible for HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue<D> {
3117 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3118 match *self {
3119 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::HTMLImageElement(ref inner) => inner.to_jsval(cx, rval),
3120 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::HTMLVideoElement(ref inner) => inner.to_jsval(cx, rval),
3121 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::HTMLCanvasElement(ref inner) => inner.to_jsval(cx, rval),
3122 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::ImageBitmap(ref inner) => inner.to_jsval(cx, rval),
3123 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::OffscreenCanvas(ref inner) => inner.to_jsval(cx, rval),
3124 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::CSSStyleValue(ref inner) => inner.to_jsval(cx, rval),
3125 }
3126 }
3127}
3128
3129
3130
3131impl<D: DomTypes> FromJSValConvertible for HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue<D> {
3132 type Config = ();
3133 unsafe fn from_jsval(cx: *mut RawJSContext,
3134 value: HandleValue,
3135 _option: ())
3136 -> Result<ConversionResult<HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue<D>>, ()> {
3137 if value.get().is_object() {
3138 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::<D>::TryConvertToHTMLImageElement(SafeJSContext::from_ptr(cx), value) {
3139 Err(_) => return Err(()),
3140 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::HTMLImageElement(value))),
3141 Ok(None) => (),
3142 }
3143 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::<D>::TryConvertToHTMLVideoElement(SafeJSContext::from_ptr(cx), value) {
3144 Err(_) => return Err(()),
3145 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::HTMLVideoElement(value))),
3146 Ok(None) => (),
3147 }
3148 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::<D>::TryConvertToHTMLCanvasElement(SafeJSContext::from_ptr(cx), value) {
3149 Err(_) => return Err(()),
3150 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::HTMLCanvasElement(value))),
3151 Ok(None) => (),
3152 }
3153 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::<D>::TryConvertToImageBitmap(SafeJSContext::from_ptr(cx), value) {
3154 Err(_) => return Err(()),
3155 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::ImageBitmap(value))),
3156 Ok(None) => (),
3157 }
3158 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::<D>::TryConvertToOffscreenCanvas(SafeJSContext::from_ptr(cx), value) {
3159 Err(_) => return Err(()),
3160 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::OffscreenCanvas(value))),
3161 Ok(None) => (),
3162 }
3163 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::<D>::TryConvertToCSSStyleValue(SafeJSContext::from_ptr(cx), value) {
3164 Err(_) => return Err(()),
3165 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue::CSSStyleValue(value))),
3166 Ok(None) => (),
3167 }
3168
3169 }
3170
3171 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLImageElement, HTMLVideoElement, HTMLCanvasElement, ImageBitmap, OffscreenCanvas, CSSStyleValue".into()))
3172 }
3173}
3174
3175impl<D: DomTypes> HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValue<D> {
3176 unsafe fn TryConvertToHTMLImageElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLImageElement>>, ()> {
3177 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3178 Ok(val) => val,
3179 Err(()) => {
3180 return Ok(None);
3181 }
3182 }
3183 ))
3184 }
3185
3186 unsafe fn TryConvertToHTMLVideoElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLVideoElement>>, ()> {
3187 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3188 Ok(val) => val,
3189 Err(()) => {
3190 return Ok(None);
3191 }
3192 }
3193 ))
3194 }
3195
3196 unsafe fn TryConvertToHTMLCanvasElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLCanvasElement>>, ()> {
3197 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3198 Ok(val) => val,
3199 Err(()) => {
3200 return Ok(None);
3201 }
3202 }
3203 ))
3204 }
3205
3206 unsafe fn TryConvertToImageBitmap(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageBitmap>>, ()> {
3207 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3208 Ok(val) => val,
3209 Err(()) => {
3210 return Ok(None);
3211 }
3212 }
3213 ))
3214 }
3215
3216 unsafe fn TryConvertToOffscreenCanvas(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::OffscreenCanvas>>, ()> {
3217 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3218 Ok(val) => val,
3219 Err(()) => {
3220 return Ok(None);
3221 }
3222 }
3223 ))
3224 }
3225
3226 unsafe fn TryConvertToCSSStyleValue(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::CSSStyleValue>>, ()> {
3227 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3228 Ok(val) => val,
3229 Err(()) => {
3230 return Ok(None);
3231 }
3232 }
3233 ))
3234 }
3235}
3236
3237
3238
3239#[derive(JSTraceable)]
3240pub enum HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData<D: DomTypes> {
3241 HTMLImageElement(DomRoot<D::HTMLImageElement>),
3242 HTMLVideoElement(DomRoot<D::HTMLVideoElement>),
3243 HTMLCanvasElement(DomRoot<D::HTMLCanvasElement>),
3244 ImageBitmap(DomRoot<D::ImageBitmap>),
3245 OffscreenCanvas(DomRoot<D::OffscreenCanvas>),
3246 CSSStyleValue(DomRoot<D::CSSStyleValue>),
3247 Blob(DomRoot<D::Blob>),
3248 ImageData(DomRoot<D::ImageData>),
3249}
3250
3251impl<D: DomTypes> ToJSValConvertible for HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData<D> {
3252 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3253 match *self {
3254 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::HTMLImageElement(ref inner) => inner.to_jsval(cx, rval),
3255 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::HTMLVideoElement(ref inner) => inner.to_jsval(cx, rval),
3256 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::HTMLCanvasElement(ref inner) => inner.to_jsval(cx, rval),
3257 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::ImageBitmap(ref inner) => inner.to_jsval(cx, rval),
3258 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::OffscreenCanvas(ref inner) => inner.to_jsval(cx, rval),
3259 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::CSSStyleValue(ref inner) => inner.to_jsval(cx, rval),
3260 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::Blob(ref inner) => inner.to_jsval(cx, rval),
3261 HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::ImageData(ref inner) => inner.to_jsval(cx, rval),
3262 }
3263 }
3264}
3265
3266
3267
3268impl<D: DomTypes> FromJSValConvertible for HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData<D> {
3269 type Config = ();
3270 unsafe fn from_jsval(cx: *mut RawJSContext,
3271 value: HandleValue,
3272 _option: ())
3273 -> Result<ConversionResult<HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData<D>>, ()> {
3274 if value.get().is_object() {
3275 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToHTMLImageElement(SafeJSContext::from_ptr(cx), value) {
3276 Err(_) => return Err(()),
3277 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::HTMLImageElement(value))),
3278 Ok(None) => (),
3279 }
3280 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToHTMLVideoElement(SafeJSContext::from_ptr(cx), value) {
3281 Err(_) => return Err(()),
3282 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::HTMLVideoElement(value))),
3283 Ok(None) => (),
3284 }
3285 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToHTMLCanvasElement(SafeJSContext::from_ptr(cx), value) {
3286 Err(_) => return Err(()),
3287 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::HTMLCanvasElement(value))),
3288 Ok(None) => (),
3289 }
3290 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToImageBitmap(SafeJSContext::from_ptr(cx), value) {
3291 Err(_) => return Err(()),
3292 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::ImageBitmap(value))),
3293 Ok(None) => (),
3294 }
3295 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToOffscreenCanvas(SafeJSContext::from_ptr(cx), value) {
3296 Err(_) => return Err(()),
3297 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::OffscreenCanvas(value))),
3298 Ok(None) => (),
3299 }
3300 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToCSSStyleValue(SafeJSContext::from_ptr(cx), value) {
3301 Err(_) => return Err(()),
3302 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::CSSStyleValue(value))),
3303 Ok(None) => (),
3304 }
3305 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
3306 Err(_) => return Err(()),
3307 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::Blob(value))),
3308 Ok(None) => (),
3309 }
3310 match HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::<D>::TryConvertToImageData(SafeJSContext::from_ptr(cx), value) {
3311 Err(_) => return Err(()),
3312 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData::ImageData(value))),
3313 Ok(None) => (),
3314 }
3315
3316 }
3317
3318 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLImageElement, HTMLVideoElement, HTMLCanvasElement, ImageBitmap, OffscreenCanvas, CSSStyleValue, Blob, ImageData".into()))
3319 }
3320}
3321
3322impl<D: DomTypes> HTMLImageElementOrHTMLVideoElementOrHTMLCanvasElementOrImageBitmapOrOffscreenCanvasOrCSSStyleValueOrBlobOrImageData<D> {
3323 unsafe fn TryConvertToHTMLImageElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLImageElement>>, ()> {
3324 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3325 Ok(val) => val,
3326 Err(()) => {
3327 return Ok(None);
3328 }
3329 }
3330 ))
3331 }
3332
3333 unsafe fn TryConvertToHTMLVideoElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLVideoElement>>, ()> {
3334 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3335 Ok(val) => val,
3336 Err(()) => {
3337 return Ok(None);
3338 }
3339 }
3340 ))
3341 }
3342
3343 unsafe fn TryConvertToHTMLCanvasElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLCanvasElement>>, ()> {
3344 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3345 Ok(val) => val,
3346 Err(()) => {
3347 return Ok(None);
3348 }
3349 }
3350 ))
3351 }
3352
3353 unsafe fn TryConvertToImageBitmap(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageBitmap>>, ()> {
3354 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3355 Ok(val) => val,
3356 Err(()) => {
3357 return Ok(None);
3358 }
3359 }
3360 ))
3361 }
3362
3363 unsafe fn TryConvertToOffscreenCanvas(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::OffscreenCanvas>>, ()> {
3364 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3365 Ok(val) => val,
3366 Err(()) => {
3367 return Ok(None);
3368 }
3369 }
3370 ))
3371 }
3372
3373 unsafe fn TryConvertToCSSStyleValue(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::CSSStyleValue>>, ()> {
3374 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3375 Ok(val) => val,
3376 Err(()) => {
3377 return Ok(None);
3378 }
3379 }
3380 ))
3381 }
3382
3383 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
3384 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3385 Ok(val) => val,
3386 Err(()) => {
3387 return Ok(None);
3388 }
3389 }
3390 ))
3391 }
3392
3393 unsafe fn TryConvertToImageData(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageData>>, ()> {
3394 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3395 Ok(val) => val,
3396 Err(()) => {
3397 return Ok(None);
3398 }
3399 }
3400 ))
3401 }
3402}
3403
3404
3405
3406#[derive(JSTraceable)]
3407pub enum HTMLOptionElementOrHTMLOptGroupElement<D: DomTypes> {
3408 HTMLOptionElement(DomRoot<D::HTMLOptionElement>),
3409 HTMLOptGroupElement(DomRoot<D::HTMLOptGroupElement>),
3410}
3411
3412impl<D: DomTypes> ToJSValConvertible for HTMLOptionElementOrHTMLOptGroupElement<D> {
3413 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3414 match *self {
3415 HTMLOptionElementOrHTMLOptGroupElement::HTMLOptionElement(ref inner) => inner.to_jsval(cx, rval),
3416 HTMLOptionElementOrHTMLOptGroupElement::HTMLOptGroupElement(ref inner) => inner.to_jsval(cx, rval),
3417 }
3418 }
3419}
3420
3421
3422
3423impl<D: DomTypes> FromJSValConvertible for HTMLOptionElementOrHTMLOptGroupElement<D> {
3424 type Config = ();
3425 unsafe fn from_jsval(cx: *mut RawJSContext,
3426 value: HandleValue,
3427 _option: ())
3428 -> Result<ConversionResult<HTMLOptionElementOrHTMLOptGroupElement<D>>, ()> {
3429 if value.get().is_object() {
3430 match HTMLOptionElementOrHTMLOptGroupElement::<D>::TryConvertToHTMLOptionElement(SafeJSContext::from_ptr(cx), value) {
3431 Err(_) => return Err(()),
3432 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLOptionElementOrHTMLOptGroupElement::HTMLOptionElement(value))),
3433 Ok(None) => (),
3434 }
3435 match HTMLOptionElementOrHTMLOptGroupElement::<D>::TryConvertToHTMLOptGroupElement(SafeJSContext::from_ptr(cx), value) {
3436 Err(_) => return Err(()),
3437 Ok(Some(value)) => return Ok(ConversionResult::Success(HTMLOptionElementOrHTMLOptGroupElement::HTMLOptGroupElement(value))),
3438 Ok(None) => (),
3439 }
3440
3441 }
3442
3443 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLOptionElement, HTMLOptGroupElement".into()))
3444 }
3445}
3446
3447impl<D: DomTypes> HTMLOptionElementOrHTMLOptGroupElement<D> {
3448 unsafe fn TryConvertToHTMLOptionElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLOptionElement>>, ()> {
3449 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3450 Ok(val) => val,
3451 Err(()) => {
3452 return Ok(None);
3453 }
3454 }
3455 ))
3456 }
3457
3458 unsafe fn TryConvertToHTMLOptGroupElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLOptGroupElement>>, ()> {
3459 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3460 Ok(val) => val,
3461 Err(()) => {
3462 return Ok(None);
3463 }
3464 }
3465 ))
3466 }
3467}
3468
3469
3470
3471#[derive(JSTraceable)]
3472pub enum IDBObjectStoreOrIDBIndex<D: DomTypes> {
3473 IDBObjectStore(DomRoot<D::IDBObjectStore>),
3474 IDBIndex(DomRoot<D::IDBIndex>),
3475}
3476
3477impl<D: DomTypes> ToJSValConvertible for IDBObjectStoreOrIDBIndex<D> {
3478 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3479 match *self {
3480 IDBObjectStoreOrIDBIndex::IDBObjectStore(ref inner) => inner.to_jsval(cx, rval),
3481 IDBObjectStoreOrIDBIndex::IDBIndex(ref inner) => inner.to_jsval(cx, rval),
3482 }
3483 }
3484}
3485
3486
3487
3488impl<D: DomTypes> FromJSValConvertible for IDBObjectStoreOrIDBIndex<D> {
3489 type Config = ();
3490 unsafe fn from_jsval(cx: *mut RawJSContext,
3491 value: HandleValue,
3492 _option: ())
3493 -> Result<ConversionResult<IDBObjectStoreOrIDBIndex<D>>, ()> {
3494 if value.get().is_object() {
3495 match IDBObjectStoreOrIDBIndex::<D>::TryConvertToIDBObjectStore(SafeJSContext::from_ptr(cx), value) {
3496 Err(_) => return Err(()),
3497 Ok(Some(value)) => return Ok(ConversionResult::Success(IDBObjectStoreOrIDBIndex::IDBObjectStore(value))),
3498 Ok(None) => (),
3499 }
3500 match IDBObjectStoreOrIDBIndex::<D>::TryConvertToIDBIndex(SafeJSContext::from_ptr(cx), value) {
3501 Err(_) => return Err(()),
3502 Ok(Some(value)) => return Ok(ConversionResult::Success(IDBObjectStoreOrIDBIndex::IDBIndex(value))),
3503 Ok(None) => (),
3504 }
3505
3506 }
3507
3508 Ok(ConversionResult::Failure("argument could not be converted to any of: IDBObjectStore, IDBIndex".into()))
3509 }
3510}
3511
3512impl<D: DomTypes> IDBObjectStoreOrIDBIndex<D> {
3513 unsafe fn TryConvertToIDBObjectStore(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::IDBObjectStore>>, ()> {
3514 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3515 Ok(val) => val,
3516 Err(()) => {
3517 return Ok(None);
3518 }
3519 }
3520 ))
3521 }
3522
3523 unsafe fn TryConvertToIDBIndex(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::IDBIndex>>, ()> {
3524 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3525 Ok(val) => val,
3526 Err(()) => {
3527 return Ok(None);
3528 }
3529 }
3530 ))
3531 }
3532}
3533
3534
3535
3536#[derive(JSTraceable)]
3537pub enum ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas<D: DomTypes> {
3538 ImageBitmap(DomRoot<D::ImageBitmap>),
3539 HTMLCanvasElement(DomRoot<D::HTMLCanvasElement>),
3540 OffscreenCanvas(DomRoot<D::OffscreenCanvas>),
3541}
3542
3543impl<D: DomTypes> ToJSValConvertible for ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas<D> {
3544 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3545 match *self {
3546 ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::ImageBitmap(ref inner) => inner.to_jsval(cx, rval),
3547 ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(ref inner) => inner.to_jsval(cx, rval),
3548 ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(ref inner) => inner.to_jsval(cx, rval),
3549 }
3550 }
3551}
3552
3553
3554
3555impl<D: DomTypes> FromJSValConvertible for ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas<D> {
3556 type Config = ();
3557 unsafe fn from_jsval(cx: *mut RawJSContext,
3558 value: HandleValue,
3559 _option: ())
3560 -> Result<ConversionResult<ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas<D>>, ()> {
3561 if value.get().is_object() {
3562 match ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::<D>::TryConvertToImageBitmap(SafeJSContext::from_ptr(cx), value) {
3563 Err(_) => return Err(()),
3564 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::ImageBitmap(value))),
3565 Ok(None) => (),
3566 }
3567 match ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::<D>::TryConvertToHTMLCanvasElement(SafeJSContext::from_ptr(cx), value) {
3568 Err(_) => return Err(()),
3569 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(value))),
3570 Ok(None) => (),
3571 }
3572 match ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::<D>::TryConvertToOffscreenCanvas(SafeJSContext::from_ptr(cx), value) {
3573 Err(_) => return Err(()),
3574 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(value))),
3575 Ok(None) => (),
3576 }
3577
3578 }
3579
3580 Ok(ConversionResult::Failure("argument could not be converted to any of: ImageBitmap, HTMLCanvasElement, OffscreenCanvas".into()))
3581 }
3582}
3583
3584impl<D: DomTypes> ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas<D> {
3585 unsafe fn TryConvertToImageBitmap(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageBitmap>>, ()> {
3586 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3587 Ok(val) => val,
3588 Err(()) => {
3589 return Ok(None);
3590 }
3591 }
3592 ))
3593 }
3594
3595 unsafe fn TryConvertToHTMLCanvasElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLCanvasElement>>, ()> {
3596 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3597 Ok(val) => val,
3598 Err(()) => {
3599 return Ok(None);
3600 }
3601 }
3602 ))
3603 }
3604
3605 unsafe fn TryConvertToOffscreenCanvas(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::OffscreenCanvas>>, ()> {
3606 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3607 Ok(val) => val,
3608 Err(()) => {
3609 return Ok(None);
3610 }
3611 }
3612 ))
3613 }
3614}
3615
3616
3617
3618#[derive(JSTraceable)]
3619pub enum ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement<D: DomTypes> {
3620 ImageBitmap(DomRoot<D::ImageBitmap>),
3621 ImageData(DomRoot<D::ImageData>),
3622 HTMLImageElement(DomRoot<D::HTMLImageElement>),
3623 HTMLCanvasElement(DomRoot<D::HTMLCanvasElement>),
3624 HTMLVideoElement(DomRoot<D::HTMLVideoElement>),
3625}
3626
3627impl<D: DomTypes> ToJSValConvertible for ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement<D> {
3628 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3629 match *self {
3630 ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::ImageBitmap(ref inner) => inner.to_jsval(cx, rval),
3631 ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::ImageData(ref inner) => inner.to_jsval(cx, rval),
3632 ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLImageElement(ref inner) => inner.to_jsval(cx, rval),
3633 ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLCanvasElement(ref inner) => inner.to_jsval(cx, rval),
3634 ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLVideoElement(ref inner) => inner.to_jsval(cx, rval),
3635 }
3636 }
3637}
3638
3639
3640
3641impl<D: DomTypes> FromJSValConvertible for ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement<D> {
3642 type Config = ();
3643 unsafe fn from_jsval(cx: *mut RawJSContext,
3644 value: HandleValue,
3645 _option: ())
3646 -> Result<ConversionResult<ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement<D>>, ()> {
3647 if value.get().is_object() {
3648 match ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>::TryConvertToImageBitmap(SafeJSContext::from_ptr(cx), value) {
3649 Err(_) => return Err(()),
3650 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::ImageBitmap(value))),
3651 Ok(None) => (),
3652 }
3653 match ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>::TryConvertToImageData(SafeJSContext::from_ptr(cx), value) {
3654 Err(_) => return Err(()),
3655 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::ImageData(value))),
3656 Ok(None) => (),
3657 }
3658 match ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>::TryConvertToHTMLImageElement(SafeJSContext::from_ptr(cx), value) {
3659 Err(_) => return Err(()),
3660 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLImageElement(value))),
3661 Ok(None) => (),
3662 }
3663 match ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>::TryConvertToHTMLCanvasElement(SafeJSContext::from_ptr(cx), value) {
3664 Err(_) => return Err(()),
3665 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLCanvasElement(value))),
3666 Ok(None) => (),
3667 }
3668 match ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>::TryConvertToHTMLVideoElement(SafeJSContext::from_ptr(cx), value) {
3669 Err(_) => return Err(()),
3670 Ok(Some(value)) => return Ok(ConversionResult::Success(ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::HTMLVideoElement(value))),
3671 Ok(None) => (),
3672 }
3673
3674 }
3675
3676 Ok(ConversionResult::Failure("argument could not be converted to any of: ImageBitmap, ImageData, HTMLImageElement, HTMLCanvasElement, HTMLVideoElement".into()))
3677 }
3678}
3679
3680impl<D: DomTypes> ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement<D> {
3681 unsafe fn TryConvertToImageBitmap(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageBitmap>>, ()> {
3682 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3683 Ok(val) => val,
3684 Err(()) => {
3685 return Ok(None);
3686 }
3687 }
3688 ))
3689 }
3690
3691 unsafe fn TryConvertToImageData(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageData>>, ()> {
3692 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3693 Ok(val) => val,
3694 Err(()) => {
3695 return Ok(None);
3696 }
3697 }
3698 ))
3699 }
3700
3701 unsafe fn TryConvertToHTMLImageElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLImageElement>>, ()> {
3702 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3703 Ok(val) => val,
3704 Err(()) => {
3705 return Ok(None);
3706 }
3707 }
3708 ))
3709 }
3710
3711 unsafe fn TryConvertToHTMLCanvasElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLCanvasElement>>, ()> {
3712 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3713 Ok(val) => val,
3714 Err(()) => {
3715 return Ok(None);
3716 }
3717 }
3718 ))
3719 }
3720
3721 unsafe fn TryConvertToHTMLVideoElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLVideoElement>>, ()> {
3722 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
3723 Ok(val) => val,
3724 Err(()) => {
3725 return Ok(None);
3726 }
3727 }
3728 ))
3729 }
3730}
3731
3732
3733
3734#[derive(JSTraceable)]
3735pub enum Int32ArrayOrLongSequence {
3736 Int32Array(RootedTraceableBox<typedarray::HeapInt32Array>),
3737 LongSequence(Vec<i32>),
3738}
3739
3740impl ToJSValConvertible for Int32ArrayOrLongSequence {
3741 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3742 match *self {
3743 Int32ArrayOrLongSequence::Int32Array(ref inner) => inner.to_jsval(cx, rval),
3744 Int32ArrayOrLongSequence::LongSequence(ref inner) => inner.to_jsval(cx, rval),
3745 }
3746 }
3747}
3748
3749
3750
3751impl FromJSValConvertible for Int32ArrayOrLongSequence {
3752 type Config = ();
3753 unsafe fn from_jsval(cx: *mut RawJSContext,
3754 value: HandleValue,
3755 _option: ())
3756 -> Result<ConversionResult<Int32ArrayOrLongSequence>, ()> {
3757 if value.get().is_object() {
3758 match Int32ArrayOrLongSequence::TryConvertToLongSequence(SafeJSContext::from_ptr(cx), value) {
3759 Err(_) => return Err(()),
3760 Ok(Some(value)) => return Ok(ConversionResult::Success(Int32ArrayOrLongSequence::LongSequence(value))),
3761 Ok(None) => (),
3762 }
3763
3764 match Int32ArrayOrLongSequence::TryConvertToInt32Array(SafeJSContext::from_ptr(cx), value) {
3765 Err(_) => return Err(()),
3766 Ok(Some(value)) => return Ok(ConversionResult::Success(Int32ArrayOrLongSequence::Int32Array(value))),
3767 Ok(None) => (),
3768 }
3769
3770 }
3771
3772 Ok(ConversionResult::Failure("argument could not be converted to any of: Int32Array, LongSequence".into()))
3773 }
3774}
3775
3776impl Int32ArrayOrLongSequence {
3777 unsafe fn TryConvertToInt32Array(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapInt32Array>>, ()> {
3778 Ok(Some(match typedarray::HeapInt32Array::from(value.get().to_object()).map(RootedTraceableBox::new) {
3779 Ok(val) => val,
3780 Err(()) => {
3781 return Ok(None);
3782 }
3783 }
3784 ))
3785 }
3786
3787 unsafe fn TryConvertToLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<i32>>, ()> {
3788 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
3789 Ok(ConversionResult::Success(value)) => value,
3790 Ok(ConversionResult::Failure(error)) => {
3791 return Ok(None);
3792 }
3793 _ => {
3794 return Err(());
3795 },
3796 }
3797 ))
3798 }
3799}
3800
3801
3802
3803#[derive(JSTraceable)]
3804pub enum LongOrLongSequenceSequence {
3805 Long(i32),
3806 LongSequenceSequence(Vec<Vec<i32>>),
3807}
3808
3809impl ToJSValConvertible for LongOrLongSequenceSequence {
3810 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3811 match *self {
3812 LongOrLongSequenceSequence::Long(ref inner) => inner.to_jsval(cx, rval),
3813 LongOrLongSequenceSequence::LongSequenceSequence(ref inner) => inner.to_jsval(cx, rval),
3814 }
3815 }
3816}
3817
3818
3819
3820impl FromJSValConvertible for LongOrLongSequenceSequence {
3821 type Config = ();
3822 unsafe fn from_jsval(cx: *mut RawJSContext,
3823 value: HandleValue,
3824 _option: ())
3825 -> Result<ConversionResult<LongOrLongSequenceSequence>, ()> {
3826 if value.get().is_object() {
3827 match LongOrLongSequenceSequence::TryConvertToLongSequenceSequence(SafeJSContext::from_ptr(cx), value) {
3828 Err(_) => return Err(()),
3829 Ok(Some(value)) => return Ok(ConversionResult::Success(LongOrLongSequenceSequence::LongSequenceSequence(value))),
3830 Ok(None) => (),
3831 }
3832
3833 }
3834
3835 match LongOrLongSequenceSequence::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
3836 Err(_) => return Err(()),
3837 Ok(Some(value)) => return Ok(ConversionResult::Success(LongOrLongSequenceSequence::Long(value))),
3838 Ok(None) => (),
3839 }
3840
3841
3842 Ok(ConversionResult::Failure("argument could not be converted to any of: LongSequenceSequence".into()))
3843 }
3844}
3845
3846impl LongOrLongSequenceSequence {
3847 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
3848 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
3849 Ok(ConversionResult::Success(value)) => value,
3850 Ok(ConversionResult::Failure(error)) => {
3851 return Ok(None);
3852 }
3853 _ => {
3854 return Err(());
3855 },
3856 }
3857 ))
3858 }
3859
3860 unsafe fn TryConvertToLongSequenceSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<Vec<i32>>>, ()> {
3861 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
3862 Ok(ConversionResult::Success(value)) => value,
3863 Ok(ConversionResult::Failure(error)) => {
3864 return Ok(None);
3865 }
3866 _ => {
3867 return Err(());
3868 },
3869 }
3870 ))
3871 }
3872}
3873
3874
3875
3876#[derive(JSTraceable)]
3877pub enum LongOrStringByteStringRecord {
3878 Long(i32),
3879 StringByteStringRecord(Record<DOMString, ByteString>),
3880}
3881
3882impl ToJSValConvertible for LongOrStringByteStringRecord {
3883 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3884 match *self {
3885 LongOrStringByteStringRecord::Long(ref inner) => inner.to_jsval(cx, rval),
3886 LongOrStringByteStringRecord::StringByteStringRecord(ref inner) => inner.to_jsval(cx, rval),
3887 }
3888 }
3889}
3890
3891
3892
3893impl FromJSValConvertible for LongOrStringByteStringRecord {
3894 type Config = ();
3895 unsafe fn from_jsval(cx: *mut RawJSContext,
3896 value: HandleValue,
3897 _option: ())
3898 -> Result<ConversionResult<LongOrStringByteStringRecord>, ()> {
3899 if value.get().is_object() {
3900 match LongOrStringByteStringRecord::TryConvertToStringByteStringRecord(SafeJSContext::from_ptr(cx), value) {
3901 Err(_) => return Err(()),
3902 Ok(Some(value)) => return Ok(ConversionResult::Success(LongOrStringByteStringRecord::StringByteStringRecord(value))),
3903 Ok(None) => (),
3904 }
3905
3906 }
3907
3908 match LongOrStringByteStringRecord::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
3909 Err(_) => return Err(()),
3910 Ok(Some(value)) => return Ok(ConversionResult::Success(LongOrStringByteStringRecord::Long(value))),
3911 Ok(None) => (),
3912 }
3913
3914
3915 Ok(ConversionResult::Failure("argument could not be converted to any of: StringByteStringRecord".into()))
3916 }
3917}
3918
3919impl LongOrStringByteStringRecord {
3920 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
3921 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
3922 Ok(ConversionResult::Success(value)) => value,
3923 Ok(ConversionResult::Failure(error)) => {
3924 return Ok(None);
3925 }
3926 _ => {
3927 return Err(());
3928 },
3929 }
3930 ))
3931 }
3932
3933 unsafe fn TryConvertToStringByteStringRecord(cx: SafeJSContext, value: HandleValue) -> Result<Option<Record<DOMString, ByteString>>, ()> {
3934 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
3935 Ok(ConversionResult::Success(value)) => value,
3936 Ok(ConversionResult::Failure(error)) => {
3937 return Ok(None);
3938 }
3939 _ => {
3940 return Err(());
3941 },
3942 }
3943 ))
3944 }
3945}
3946
3947
3948
3949#[derive(JSTraceable)]
3950pub enum LongSequenceOrBoolean {
3951 LongSequence(Vec<i32>),
3952 Boolean(bool),
3953}
3954
3955impl ToJSValConvertible for LongSequenceOrBoolean {
3956 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
3957 match *self {
3958 LongSequenceOrBoolean::LongSequence(ref inner) => inner.to_jsval(cx, rval),
3959 LongSequenceOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
3960 }
3961 }
3962}
3963
3964
3965
3966impl FromJSValConvertible for LongSequenceOrBoolean {
3967 type Config = ();
3968 unsafe fn from_jsval(cx: *mut RawJSContext,
3969 value: HandleValue,
3970 _option: ())
3971 -> Result<ConversionResult<LongSequenceOrBoolean>, ()> {
3972 if value.get().is_object() {
3973 match LongSequenceOrBoolean::TryConvertToLongSequence(SafeJSContext::from_ptr(cx), value) {
3974 Err(_) => return Err(()),
3975 Ok(Some(value)) => return Ok(ConversionResult::Success(LongSequenceOrBoolean::LongSequence(value))),
3976 Ok(None) => (),
3977 }
3978
3979 }
3980
3981 match LongSequenceOrBoolean::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
3982 Err(_) => return Err(()),
3983 Ok(Some(value)) => return Ok(ConversionResult::Success(LongSequenceOrBoolean::Boolean(value))),
3984 Ok(None) => (),
3985 }
3986
3987
3988 Ok(ConversionResult::Failure("argument could not be converted to any of: LongSequence".into()))
3989 }
3990}
3991
3992impl LongSequenceOrBoolean {
3993 unsafe fn TryConvertToLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<i32>>, ()> {
3994 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
3995 Ok(ConversionResult::Success(value)) => value,
3996 Ok(ConversionResult::Failure(error)) => {
3997 return Ok(None);
3998 }
3999 _ => {
4000 return Err(());
4001 },
4002 }
4003 ))
4004 }
4005
4006 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
4007 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
4008 Ok(ConversionResult::Success(value)) => value,
4009 Ok(ConversionResult::Failure(error)) => {
4010 return Ok(None);
4011 }
4012 _ => {
4013 return Err(());
4014 },
4015 }
4016 ))
4017 }
4018}
4019
4020
4021
4022#[derive(JSTraceable)]
4023pub enum LongSequenceOrStringOrURLOrBlob<D: DomTypes> {
4024 LongSequence(Vec<i32>),
4025 String(DOMString),
4026 URL(DomRoot<D::URL>),
4027 Blob(DomRoot<D::Blob>),
4028}
4029
4030impl<D: DomTypes> ToJSValConvertible for LongSequenceOrStringOrURLOrBlob<D> {
4031 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4032 match *self {
4033 LongSequenceOrStringOrURLOrBlob::LongSequence(ref inner) => inner.to_jsval(cx, rval),
4034 LongSequenceOrStringOrURLOrBlob::String(ref inner) => inner.to_jsval(cx, rval),
4035 LongSequenceOrStringOrURLOrBlob::URL(ref inner) => inner.to_jsval(cx, rval),
4036 LongSequenceOrStringOrURLOrBlob::Blob(ref inner) => inner.to_jsval(cx, rval),
4037 }
4038 }
4039}
4040
4041
4042
4043impl<D: DomTypes> FromJSValConvertible for LongSequenceOrStringOrURLOrBlob<D> {
4044 type Config = ();
4045 unsafe fn from_jsval(cx: *mut RawJSContext,
4046 value: HandleValue,
4047 _option: ())
4048 -> Result<ConversionResult<LongSequenceOrStringOrURLOrBlob<D>>, ()> {
4049 if value.get().is_object() {
4050 match LongSequenceOrStringOrURLOrBlob::<D>::TryConvertToLongSequence(SafeJSContext::from_ptr(cx), value) {
4051 Err(_) => return Err(()),
4052 Ok(Some(value)) => return Ok(ConversionResult::Success(LongSequenceOrStringOrURLOrBlob::LongSequence(value))),
4053 Ok(None) => (),
4054 }
4055
4056 match LongSequenceOrStringOrURLOrBlob::<D>::TryConvertToURL(SafeJSContext::from_ptr(cx), value) {
4057 Err(_) => return Err(()),
4058 Ok(Some(value)) => return Ok(ConversionResult::Success(LongSequenceOrStringOrURLOrBlob::URL(value))),
4059 Ok(None) => (),
4060 }
4061 match LongSequenceOrStringOrURLOrBlob::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
4062 Err(_) => return Err(()),
4063 Ok(Some(value)) => return Ok(ConversionResult::Success(LongSequenceOrStringOrURLOrBlob::Blob(value))),
4064 Ok(None) => (),
4065 }
4066
4067 }
4068
4069 match LongSequenceOrStringOrURLOrBlob::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
4070 Err(_) => return Err(()),
4071 Ok(Some(value)) => return Ok(ConversionResult::Success(LongSequenceOrStringOrURLOrBlob::String(value))),
4072 Ok(None) => (),
4073 }
4074
4075
4076 Ok(ConversionResult::Failure("argument could not be converted to any of: URL, Blob, LongSequence".into()))
4077 }
4078}
4079
4080impl<D: DomTypes> LongSequenceOrStringOrURLOrBlob<D> {
4081 unsafe fn TryConvertToLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<i32>>, ()> {
4082 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
4083 Ok(ConversionResult::Success(value)) => value,
4084 Ok(ConversionResult::Failure(error)) => {
4085 return Ok(None);
4086 }
4087 _ => {
4088 return Err(());
4089 },
4090 }
4091 ))
4092 }
4093
4094 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
4095 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
4096 Ok(ConversionResult::Success(value)) => value,
4097 Ok(ConversionResult::Failure(error)) => {
4098 return Ok(None);
4099 }
4100 _ => {
4101 return Err(());
4102 },
4103 }
4104 ))
4105 }
4106
4107 unsafe fn TryConvertToURL(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::URL>>, ()> {
4108 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4109 Ok(val) => val,
4110 Err(()) => {
4111 return Ok(None);
4112 }
4113 }
4114 ))
4115 }
4116
4117 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
4118 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4119 Ok(val) => val,
4120 Err(()) => {
4121 return Ok(None);
4122 }
4123 }
4124 ))
4125 }
4126}
4127
4128
4129
4130#[derive(JSTraceable)]
4131pub enum MediaListOrString<D: DomTypes> {
4132 MediaList(DomRoot<D::MediaList>),
4133 String(DOMString),
4134}
4135
4136impl<D: DomTypes> ToJSValConvertible for MediaListOrString<D> {
4137 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4138 match *self {
4139 MediaListOrString::MediaList(ref inner) => inner.to_jsval(cx, rval),
4140 MediaListOrString::String(ref inner) => inner.to_jsval(cx, rval),
4141 }
4142 }
4143}
4144
4145
4146
4147impl<D: DomTypes> FromJSValConvertible for MediaListOrString<D> {
4148 type Config = ();
4149 unsafe fn from_jsval(cx: *mut RawJSContext,
4150 value: HandleValue,
4151 _option: ())
4152 -> Result<ConversionResult<MediaListOrString<D>>, ()> {
4153 if value.get().is_object() {
4154 match MediaListOrString::<D>::TryConvertToMediaList(SafeJSContext::from_ptr(cx), value) {
4155 Err(_) => return Err(()),
4156 Ok(Some(value)) => return Ok(ConversionResult::Success(MediaListOrString::MediaList(value))),
4157 Ok(None) => (),
4158 }
4159
4160 }
4161
4162 match MediaListOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
4163 Err(_) => return Err(()),
4164 Ok(Some(value)) => return Ok(ConversionResult::Success(MediaListOrString::String(value))),
4165 Ok(None) => (),
4166 }
4167
4168
4169 Ok(ConversionResult::Failure("argument could not be converted to any of: MediaList".into()))
4170 }
4171}
4172
4173impl<D: DomTypes> MediaListOrString<D> {
4174 unsafe fn TryConvertToMediaList(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::MediaList>>, ()> {
4175 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4176 Ok(val) => val,
4177 Err(()) => {
4178 return Ok(None);
4179 }
4180 }
4181 ))
4182 }
4183
4184 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
4185 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
4186 Ok(ConversionResult::Success(value)) => value,
4187 Ok(ConversionResult::Failure(error)) => {
4188 return Ok(None);
4189 }
4190 _ => {
4191 return Err(());
4192 },
4193 }
4194 ))
4195 }
4196}
4197
4198
4199
4200#[derive(JSTraceable)]
4201pub enum MediaStreamOrBlob<D: DomTypes> {
4202 MediaStream(DomRoot<D::MediaStream>),
4203 Blob(DomRoot<D::Blob>),
4204}
4205
4206impl<D: DomTypes> ToJSValConvertible for MediaStreamOrBlob<D> {
4207 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4208 match *self {
4209 MediaStreamOrBlob::MediaStream(ref inner) => inner.to_jsval(cx, rval),
4210 MediaStreamOrBlob::Blob(ref inner) => inner.to_jsval(cx, rval),
4211 }
4212 }
4213}
4214
4215
4216
4217impl<D: DomTypes> FromJSValConvertible for MediaStreamOrBlob<D> {
4218 type Config = ();
4219 unsafe fn from_jsval(cx: *mut RawJSContext,
4220 value: HandleValue,
4221 _option: ())
4222 -> Result<ConversionResult<MediaStreamOrBlob<D>>, ()> {
4223 if value.get().is_object() {
4224 match MediaStreamOrBlob::<D>::TryConvertToMediaStream(SafeJSContext::from_ptr(cx), value) {
4225 Err(_) => return Err(()),
4226 Ok(Some(value)) => return Ok(ConversionResult::Success(MediaStreamOrBlob::MediaStream(value))),
4227 Ok(None) => (),
4228 }
4229 match MediaStreamOrBlob::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
4230 Err(_) => return Err(()),
4231 Ok(Some(value)) => return Ok(ConversionResult::Success(MediaStreamOrBlob::Blob(value))),
4232 Ok(None) => (),
4233 }
4234
4235 }
4236
4237 Ok(ConversionResult::Failure("argument could not be converted to any of: MediaStream, Blob".into()))
4238 }
4239}
4240
4241impl<D: DomTypes> MediaStreamOrBlob<D> {
4242 unsafe fn TryConvertToMediaStream(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::MediaStream>>, ()> {
4243 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4244 Ok(val) => val,
4245 Err(()) => {
4246 return Ok(None);
4247 }
4248 }
4249 ))
4250 }
4251
4252 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
4253 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4254 Ok(val) => val,
4255 Err(()) => {
4256 return Ok(None);
4257 }
4258 }
4259 ))
4260 }
4261}
4262
4263
4264
4265#[derive(JSTraceable)]
4266pub enum MediaStreamTrackOrString<D: DomTypes> {
4267 MediaStreamTrack(DomRoot<D::MediaStreamTrack>),
4268 String(DOMString),
4269}
4270
4271impl<D: DomTypes> ToJSValConvertible for MediaStreamTrackOrString<D> {
4272 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4273 match *self {
4274 MediaStreamTrackOrString::MediaStreamTrack(ref inner) => inner.to_jsval(cx, rval),
4275 MediaStreamTrackOrString::String(ref inner) => inner.to_jsval(cx, rval),
4276 }
4277 }
4278}
4279
4280
4281
4282impl<D: DomTypes> FromJSValConvertible for MediaStreamTrackOrString<D> {
4283 type Config = ();
4284 unsafe fn from_jsval(cx: *mut RawJSContext,
4285 value: HandleValue,
4286 _option: ())
4287 -> Result<ConversionResult<MediaStreamTrackOrString<D>>, ()> {
4288 if value.get().is_object() {
4289 match MediaStreamTrackOrString::<D>::TryConvertToMediaStreamTrack(SafeJSContext::from_ptr(cx), value) {
4290 Err(_) => return Err(()),
4291 Ok(Some(value)) => return Ok(ConversionResult::Success(MediaStreamTrackOrString::MediaStreamTrack(value))),
4292 Ok(None) => (),
4293 }
4294
4295 }
4296
4297 match MediaStreamTrackOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
4298 Err(_) => return Err(()),
4299 Ok(Some(value)) => return Ok(ConversionResult::Success(MediaStreamTrackOrString::String(value))),
4300 Ok(None) => (),
4301 }
4302
4303
4304 Ok(ConversionResult::Failure("argument could not be converted to any of: MediaStreamTrack".into()))
4305 }
4306}
4307
4308impl<D: DomTypes> MediaStreamTrackOrString<D> {
4309 unsafe fn TryConvertToMediaStreamTrack(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::MediaStreamTrack>>, ()> {
4310 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4311 Ok(val) => val,
4312 Err(()) => {
4313 return Ok(None);
4314 }
4315 }
4316 ))
4317 }
4318
4319 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
4320 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
4321 Ok(ConversionResult::Success(value)) => value,
4322 Ok(ConversionResult::Failure(error)) => {
4323 return Ok(None);
4324 }
4325 _ => {
4326 return Err(());
4327 },
4328 }
4329 ))
4330 }
4331}
4332
4333
4334
4335#[derive(JSTraceable)]
4336pub enum NodeOrString<D: DomTypes> {
4337 Node(DomRoot<D::Node>),
4338 String(DOMString),
4339}
4340
4341impl<D: DomTypes> ToJSValConvertible for NodeOrString<D> {
4342 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4343 match *self {
4344 NodeOrString::Node(ref inner) => inner.to_jsval(cx, rval),
4345 NodeOrString::String(ref inner) => inner.to_jsval(cx, rval),
4346 }
4347 }
4348}
4349
4350
4351
4352impl<D: DomTypes> FromJSValConvertible for NodeOrString<D> {
4353 type Config = ();
4354 unsafe fn from_jsval(cx: *mut RawJSContext,
4355 value: HandleValue,
4356 _option: ())
4357 -> Result<ConversionResult<NodeOrString<D>>, ()> {
4358 if value.get().is_object() {
4359 match NodeOrString::<D>::TryConvertToNode(SafeJSContext::from_ptr(cx), value) {
4360 Err(_) => return Err(()),
4361 Ok(Some(value)) => return Ok(ConversionResult::Success(NodeOrString::Node(value))),
4362 Ok(None) => (),
4363 }
4364
4365 }
4366
4367 match NodeOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
4368 Err(_) => return Err(()),
4369 Ok(Some(value)) => return Ok(ConversionResult::Success(NodeOrString::String(value))),
4370 Ok(None) => (),
4371 }
4372
4373
4374 Ok(ConversionResult::Failure("argument could not be converted to any of: Node".into()))
4375 }
4376}
4377
4378impl<D: DomTypes> NodeOrString<D> {
4379 unsafe fn TryConvertToNode(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Node>>, ()> {
4380 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4381 Ok(val) => val,
4382 Err(()) => {
4383 return Ok(None);
4384 }
4385 }
4386 ))
4387 }
4388
4389 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
4390 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
4391 Ok(ConversionResult::Success(value)) => value,
4392 Ok(ConversionResult::Failure(error)) => {
4393 return Ok(None);
4394 }
4395 _ => {
4396 return Err(());
4397 },
4398 }
4399 ))
4400 }
4401}
4402
4403
4404
4405#[derive(JSTraceable)]
4406pub enum ObjectOrString {
4407 Object(RootedTraceableBox<Heap<*mut JSObject>>),
4408 String(DOMString),
4409}
4410
4411impl ToJSValConvertible for ObjectOrString {
4412 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4413 match *self {
4414 ObjectOrString::Object(ref inner) => inner.to_jsval(cx, rval),
4415 ObjectOrString::String(ref inner) => inner.to_jsval(cx, rval),
4416 }
4417 }
4418}
4419
4420
4421
4422impl FromJSValConvertible for ObjectOrString {
4423 type Config = ();
4424 unsafe fn from_jsval(cx: *mut RawJSContext,
4425 value: HandleValue,
4426 _option: ())
4427 -> Result<ConversionResult<ObjectOrString>, ()> {
4428 if value.get().is_object() {
4429 match ObjectOrString::TryConvertToObject(SafeJSContext::from_ptr(cx), value) {
4430 Err(_) => return Err(()),
4431 Ok(Some(value)) => return Ok(ConversionResult::Success(ObjectOrString::Object(value))),
4432 Ok(None) => (),
4433 }
4434
4435 }
4436
4437 match ObjectOrString::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
4438 Err(_) => return Err(()),
4439 Ok(Some(value)) => return Ok(ConversionResult::Success(ObjectOrString::String(value))),
4440 Ok(None) => (),
4441 }
4442
4443
4444 Ok(ConversionResult::Failure("argument could not be converted to any of: Object".into()))
4445 }
4446}
4447
4448impl ObjectOrString {
4449 unsafe fn TryConvertToObject(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<Heap<*mut JSObject>>>, ()> {
4450 Ok(Some(RootedTraceableBox::from_box(Heap::boxed(value.get().to_object()))))
4451 }
4452
4453 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
4454 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
4455 Ok(ConversionResult::Success(value)) => value,
4456 Ok(ConversionResult::Failure(error)) => {
4457 return Ok(None);
4458 }
4459 _ => {
4460 return Err(());
4461 },
4462 }
4463 ))
4464 }
4465}
4466
4467
4468
4469#[derive(JSTraceable)]
4470pub enum OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext<D: DomTypes> {
4471 OffscreenCanvasRenderingContext2D(DomRoot<D::OffscreenCanvasRenderingContext2D>),
4472 ImageBitmapRenderingContext(DomRoot<D::ImageBitmapRenderingContext>),
4473 WebGLRenderingContext(DomRoot<D::WebGLRenderingContext>),
4474 WebGL2RenderingContext(DomRoot<D::WebGL2RenderingContext>),
4475}
4476
4477impl<D: DomTypes> ToJSValConvertible for OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext<D> {
4478 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4479 match *self {
4480 OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::OffscreenCanvasRenderingContext2D(ref inner) => inner.to_jsval(cx, rval),
4481 OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::ImageBitmapRenderingContext(ref inner) => inner.to_jsval(cx, rval),
4482 OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::WebGLRenderingContext(ref inner) => inner.to_jsval(cx, rval),
4483 OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::WebGL2RenderingContext(ref inner) => inner.to_jsval(cx, rval),
4484 }
4485 }
4486}
4487
4488
4489
4490impl<D: DomTypes> FromJSValConvertible for OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext<D> {
4491 type Config = ();
4492 unsafe fn from_jsval(cx: *mut RawJSContext,
4493 value: HandleValue,
4494 _option: ())
4495 -> Result<ConversionResult<OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext<D>>, ()> {
4496 if value.get().is_object() {
4497 match OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::<D>::TryConvertToOffscreenCanvasRenderingContext2D(SafeJSContext::from_ptr(cx), value) {
4498 Err(_) => return Err(()),
4499 Ok(Some(value)) => return Ok(ConversionResult::Success(OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::OffscreenCanvasRenderingContext2D(value))),
4500 Ok(None) => (),
4501 }
4502 match OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::<D>::TryConvertToImageBitmapRenderingContext(SafeJSContext::from_ptr(cx), value) {
4503 Err(_) => return Err(()),
4504 Ok(Some(value)) => return Ok(ConversionResult::Success(OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::ImageBitmapRenderingContext(value))),
4505 Ok(None) => (),
4506 }
4507 match OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::<D>::TryConvertToWebGLRenderingContext(SafeJSContext::from_ptr(cx), value) {
4508 Err(_) => return Err(()),
4509 Ok(Some(value)) => return Ok(ConversionResult::Success(OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::WebGLRenderingContext(value))),
4510 Ok(None) => (),
4511 }
4512 match OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::<D>::TryConvertToWebGL2RenderingContext(SafeJSContext::from_ptr(cx), value) {
4513 Err(_) => return Err(()),
4514 Ok(Some(value)) => return Ok(ConversionResult::Success(OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext::WebGL2RenderingContext(value))),
4515 Ok(None) => (),
4516 }
4517
4518 }
4519
4520 Ok(ConversionResult::Failure("argument could not be converted to any of: OffscreenCanvasRenderingContext2D, ImageBitmapRenderingContext, WebGLRenderingContext, WebGL2RenderingContext".into()))
4521 }
4522}
4523
4524impl<D: DomTypes> OffscreenCanvasRenderingContext2DOrImageBitmapRenderingContextOrWebGLRenderingContextOrWebGL2RenderingContext<D> {
4525 unsafe fn TryConvertToOffscreenCanvasRenderingContext2D(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::OffscreenCanvasRenderingContext2D>>, ()> {
4526 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4527 Ok(val) => val,
4528 Err(()) => {
4529 return Ok(None);
4530 }
4531 }
4532 ))
4533 }
4534
4535 unsafe fn TryConvertToImageBitmapRenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ImageBitmapRenderingContext>>, ()> {
4536 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4537 Ok(val) => val,
4538 Err(()) => {
4539 return Ok(None);
4540 }
4541 }
4542 ))
4543 }
4544
4545 unsafe fn TryConvertToWebGLRenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WebGLRenderingContext>>, ()> {
4546 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4547 Ok(val) => val,
4548 Err(()) => {
4549 return Ok(None);
4550 }
4551 }
4552 ))
4553 }
4554
4555 unsafe fn TryConvertToWebGL2RenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WebGL2RenderingContext>>, ()> {
4556 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4557 Ok(val) => val,
4558 Err(()) => {
4559 return Ok(None);
4560 }
4561 }
4562 ))
4563 }
4564}
4565
4566
4567
4568#[derive(JSTraceable)]
4569pub enum PasswordCredentialDataOrHTMLFormElement<D: DomTypes> {
4570 PasswordCredentialData(PasswordCredentialData),
4571 HTMLFormElement(DomRoot<D::HTMLFormElement>),
4572}
4573
4574impl<D: DomTypes> ToJSValConvertible for PasswordCredentialDataOrHTMLFormElement<D> {
4575 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4576 match *self {
4577 PasswordCredentialDataOrHTMLFormElement::PasswordCredentialData(ref inner) => inner.to_jsval(cx, rval),
4578 PasswordCredentialDataOrHTMLFormElement::HTMLFormElement(ref inner) => inner.to_jsval(cx, rval),
4579 }
4580 }
4581}
4582
4583
4584
4585impl<D: DomTypes> FromJSValConvertible for PasswordCredentialDataOrHTMLFormElement<D> {
4586 type Config = ();
4587 unsafe fn from_jsval(cx: *mut RawJSContext,
4588 value: HandleValue,
4589 _option: ())
4590 -> Result<ConversionResult<PasswordCredentialDataOrHTMLFormElement<D>>, ()> {
4591 if value.get().is_object() {
4592 match PasswordCredentialDataOrHTMLFormElement::<D>::TryConvertToHTMLFormElement(SafeJSContext::from_ptr(cx), value) {
4593 Err(_) => return Err(()),
4594 Ok(Some(value)) => return Ok(ConversionResult::Success(PasswordCredentialDataOrHTMLFormElement::HTMLFormElement(value))),
4595 Ok(None) => (),
4596 }
4597
4598 }
4599
4600 match PasswordCredentialDataOrHTMLFormElement::<D>::TryConvertToPasswordCredentialData(SafeJSContext::from_ptr(cx), value) {
4601 Err(_) => return Err(()),
4602 Ok(Some(value)) => return Ok(ConversionResult::Success(PasswordCredentialDataOrHTMLFormElement::PasswordCredentialData(value))),
4603 Ok(None) => (),
4604 }
4605
4606
4607 Ok(ConversionResult::Failure("argument could not be converted to any of: HTMLFormElement, PasswordCredentialData".into()))
4608 }
4609}
4610
4611impl<D: DomTypes> PasswordCredentialDataOrHTMLFormElement<D> {
4612 unsafe fn TryConvertToPasswordCredentialData(cx: SafeJSContext, value: HandleValue) -> Result<Option<PasswordCredentialData>, ()> {
4613 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
4614 Ok(ConversionResult::Success(value)) => value,
4615 Ok(ConversionResult::Failure(error)) => {
4616 return Ok(None);
4617 }
4618 _ => {
4619 return Err(());
4620 },
4621 }
4622 ))
4623 }
4624
4625 unsafe fn TryConvertToHTMLFormElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLFormElement>>, ()> {
4626 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4627 Ok(val) => val,
4628 Err(()) => {
4629 return Ok(None);
4630 }
4631 }
4632 ))
4633 }
4634}
4635
4636
4637
4638#[derive(JSTraceable)]
4639pub enum RadioNodeListOrElement<D: DomTypes> {
4640 RadioNodeList(DomRoot<D::RadioNodeList>),
4641 Element(DomRoot<D::Element>),
4642}
4643
4644impl<D: DomTypes> ToJSValConvertible for RadioNodeListOrElement<D> {
4645 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4646 match *self {
4647 RadioNodeListOrElement::RadioNodeList(ref inner) => inner.to_jsval(cx, rval),
4648 RadioNodeListOrElement::Element(ref inner) => inner.to_jsval(cx, rval),
4649 }
4650 }
4651}
4652
4653
4654
4655impl<D: DomTypes> FromJSValConvertible for RadioNodeListOrElement<D> {
4656 type Config = ();
4657 unsafe fn from_jsval(cx: *mut RawJSContext,
4658 value: HandleValue,
4659 _option: ())
4660 -> Result<ConversionResult<RadioNodeListOrElement<D>>, ()> {
4661 if value.get().is_object() {
4662 match RadioNodeListOrElement::<D>::TryConvertToRadioNodeList(SafeJSContext::from_ptr(cx), value) {
4663 Err(_) => return Err(()),
4664 Ok(Some(value)) => return Ok(ConversionResult::Success(RadioNodeListOrElement::RadioNodeList(value))),
4665 Ok(None) => (),
4666 }
4667 match RadioNodeListOrElement::<D>::TryConvertToElement(SafeJSContext::from_ptr(cx), value) {
4668 Err(_) => return Err(()),
4669 Ok(Some(value)) => return Ok(ConversionResult::Success(RadioNodeListOrElement::Element(value))),
4670 Ok(None) => (),
4671 }
4672
4673 }
4674
4675 Ok(ConversionResult::Failure("argument could not be converted to any of: RadioNodeList, Element".into()))
4676 }
4677}
4678
4679impl<D: DomTypes> RadioNodeListOrElement<D> {
4680 unsafe fn TryConvertToRadioNodeList(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::RadioNodeList>>, ()> {
4681 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4682 Ok(val) => val,
4683 Err(()) => {
4684 return Ok(None);
4685 }
4686 }
4687 ))
4688 }
4689
4690 unsafe fn TryConvertToElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Element>>, ()> {
4691 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4692 Ok(val) => val,
4693 Err(()) => {
4694 return Ok(None);
4695 }
4696 }
4697 ))
4698 }
4699}
4700
4701
4702
4703#[derive(JSTraceable, MallocSizeOf)]
4704pub enum RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict {
4705 RangeEnforcedUnsignedLongSequence(Vec<u32>),
4706 GPUExtent3DDict(GPUExtent3DDict),
4707}
4708
4709impl ToJSValConvertible for RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict {
4710 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4711 match *self {
4712 RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict::RangeEnforcedUnsignedLongSequence(ref inner) => inner.to_jsval(cx, rval),
4713 RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict::GPUExtent3DDict(ref inner) => inner.to_jsval(cx, rval),
4714 }
4715 }
4716}
4717
4718
4719
4720impl FromJSValConvertible for RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict {
4721 type Config = ();
4722 unsafe fn from_jsval(cx: *mut RawJSContext,
4723 value: HandleValue,
4724 _option: ())
4725 -> Result<ConversionResult<RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict>, ()> {
4726 if value.get().is_object() {
4727 match RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict::TryConvertToRangeEnforcedUnsignedLongSequence(SafeJSContext::from_ptr(cx), value) {
4728 Err(_) => return Err(()),
4729 Ok(Some(value)) => return Ok(ConversionResult::Success(RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict::RangeEnforcedUnsignedLongSequence(value))),
4730 Ok(None) => (),
4731 }
4732
4733 }
4734
4735 match RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict::TryConvertToGPUExtent3DDict(SafeJSContext::from_ptr(cx), value) {
4736 Err(_) => return Err(()),
4737 Ok(Some(value)) => return Ok(ConversionResult::Success(RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict::GPUExtent3DDict(value))),
4738 Ok(None) => (),
4739 }
4740
4741
4742 Ok(ConversionResult::Failure("argument could not be converted to any of: RangeEnforcedUnsignedLongSequence, GPUExtent3DDict".into()))
4743 }
4744}
4745
4746impl RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict {
4747 unsafe fn TryConvertToRangeEnforcedUnsignedLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<u32>>, ()> {
4748 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::EnforceRange) {
4749 Ok(ConversionResult::Success(value)) => value,
4750 Ok(ConversionResult::Failure(error)) => {
4751 return Ok(None);
4752 }
4753 _ => {
4754 return Err(());
4755 },
4756 }
4757 ))
4758 }
4759
4760 unsafe fn TryConvertToGPUExtent3DDict(cx: SafeJSContext, value: HandleValue) -> Result<Option<GPUExtent3DDict>, ()> {
4761 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
4762 Ok(ConversionResult::Success(value)) => value,
4763 Ok(ConversionResult::Failure(error)) => {
4764 return Ok(None);
4765 }
4766 _ => {
4767 return Err(());
4768 },
4769 }
4770 ))
4771 }
4772}
4773
4774
4775
4776#[derive(JSTraceable)]
4777pub enum RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict {
4778 RangeEnforcedUnsignedLongSequence(Vec<u32>),
4779 GPUOrigin2DDict(GPUOrigin2DDict),
4780}
4781
4782impl ToJSValConvertible for RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict {
4783 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4784 match *self {
4785 RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::RangeEnforcedUnsignedLongSequence(ref inner) => inner.to_jsval(cx, rval),
4786 RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::GPUOrigin2DDict(ref inner) => inner.to_jsval(cx, rval),
4787 }
4788 }
4789}
4790
4791
4792
4793impl FromJSValConvertible for RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict {
4794 type Config = ();
4795 unsafe fn from_jsval(cx: *mut RawJSContext,
4796 value: HandleValue,
4797 _option: ())
4798 -> Result<ConversionResult<RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict>, ()> {
4799 if value.get().is_object() {
4800 match RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::TryConvertToRangeEnforcedUnsignedLongSequence(SafeJSContext::from_ptr(cx), value) {
4801 Err(_) => return Err(()),
4802 Ok(Some(value)) => return Ok(ConversionResult::Success(RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::RangeEnforcedUnsignedLongSequence(value))),
4803 Ok(None) => (),
4804 }
4805
4806 }
4807
4808 match RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::TryConvertToGPUOrigin2DDict(SafeJSContext::from_ptr(cx), value) {
4809 Err(_) => return Err(()),
4810 Ok(Some(value)) => return Ok(ConversionResult::Success(RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::GPUOrigin2DDict(value))),
4811 Ok(None) => (),
4812 }
4813
4814
4815 Ok(ConversionResult::Failure("argument could not be converted to any of: RangeEnforcedUnsignedLongSequence, GPUOrigin2DDict".into()))
4816 }
4817}
4818
4819impl RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict {
4820 unsafe fn TryConvertToRangeEnforcedUnsignedLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<u32>>, ()> {
4821 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::EnforceRange) {
4822 Ok(ConversionResult::Success(value)) => value,
4823 Ok(ConversionResult::Failure(error)) => {
4824 return Ok(None);
4825 }
4826 _ => {
4827 return Err(());
4828 },
4829 }
4830 ))
4831 }
4832
4833 unsafe fn TryConvertToGPUOrigin2DDict(cx: SafeJSContext, value: HandleValue) -> Result<Option<GPUOrigin2DDict>, ()> {
4834 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
4835 Ok(ConversionResult::Success(value)) => value,
4836 Ok(ConversionResult::Failure(error)) => {
4837 return Ok(None);
4838 }
4839 _ => {
4840 return Err(());
4841 },
4842 }
4843 ))
4844 }
4845}
4846
4847
4848
4849#[derive(JSTraceable)]
4850pub enum RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict {
4851 RangeEnforcedUnsignedLongSequence(Vec<u32>),
4852 GPUOrigin3DDict(GPUOrigin3DDict),
4853}
4854
4855impl ToJSValConvertible for RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict {
4856 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4857 match *self {
4858 RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict::RangeEnforcedUnsignedLongSequence(ref inner) => inner.to_jsval(cx, rval),
4859 RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict::GPUOrigin3DDict(ref inner) => inner.to_jsval(cx, rval),
4860 }
4861 }
4862}
4863
4864
4865
4866impl FromJSValConvertible for RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict {
4867 type Config = ();
4868 unsafe fn from_jsval(cx: *mut RawJSContext,
4869 value: HandleValue,
4870 _option: ())
4871 -> Result<ConversionResult<RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict>, ()> {
4872 if value.get().is_object() {
4873 match RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict::TryConvertToRangeEnforcedUnsignedLongSequence(SafeJSContext::from_ptr(cx), value) {
4874 Err(_) => return Err(()),
4875 Ok(Some(value)) => return Ok(ConversionResult::Success(RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict::RangeEnforcedUnsignedLongSequence(value))),
4876 Ok(None) => (),
4877 }
4878
4879 }
4880
4881 match RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict::TryConvertToGPUOrigin3DDict(SafeJSContext::from_ptr(cx), value) {
4882 Err(_) => return Err(()),
4883 Ok(Some(value)) => return Ok(ConversionResult::Success(RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict::GPUOrigin3DDict(value))),
4884 Ok(None) => (),
4885 }
4886
4887
4888 Ok(ConversionResult::Failure("argument could not be converted to any of: RangeEnforcedUnsignedLongSequence, GPUOrigin3DDict".into()))
4889 }
4890}
4891
4892impl RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict {
4893 unsafe fn TryConvertToRangeEnforcedUnsignedLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<u32>>, ()> {
4894 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::EnforceRange) {
4895 Ok(ConversionResult::Success(value)) => value,
4896 Ok(ConversionResult::Failure(error)) => {
4897 return Ok(None);
4898 }
4899 _ => {
4900 return Err(());
4901 },
4902 }
4903 ))
4904 }
4905
4906 unsafe fn TryConvertToGPUOrigin3DDict(cx: SafeJSContext, value: HandleValue) -> Result<Option<GPUOrigin3DDict>, ()> {
4907 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
4908 Ok(ConversionResult::Success(value)) => value,
4909 Ok(ConversionResult::Failure(error)) => {
4910 return Ok(None);
4911 }
4912 _ => {
4913 return Err(());
4914 },
4915 }
4916 ))
4917 }
4918}
4919
4920
4921
4922#[derive(JSTraceable)]
4923pub enum ReadableStreamDefaultControllerOrReadableByteStreamController<D: DomTypes> {
4924 ReadableStreamDefaultController(DomRoot<D::ReadableStreamDefaultController>),
4925 ReadableByteStreamController(DomRoot<D::ReadableByteStreamController>),
4926}
4927
4928impl<D: DomTypes> ToJSValConvertible for ReadableStreamDefaultControllerOrReadableByteStreamController<D> {
4929 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4930 match *self {
4931 ReadableStreamDefaultControllerOrReadableByteStreamController::ReadableStreamDefaultController(ref inner) => inner.to_jsval(cx, rval),
4932 ReadableStreamDefaultControllerOrReadableByteStreamController::ReadableByteStreamController(ref inner) => inner.to_jsval(cx, rval),
4933 }
4934 }
4935}
4936
4937
4938
4939impl<D: DomTypes> FromJSValConvertible for ReadableStreamDefaultControllerOrReadableByteStreamController<D> {
4940 type Config = ();
4941 unsafe fn from_jsval(cx: *mut RawJSContext,
4942 value: HandleValue,
4943 _option: ())
4944 -> Result<ConversionResult<ReadableStreamDefaultControllerOrReadableByteStreamController<D>>, ()> {
4945 if value.get().is_object() {
4946 match ReadableStreamDefaultControllerOrReadableByteStreamController::<D>::TryConvertToReadableStreamDefaultController(SafeJSContext::from_ptr(cx), value) {
4947 Err(_) => return Err(()),
4948 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamDefaultControllerOrReadableByteStreamController::ReadableStreamDefaultController(value))),
4949 Ok(None) => (),
4950 }
4951 match ReadableStreamDefaultControllerOrReadableByteStreamController::<D>::TryConvertToReadableByteStreamController(SafeJSContext::from_ptr(cx), value) {
4952 Err(_) => return Err(()),
4953 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamDefaultControllerOrReadableByteStreamController::ReadableByteStreamController(value))),
4954 Ok(None) => (),
4955 }
4956
4957 }
4958
4959 Ok(ConversionResult::Failure("argument could not be converted to any of: ReadableStreamDefaultController, ReadableByteStreamController".into()))
4960 }
4961}
4962
4963impl<D: DomTypes> ReadableStreamDefaultControllerOrReadableByteStreamController<D> {
4964 unsafe fn TryConvertToReadableStreamDefaultController(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ReadableStreamDefaultController>>, ()> {
4965 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4966 Ok(val) => val,
4967 Err(()) => {
4968 return Ok(None);
4969 }
4970 }
4971 ))
4972 }
4973
4974 unsafe fn TryConvertToReadableByteStreamController(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ReadableByteStreamController>>, ()> {
4975 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
4976 Ok(val) => val,
4977 Err(()) => {
4978 return Ok(None);
4979 }
4980 }
4981 ))
4982 }
4983}
4984
4985
4986
4987#[derive(JSTraceable)]
4988pub enum ReadableStreamDefaultReaderOrReadableStreamBYOBReader<D: DomTypes> {
4989 ReadableStreamDefaultReader(DomRoot<D::ReadableStreamDefaultReader>),
4990 ReadableStreamBYOBReader(DomRoot<D::ReadableStreamBYOBReader>),
4991}
4992
4993impl<D: DomTypes> ToJSValConvertible for ReadableStreamDefaultReaderOrReadableStreamBYOBReader<D> {
4994 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
4995 match *self {
4996 ReadableStreamDefaultReaderOrReadableStreamBYOBReader::ReadableStreamDefaultReader(ref inner) => inner.to_jsval(cx, rval),
4997 ReadableStreamDefaultReaderOrReadableStreamBYOBReader::ReadableStreamBYOBReader(ref inner) => inner.to_jsval(cx, rval),
4998 }
4999 }
5000}
5001
5002
5003
5004impl<D: DomTypes> FromJSValConvertible for ReadableStreamDefaultReaderOrReadableStreamBYOBReader<D> {
5005 type Config = ();
5006 unsafe fn from_jsval(cx: *mut RawJSContext,
5007 value: HandleValue,
5008 _option: ())
5009 -> Result<ConversionResult<ReadableStreamDefaultReaderOrReadableStreamBYOBReader<D>>, ()> {
5010 if value.get().is_object() {
5011 match ReadableStreamDefaultReaderOrReadableStreamBYOBReader::<D>::TryConvertToReadableStreamDefaultReader(SafeJSContext::from_ptr(cx), value) {
5012 Err(_) => return Err(()),
5013 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamDefaultReaderOrReadableStreamBYOBReader::ReadableStreamDefaultReader(value))),
5014 Ok(None) => (),
5015 }
5016 match ReadableStreamDefaultReaderOrReadableStreamBYOBReader::<D>::TryConvertToReadableStreamBYOBReader(SafeJSContext::from_ptr(cx), value) {
5017 Err(_) => return Err(()),
5018 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamDefaultReaderOrReadableStreamBYOBReader::ReadableStreamBYOBReader(value))),
5019 Ok(None) => (),
5020 }
5021
5022 }
5023
5024 Ok(ConversionResult::Failure("argument could not be converted to any of: ReadableStreamDefaultReader, ReadableStreamBYOBReader".into()))
5025 }
5026}
5027
5028impl<D: DomTypes> ReadableStreamDefaultReaderOrReadableStreamBYOBReader<D> {
5029 unsafe fn TryConvertToReadableStreamDefaultReader(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ReadableStreamDefaultReader>>, ()> {
5030 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5031 Ok(val) => val,
5032 Err(()) => {
5033 return Ok(None);
5034 }
5035 }
5036 ))
5037 }
5038
5039 unsafe fn TryConvertToReadableStreamBYOBReader(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ReadableStreamBYOBReader>>, ()> {
5040 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5041 Ok(val) => val,
5042 Err(()) => {
5043 return Ok(None);
5044 }
5045 }
5046 ))
5047 }
5048}
5049
5050
5051
5052#[derive(JSTraceable)]
5053pub enum ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D: DomTypes> {
5054 ReadableStream(DomRoot<D::ReadableStream>),
5055 Blob(DomRoot<D::Blob>),
5056 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
5057 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
5058 FormData(DomRoot<D::FormData>),
5059 String(DOMString),
5060 URLSearchParams(DomRoot<D::URLSearchParams>),
5061}
5062
5063impl<D: DomTypes> ToJSValConvertible for ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
5064 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5065 match *self {
5066 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ReadableStream(ref inner) => inner.to_jsval(cx, rval),
5067 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Blob(ref inner) => inner.to_jsval(cx, rval),
5068 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
5069 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
5070 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::FormData(ref inner) => inner.to_jsval(cx, rval),
5071 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::String(ref inner) => inner.to_jsval(cx, rval),
5072 ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::URLSearchParams(ref inner) => inner.to_jsval(cx, rval),
5073 }
5074 }
5075}
5076
5077
5078
5079impl<D: DomTypes> FromJSValConvertible for ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
5080 type Config = ();
5081 unsafe fn from_jsval(cx: *mut RawJSContext,
5082 value: HandleValue,
5083 _option: ())
5084 -> Result<ConversionResult<ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D>>, ()> {
5085 if value.get().is_object() {
5086 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToReadableStream(SafeJSContext::from_ptr(cx), value) {
5087 Err(_) => return Err(()),
5088 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ReadableStream(value))),
5089 Ok(None) => (),
5090 }
5091 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
5092 Err(_) => return Err(()),
5093 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::Blob(value))),
5094 Ok(None) => (),
5095 }
5096 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
5097 Err(_) => return Err(()),
5098 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBufferView(value))),
5099 Ok(None) => (),
5100 }
5101 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
5102 Err(_) => return Err(()),
5103 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::ArrayBuffer(value))),
5104 Ok(None) => (),
5105 }
5106 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToFormData(SafeJSContext::from_ptr(cx), value) {
5107 Err(_) => return Err(()),
5108 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::FormData(value))),
5109 Ok(None) => (),
5110 }
5111 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToURLSearchParams(SafeJSContext::from_ptr(cx), value) {
5112 Err(_) => return Err(()),
5113 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::URLSearchParams(value))),
5114 Ok(None) => (),
5115 }
5116
5117 }
5118
5119 match ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5120 Err(_) => return Err(()),
5121 Ok(Some(value)) => return Ok(ConversionResult::Success(ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams::String(value))),
5122 Ok(None) => (),
5123 }
5124
5125
5126 Ok(ConversionResult::Failure("argument could not be converted to any of: ReadableStream, Blob, ArrayBufferView, ArrayBuffer, FormData, URLSearchParams".into()))
5127 }
5128}
5129
5130impl<D: DomTypes> ReadableStreamOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrStringOrURLSearchParams<D> {
5131 unsafe fn TryConvertToReadableStream(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ReadableStream>>, ()> {
5132 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5133 Ok(val) => val,
5134 Err(()) => {
5135 return Ok(None);
5136 }
5137 }
5138 ))
5139 }
5140
5141 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
5142 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5143 Ok(val) => val,
5144 Err(()) => {
5145 return Ok(None);
5146 }
5147 }
5148 ))
5149 }
5150
5151 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
5152 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
5153 Ok(val) => val,
5154 Err(()) => {
5155 return Ok(None);
5156 }
5157 }
5158 ))
5159 }
5160
5161 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
5162 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
5163 Ok(val) => val,
5164 Err(()) => {
5165 return Ok(None);
5166 }
5167 }
5168 ))
5169 }
5170
5171 unsafe fn TryConvertToFormData(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::FormData>>, ()> {
5172 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5173 Ok(val) => val,
5174 Err(()) => {
5175 return Ok(None);
5176 }
5177 }
5178 ))
5179 }
5180
5181 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5182 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5183 Ok(ConversionResult::Success(value)) => value,
5184 Ok(ConversionResult::Failure(error)) => {
5185 return Ok(None);
5186 }
5187 _ => {
5188 return Err(());
5189 },
5190 }
5191 ))
5192 }
5193
5194 unsafe fn TryConvertToURLSearchParams(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::URLSearchParams>>, ()> {
5195 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5196 Ok(val) => val,
5197 Err(()) => {
5198 return Ok(None);
5199 }
5200 }
5201 ))
5202 }
5203}
5204
5205
5206
5207#[derive(JSTraceable)]
5208pub enum RequestOrUSVString<D: DomTypes> {
5209 Request(DomRoot<D::Request>),
5210 USVString(USVString),
5211}
5212
5213impl<D: DomTypes> ToJSValConvertible for RequestOrUSVString<D> {
5214 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5215 match *self {
5216 RequestOrUSVString::Request(ref inner) => inner.to_jsval(cx, rval),
5217 RequestOrUSVString::USVString(ref inner) => inner.to_jsval(cx, rval),
5218 }
5219 }
5220}
5221
5222
5223
5224impl<D: DomTypes> FromJSValConvertible for RequestOrUSVString<D> {
5225 type Config = ();
5226 unsafe fn from_jsval(cx: *mut RawJSContext,
5227 value: HandleValue,
5228 _option: ())
5229 -> Result<ConversionResult<RequestOrUSVString<D>>, ()> {
5230 if value.get().is_object() {
5231 match RequestOrUSVString::<D>::TryConvertToRequest(SafeJSContext::from_ptr(cx), value) {
5232 Err(_) => return Err(()),
5233 Ok(Some(value)) => return Ok(ConversionResult::Success(RequestOrUSVString::Request(value))),
5234 Ok(None) => (),
5235 }
5236
5237 }
5238
5239 match RequestOrUSVString::<D>::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
5240 Err(_) => return Err(()),
5241 Ok(Some(value)) => return Ok(ConversionResult::Success(RequestOrUSVString::USVString(value))),
5242 Ok(None) => (),
5243 }
5244
5245
5246 Ok(ConversionResult::Failure("argument could not be converted to any of: Request".into()))
5247 }
5248}
5249
5250impl<D: DomTypes> RequestOrUSVString<D> {
5251 unsafe fn TryConvertToRequest(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Request>>, ()> {
5252 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5253 Ok(val) => val,
5254 Err(()) => {
5255 return Ok(None);
5256 }
5257 }
5258 ))
5259 }
5260
5261 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
5262 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
5263 Ok(ConversionResult::Success(value)) => value,
5264 Ok(ConversionResult::Failure(error)) => {
5265 return Ok(None);
5266 }
5267 _ => {
5268 return Err(());
5269 },
5270 }
5271 ))
5272 }
5273}
5274
5275
5276
5277#[derive(JSTraceable)]
5278pub enum StringOrArrayBufferViewOrArrayBuffer {
5279 String(DOMString),
5280 ArrayBufferView(RootedTraceableBox<typedarray::HeapArrayBufferView>),
5281 ArrayBuffer(RootedTraceableBox<typedarray::HeapArrayBuffer>),
5282}
5283
5284impl ToJSValConvertible for StringOrArrayBufferViewOrArrayBuffer {
5285 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5286 match *self {
5287 StringOrArrayBufferViewOrArrayBuffer::String(ref inner) => inner.to_jsval(cx, rval),
5288 StringOrArrayBufferViewOrArrayBuffer::ArrayBufferView(ref inner) => inner.to_jsval(cx, rval),
5289 StringOrArrayBufferViewOrArrayBuffer::ArrayBuffer(ref inner) => inner.to_jsval(cx, rval),
5290 }
5291 }
5292}
5293
5294
5295
5296impl FromJSValConvertible for StringOrArrayBufferViewOrArrayBuffer {
5297 type Config = ();
5298 unsafe fn from_jsval(cx: *mut RawJSContext,
5299 value: HandleValue,
5300 _option: ())
5301 -> Result<ConversionResult<StringOrArrayBufferViewOrArrayBuffer>, ()> {
5302 if value.get().is_object() {
5303 match StringOrArrayBufferViewOrArrayBuffer::TryConvertToArrayBufferView(SafeJSContext::from_ptr(cx), value) {
5304 Err(_) => return Err(()),
5305 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrArrayBufferViewOrArrayBuffer::ArrayBufferView(value))),
5306 Ok(None) => (),
5307 }
5308 match StringOrArrayBufferViewOrArrayBuffer::TryConvertToArrayBuffer(SafeJSContext::from_ptr(cx), value) {
5309 Err(_) => return Err(()),
5310 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrArrayBufferViewOrArrayBuffer::ArrayBuffer(value))),
5311 Ok(None) => (),
5312 }
5313
5314 }
5315
5316 match StringOrArrayBufferViewOrArrayBuffer::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5317 Err(_) => return Err(()),
5318 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrArrayBufferViewOrArrayBuffer::String(value))),
5319 Ok(None) => (),
5320 }
5321
5322
5323 Ok(ConversionResult::Failure("argument could not be converted to any of: ArrayBufferView, ArrayBuffer".into()))
5324 }
5325}
5326
5327impl StringOrArrayBufferViewOrArrayBuffer {
5328 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5329 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5330 Ok(ConversionResult::Success(value)) => value,
5331 Ok(ConversionResult::Failure(error)) => {
5332 return Ok(None);
5333 }
5334 _ => {
5335 return Err(());
5336 },
5337 }
5338 ))
5339 }
5340
5341 unsafe fn TryConvertToArrayBufferView(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBufferView>>, ()> {
5342 Ok(Some(match typedarray::HeapArrayBufferView::from(value.get().to_object()).map(RootedTraceableBox::new) {
5343 Ok(val) => val,
5344 Err(()) => {
5345 return Ok(None);
5346 }
5347 }
5348 ))
5349 }
5350
5351 unsafe fn TryConvertToArrayBuffer(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapArrayBuffer>>, ()> {
5352 Ok(Some(match typedarray::HeapArrayBuffer::from(value.get().to_object()).map(RootedTraceableBox::new) {
5353 Ok(val) => val,
5354 Err(()) => {
5355 return Ok(None);
5356 }
5357 }
5358 ))
5359 }
5360}
5361
5362
5363
5364#[derive(JSTraceable)]
5365pub enum StringOrBoolean {
5366 String(DOMString),
5367 Boolean(bool),
5368}
5369
5370impl ToJSValConvertible for StringOrBoolean {
5371 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5372 match *self {
5373 StringOrBoolean::String(ref inner) => inner.to_jsval(cx, rval),
5374 StringOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
5375 }
5376 }
5377}
5378
5379
5380
5381impl FromJSValConvertible for StringOrBoolean {
5382 type Config = ();
5383 unsafe fn from_jsval(cx: *mut RawJSContext,
5384 value: HandleValue,
5385 _option: ())
5386 -> Result<ConversionResult<StringOrBoolean>, ()> {
5387 if value.get().is_boolean() {
5388 match StringOrBoolean::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
5389 Err(_) => return Err(()),
5390 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrBoolean::Boolean(value))),
5391 Ok(None) => (),
5392 }
5393
5394 }
5395
5396 match StringOrBoolean::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5397 Err(_) => return Err(()),
5398 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrBoolean::String(value))),
5399 Ok(None) => (),
5400 }
5401
5402
5403 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
5404 }
5405}
5406
5407impl StringOrBoolean {
5408 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5409 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5410 Ok(ConversionResult::Success(value)) => value,
5411 Ok(ConversionResult::Failure(error)) => {
5412 return Ok(None);
5413 }
5414 _ => {
5415 return Err(());
5416 },
5417 }
5418 ))
5419 }
5420
5421 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
5422 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
5423 Ok(ConversionResult::Success(value)) => value,
5424 Ok(ConversionResult::Failure(error)) => {
5425 return Ok(None);
5426 }
5427 _ => {
5428 return Err(());
5429 },
5430 }
5431 ))
5432 }
5433}
5434
5435
5436
5437#[derive(JSTraceable)]
5438pub enum StringOrCanvasGradientOrCanvasPattern<D: DomTypes> {
5439 String(DOMString),
5440 CanvasGradient(DomRoot<D::CanvasGradient>),
5441 CanvasPattern(DomRoot<D::CanvasPattern>),
5442}
5443
5444impl<D: DomTypes> ToJSValConvertible for StringOrCanvasGradientOrCanvasPattern<D> {
5445 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5446 match *self {
5447 StringOrCanvasGradientOrCanvasPattern::String(ref inner) => inner.to_jsval(cx, rval),
5448 StringOrCanvasGradientOrCanvasPattern::CanvasGradient(ref inner) => inner.to_jsval(cx, rval),
5449 StringOrCanvasGradientOrCanvasPattern::CanvasPattern(ref inner) => inner.to_jsval(cx, rval),
5450 }
5451 }
5452}
5453
5454
5455
5456impl<D: DomTypes> FromJSValConvertible for StringOrCanvasGradientOrCanvasPattern<D> {
5457 type Config = ();
5458 unsafe fn from_jsval(cx: *mut RawJSContext,
5459 value: HandleValue,
5460 _option: ())
5461 -> Result<ConversionResult<StringOrCanvasGradientOrCanvasPattern<D>>, ()> {
5462 if value.get().is_object() {
5463 match StringOrCanvasGradientOrCanvasPattern::<D>::TryConvertToCanvasGradient(SafeJSContext::from_ptr(cx), value) {
5464 Err(_) => return Err(()),
5465 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrCanvasGradientOrCanvasPattern::CanvasGradient(value))),
5466 Ok(None) => (),
5467 }
5468 match StringOrCanvasGradientOrCanvasPattern::<D>::TryConvertToCanvasPattern(SafeJSContext::from_ptr(cx), value) {
5469 Err(_) => return Err(()),
5470 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrCanvasGradientOrCanvasPattern::CanvasPattern(value))),
5471 Ok(None) => (),
5472 }
5473
5474 }
5475
5476 match StringOrCanvasGradientOrCanvasPattern::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5477 Err(_) => return Err(()),
5478 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrCanvasGradientOrCanvasPattern::String(value))),
5479 Ok(None) => (),
5480 }
5481
5482
5483 Ok(ConversionResult::Failure("argument could not be converted to any of: CanvasGradient, CanvasPattern".into()))
5484 }
5485}
5486
5487impl<D: DomTypes> StringOrCanvasGradientOrCanvasPattern<D> {
5488 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5489 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5490 Ok(ConversionResult::Success(value)) => value,
5491 Ok(ConversionResult::Failure(error)) => {
5492 return Ok(None);
5493 }
5494 _ => {
5495 return Err(());
5496 },
5497 }
5498 ))
5499 }
5500
5501 unsafe fn TryConvertToCanvasGradient(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::CanvasGradient>>, ()> {
5502 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5503 Ok(val) => val,
5504 Err(()) => {
5505 return Ok(None);
5506 }
5507 }
5508 ))
5509 }
5510
5511 unsafe fn TryConvertToCanvasPattern(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::CanvasPattern>>, ()> {
5512 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5513 Ok(val) => val,
5514 Err(()) => {
5515 return Ok(None);
5516 }
5517 }
5518 ))
5519 }
5520}
5521
5522
5523
5524#[derive(JSTraceable)]
5525pub enum StringOrElementCreationOptions {
5526 String(DOMString),
5527 ElementCreationOptions(ElementCreationOptions),
5528}
5529
5530impl ToJSValConvertible for StringOrElementCreationOptions {
5531 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5532 match *self {
5533 StringOrElementCreationOptions::String(ref inner) => inner.to_jsval(cx, rval),
5534 StringOrElementCreationOptions::ElementCreationOptions(ref inner) => inner.to_jsval(cx, rval),
5535 }
5536 }
5537}
5538
5539
5540
5541impl FromJSValConvertible for StringOrElementCreationOptions {
5542 type Config = ();
5543 unsafe fn from_jsval(cx: *mut RawJSContext,
5544 value: HandleValue,
5545 _option: ())
5546 -> Result<ConversionResult<StringOrElementCreationOptions>, ()> {
5547 match StringOrElementCreationOptions::TryConvertToElementCreationOptions(SafeJSContext::from_ptr(cx), value) {
5548 Err(_) => return Err(()),
5549 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrElementCreationOptions::ElementCreationOptions(value))),
5550 Ok(None) => (),
5551 }
5552
5553
5554 match StringOrElementCreationOptions::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5555 Err(_) => return Err(()),
5556 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrElementCreationOptions::String(value))),
5557 Ok(None) => (),
5558 }
5559
5560
5561 Ok(ConversionResult::Failure("argument could not be converted to any of: ElementCreationOptions".into()))
5562 }
5563}
5564
5565impl StringOrElementCreationOptions {
5566 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5567 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5568 Ok(ConversionResult::Success(value)) => value,
5569 Ok(ConversionResult::Failure(error)) => {
5570 return Ok(None);
5571 }
5572 _ => {
5573 return Err(());
5574 },
5575 }
5576 ))
5577 }
5578
5579 unsafe fn TryConvertToElementCreationOptions(cx: SafeJSContext, value: HandleValue) -> Result<Option<ElementCreationOptions>, ()> {
5580 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
5581 Ok(ConversionResult::Success(value)) => value,
5582 Ok(ConversionResult::Failure(error)) => {
5583 return Ok(None);
5584 }
5585 _ => {
5586 return Err(());
5587 },
5588 }
5589 ))
5590 }
5591}
5592
5593
5594
5595#[derive(JSTraceable)]
5596pub enum StringOrLongSequence {
5597 String(DOMString),
5598 LongSequence(Vec<i32>),
5599}
5600
5601impl ToJSValConvertible for StringOrLongSequence {
5602 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5603 match *self {
5604 StringOrLongSequence::String(ref inner) => inner.to_jsval(cx, rval),
5605 StringOrLongSequence::LongSequence(ref inner) => inner.to_jsval(cx, rval),
5606 }
5607 }
5608}
5609
5610
5611
5612impl FromJSValConvertible for StringOrLongSequence {
5613 type Config = ();
5614 unsafe fn from_jsval(cx: *mut RawJSContext,
5615 value: HandleValue,
5616 _option: ())
5617 -> Result<ConversionResult<StringOrLongSequence>, ()> {
5618 if value.get().is_object() {
5619 match StringOrLongSequence::TryConvertToLongSequence(SafeJSContext::from_ptr(cx), value) {
5620 Err(_) => return Err(()),
5621 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrLongSequence::LongSequence(value))),
5622 Ok(None) => (),
5623 }
5624
5625 }
5626
5627 match StringOrLongSequence::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5628 Err(_) => return Err(()),
5629 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrLongSequence::String(value))),
5630 Ok(None) => (),
5631 }
5632
5633
5634 Ok(ConversionResult::Failure("argument could not be converted to any of: LongSequence".into()))
5635 }
5636}
5637
5638impl StringOrLongSequence {
5639 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5640 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5641 Ok(ConversionResult::Success(value)) => value,
5642 Ok(ConversionResult::Failure(error)) => {
5643 return Ok(None);
5644 }
5645 _ => {
5646 return Err(());
5647 },
5648 }
5649 ))
5650 }
5651
5652 unsafe fn TryConvertToLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<i32>>, ()> {
5653 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
5654 Ok(ConversionResult::Success(value)) => value,
5655 Ok(ConversionResult::Failure(error)) => {
5656 return Ok(None);
5657 }
5658 _ => {
5659 return Err(());
5660 },
5661 }
5662 ))
5663 }
5664}
5665
5666
5667
5668#[derive(JSTraceable)]
5669pub enum StringOrObject {
5670 String(DOMString),
5671 Object(RootedTraceableBox<Heap<*mut JSObject>>),
5672}
5673
5674impl ToJSValConvertible for StringOrObject {
5675 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5676 match *self {
5677 StringOrObject::String(ref inner) => inner.to_jsval(cx, rval),
5678 StringOrObject::Object(ref inner) => inner.to_jsval(cx, rval),
5679 }
5680 }
5681}
5682
5683
5684
5685impl FromJSValConvertible for StringOrObject {
5686 type Config = ();
5687 unsafe fn from_jsval(cx: *mut RawJSContext,
5688 value: HandleValue,
5689 _option: ())
5690 -> Result<ConversionResult<StringOrObject>, ()> {
5691 if value.get().is_object() {
5692 match StringOrObject::TryConvertToObject(SafeJSContext::from_ptr(cx), value) {
5693 Err(_) => return Err(()),
5694 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrObject::Object(value))),
5695 Ok(None) => (),
5696 }
5697
5698 }
5699
5700 match StringOrObject::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5701 Err(_) => return Err(()),
5702 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrObject::String(value))),
5703 Ok(None) => (),
5704 }
5705
5706
5707 Ok(ConversionResult::Failure("argument could not be converted to any of: Object".into()))
5708 }
5709}
5710
5711impl StringOrObject {
5712 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5713 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5714 Ok(ConversionResult::Success(value)) => value,
5715 Ok(ConversionResult::Failure(error)) => {
5716 return Ok(None);
5717 }
5718 _ => {
5719 return Err(());
5720 },
5721 }
5722 ))
5723 }
5724
5725 unsafe fn TryConvertToObject(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<Heap<*mut JSObject>>>, ()> {
5726 Ok(Some(RootedTraceableBox::from_box(Heap::boxed(value.get().to_object()))))
5727 }
5728}
5729
5730
5731
5732#[derive(JSTraceable)]
5733pub enum StringOrStringSequence {
5734 String(DOMString),
5735 StringSequence(Vec<DOMString>),
5736}
5737
5738impl ToJSValConvertible for StringOrStringSequence {
5739 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5740 match *self {
5741 StringOrStringSequence::String(ref inner) => inner.to_jsval(cx, rval),
5742 StringOrStringSequence::StringSequence(ref inner) => inner.to_jsval(cx, rval),
5743 }
5744 }
5745}
5746
5747
5748
5749impl FromJSValConvertible for StringOrStringSequence {
5750 type Config = ();
5751 unsafe fn from_jsval(cx: *mut RawJSContext,
5752 value: HandleValue,
5753 _option: ())
5754 -> Result<ConversionResult<StringOrStringSequence>, ()> {
5755 if value.get().is_object() {
5756 match StringOrStringSequence::TryConvertToStringSequence(SafeJSContext::from_ptr(cx), value) {
5757 Err(_) => return Err(()),
5758 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrStringSequence::StringSequence(value))),
5759 Ok(None) => (),
5760 }
5761
5762 }
5763
5764 match StringOrStringSequence::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5765 Err(_) => return Err(()),
5766 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrStringSequence::String(value))),
5767 Ok(None) => (),
5768 }
5769
5770
5771 Ok(ConversionResult::Failure("argument could not be converted to any of: StringSequence".into()))
5772 }
5773}
5774
5775impl StringOrStringSequence {
5776 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5777 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5778 Ok(ConversionResult::Success(value)) => value,
5779 Ok(ConversionResult::Failure(error)) => {
5780 return Ok(None);
5781 }
5782 _ => {
5783 return Err(());
5784 },
5785 }
5786 ))
5787 }
5788
5789 unsafe fn TryConvertToStringSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<DOMString>>, ()> {
5790 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5791 Ok(ConversionResult::Success(value)) => value,
5792 Ok(ConversionResult::Failure(error)) => {
5793 return Ok(None);
5794 }
5795 _ => {
5796 return Err(());
5797 },
5798 }
5799 ))
5800 }
5801}
5802
5803
5804
5805#[derive(JSTraceable)]
5806pub enum StringOrURLOrBlob<D: DomTypes> {
5807 String(DOMString),
5808 URL(DomRoot<D::URL>),
5809 Blob(DomRoot<D::Blob>),
5810}
5811
5812impl<D: DomTypes> ToJSValConvertible for StringOrURLOrBlob<D> {
5813 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5814 match *self {
5815 StringOrURLOrBlob::String(ref inner) => inner.to_jsval(cx, rval),
5816 StringOrURLOrBlob::URL(ref inner) => inner.to_jsval(cx, rval),
5817 StringOrURLOrBlob::Blob(ref inner) => inner.to_jsval(cx, rval),
5818 }
5819 }
5820}
5821
5822
5823
5824impl<D: DomTypes> FromJSValConvertible for StringOrURLOrBlob<D> {
5825 type Config = ();
5826 unsafe fn from_jsval(cx: *mut RawJSContext,
5827 value: HandleValue,
5828 _option: ())
5829 -> Result<ConversionResult<StringOrURLOrBlob<D>>, ()> {
5830 if value.get().is_object() {
5831 match StringOrURLOrBlob::<D>::TryConvertToURL(SafeJSContext::from_ptr(cx), value) {
5832 Err(_) => return Err(()),
5833 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrURLOrBlob::URL(value))),
5834 Ok(None) => (),
5835 }
5836 match StringOrURLOrBlob::<D>::TryConvertToBlob(SafeJSContext::from_ptr(cx), value) {
5837 Err(_) => return Err(()),
5838 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrURLOrBlob::Blob(value))),
5839 Ok(None) => (),
5840 }
5841
5842 }
5843
5844 match StringOrURLOrBlob::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5845 Err(_) => return Err(()),
5846 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrURLOrBlob::String(value))),
5847 Ok(None) => (),
5848 }
5849
5850
5851 Ok(ConversionResult::Failure("argument could not be converted to any of: URL, Blob".into()))
5852 }
5853}
5854
5855impl<D: DomTypes> StringOrURLOrBlob<D> {
5856 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5857 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5858 Ok(ConversionResult::Success(value)) => value,
5859 Ok(ConversionResult::Failure(error)) => {
5860 return Ok(None);
5861 }
5862 _ => {
5863 return Err(());
5864 },
5865 }
5866 ))
5867 }
5868
5869 unsafe fn TryConvertToURL(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::URL>>, ()> {
5870 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5871 Ok(val) => val,
5872 Err(()) => {
5873 return Ok(None);
5874 }
5875 }
5876 ))
5877 }
5878
5879 unsafe fn TryConvertToBlob(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Blob>>, ()> {
5880 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
5881 Ok(val) => val,
5882 Err(()) => {
5883 return Ok(None);
5884 }
5885 }
5886 ))
5887 }
5888}
5889
5890
5891
5892#[derive(JSTraceable)]
5893pub enum StringOrUnrestrictedDoubleSequence {
5894 String(DOMString),
5895 UnrestrictedDoubleSequence(Vec<f64>),
5896}
5897
5898impl ToJSValConvertible for StringOrUnrestrictedDoubleSequence {
5899 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5900 match *self {
5901 StringOrUnrestrictedDoubleSequence::String(ref inner) => inner.to_jsval(cx, rval),
5902 StringOrUnrestrictedDoubleSequence::UnrestrictedDoubleSequence(ref inner) => inner.to_jsval(cx, rval),
5903 }
5904 }
5905}
5906
5907
5908
5909impl FromJSValConvertible for StringOrUnrestrictedDoubleSequence {
5910 type Config = ();
5911 unsafe fn from_jsval(cx: *mut RawJSContext,
5912 value: HandleValue,
5913 _option: ())
5914 -> Result<ConversionResult<StringOrUnrestrictedDoubleSequence>, ()> {
5915 if value.get().is_object() {
5916 match StringOrUnrestrictedDoubleSequence::TryConvertToUnrestrictedDoubleSequence(SafeJSContext::from_ptr(cx), value) {
5917 Err(_) => return Err(()),
5918 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrUnrestrictedDoubleSequence::UnrestrictedDoubleSequence(value))),
5919 Ok(None) => (),
5920 }
5921
5922 }
5923
5924 match StringOrUnrestrictedDoubleSequence::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5925 Err(_) => return Err(()),
5926 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrUnrestrictedDoubleSequence::String(value))),
5927 Ok(None) => (),
5928 }
5929
5930
5931 Ok(ConversionResult::Failure("argument could not be converted to any of: UnrestrictedDoubleSequence".into()))
5932 }
5933}
5934
5935impl StringOrUnrestrictedDoubleSequence {
5936 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
5937 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
5938 Ok(ConversionResult::Success(value)) => value,
5939 Ok(ConversionResult::Failure(error)) => {
5940 return Ok(None);
5941 }
5942 _ => {
5943 return Err(());
5944 },
5945 }
5946 ))
5947 }
5948
5949 unsafe fn TryConvertToUnrestrictedDoubleSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<f64>>, ()> {
5950 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
5951 Ok(ConversionResult::Success(value)) => value,
5952 Ok(ConversionResult::Failure(error)) => {
5953 return Ok(None);
5954 }
5955 _ => {
5956 return Err(());
5957 },
5958 }
5959 ))
5960 }
5961}
5962
5963
5964
5965#[derive(JSTraceable, Clone)]
5966pub enum StringOrUnsignedLong {
5967 String(DOMString),
5968 UnsignedLong(u32),
5969}
5970
5971impl ToJSValConvertible for StringOrUnsignedLong {
5972 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
5973 match *self {
5974 StringOrUnsignedLong::String(ref inner) => inner.to_jsval(cx, rval),
5975 StringOrUnsignedLong::UnsignedLong(ref inner) => inner.to_jsval(cx, rval),
5976 }
5977 }
5978}
5979
5980
5981
5982impl FromJSValConvertible for StringOrUnsignedLong {
5983 type Config = ();
5984 unsafe fn from_jsval(cx: *mut RawJSContext,
5985 value: HandleValue,
5986 _option: ())
5987 -> Result<ConversionResult<StringOrUnsignedLong>, ()> {
5988 if value.get().is_number() {
5989 match StringOrUnsignedLong::TryConvertToUnsignedLong(SafeJSContext::from_ptr(cx), value) {
5990 Err(_) => return Err(()),
5991 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrUnsignedLong::UnsignedLong(value))),
5992 Ok(None) => (),
5993 }
5994
5995 }
5996
5997 match StringOrUnsignedLong::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
5998 Err(_) => return Err(()),
5999 Ok(Some(value)) => return Ok(ConversionResult::Success(StringOrUnsignedLong::String(value))),
6000 Ok(None) => (),
6001 }
6002
6003
6004 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
6005 }
6006}
6007
6008impl StringOrUnsignedLong {
6009 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
6010 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
6011 Ok(ConversionResult::Success(value)) => value,
6012 Ok(ConversionResult::Failure(error)) => {
6013 return Ok(None);
6014 }
6015 _ => {
6016 return Err(());
6017 },
6018 }
6019 ))
6020 }
6021
6022 unsafe fn TryConvertToUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
6023 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
6024 Ok(ConversionResult::Success(value)) => value,
6025 Ok(ConversionResult::Failure(error)) => {
6026 return Ok(None);
6027 }
6028 _ => {
6029 return Err(());
6030 },
6031 }
6032 ))
6033 }
6034}
6035
6036
6037
6038#[derive(JSTraceable)]
6039pub enum StringSequenceOrUnsignedLong {
6040 StringSequence(Vec<DOMString>),
6041 UnsignedLong(u32),
6042}
6043
6044impl ToJSValConvertible for StringSequenceOrUnsignedLong {
6045 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6046 match *self {
6047 StringSequenceOrUnsignedLong::StringSequence(ref inner) => inner.to_jsval(cx, rval),
6048 StringSequenceOrUnsignedLong::UnsignedLong(ref inner) => inner.to_jsval(cx, rval),
6049 }
6050 }
6051}
6052
6053
6054
6055impl FromJSValConvertible for StringSequenceOrUnsignedLong {
6056 type Config = ();
6057 unsafe fn from_jsval(cx: *mut RawJSContext,
6058 value: HandleValue,
6059 _option: ())
6060 -> Result<ConversionResult<StringSequenceOrUnsignedLong>, ()> {
6061 if value.get().is_object() {
6062 match StringSequenceOrUnsignedLong::TryConvertToStringSequence(SafeJSContext::from_ptr(cx), value) {
6063 Err(_) => return Err(()),
6064 Ok(Some(value)) => return Ok(ConversionResult::Success(StringSequenceOrUnsignedLong::StringSequence(value))),
6065 Ok(None) => (),
6066 }
6067
6068 }
6069
6070 match StringSequenceOrUnsignedLong::TryConvertToUnsignedLong(SafeJSContext::from_ptr(cx), value) {
6071 Err(_) => return Err(()),
6072 Ok(Some(value)) => return Ok(ConversionResult::Success(StringSequenceOrUnsignedLong::UnsignedLong(value))),
6073 Ok(None) => (),
6074 }
6075
6076
6077 Ok(ConversionResult::Failure("argument could not be converted to any of: StringSequence".into()))
6078 }
6079}
6080
6081impl StringSequenceOrUnsignedLong {
6082 unsafe fn TryConvertToStringSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<DOMString>>, ()> {
6083 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
6084 Ok(ConversionResult::Success(value)) => value,
6085 Ok(ConversionResult::Failure(error)) => {
6086 return Ok(None);
6087 }
6088 _ => {
6089 return Err(());
6090 },
6091 }
6092 ))
6093 }
6094
6095 unsafe fn TryConvertToUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
6096 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
6097 Ok(ConversionResult::Success(value)) => value,
6098 Ok(ConversionResult::Failure(error)) => {
6099 return Ok(None);
6100 }
6101 _ => {
6102 return Err(());
6103 },
6104 }
6105 ))
6106 }
6107}
6108
6109
6110
6111#[derive(JSTraceable)]
6112pub enum TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord<D: DomTypes> {
6113 TestBinding(DomRoot<D::TestBinding>),
6114 ByteStringSequenceSequence(Vec<Vec<ByteString>>),
6115 StringByteStringRecord(Record<DOMString, ByteString>),
6116}
6117
6118impl<D: DomTypes> ToJSValConvertible for TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord<D> {
6119 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6120 match *self {
6121 TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::TestBinding(ref inner) => inner.to_jsval(cx, rval),
6122 TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::ByteStringSequenceSequence(ref inner) => inner.to_jsval(cx, rval),
6123 TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::StringByteStringRecord(ref inner) => inner.to_jsval(cx, rval),
6124 }
6125 }
6126}
6127
6128
6129
6130impl<D: DomTypes> FromJSValConvertible for TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord<D> {
6131 type Config = ();
6132 unsafe fn from_jsval(cx: *mut RawJSContext,
6133 value: HandleValue,
6134 _option: ())
6135 -> Result<ConversionResult<TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord<D>>, ()> {
6136 if value.get().is_object() {
6137 match TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::<D>::TryConvertToByteStringSequenceSequence(SafeJSContext::from_ptr(cx), value) {
6138 Err(_) => return Err(()),
6139 Ok(Some(value)) => return Ok(ConversionResult::Success(TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::ByteStringSequenceSequence(value))),
6140 Ok(None) => (),
6141 }
6142
6143 match TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::<D>::TryConvertToTestBinding(SafeJSContext::from_ptr(cx), value) {
6144 Err(_) => return Err(()),
6145 Ok(Some(value)) => return Ok(ConversionResult::Success(TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::TestBinding(value))),
6146 Ok(None) => (),
6147 }
6148
6149 match TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::<D>::TryConvertToStringByteStringRecord(SafeJSContext::from_ptr(cx), value) {
6150 Err(_) => return Err(()),
6151 Ok(Some(value)) => return Ok(ConversionResult::Success(TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::StringByteStringRecord(value))),
6152 Ok(None) => (),
6153 }
6154
6155 }
6156
6157 Ok(ConversionResult::Failure("argument could not be converted to any of: TestBinding, ByteStringSequenceSequence, StringByteStringRecord".into()))
6158 }
6159}
6160
6161impl<D: DomTypes> TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord<D> {
6162 unsafe fn TryConvertToTestBinding(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TestBinding>>, ()> {
6163 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6164 Ok(val) => val,
6165 Err(()) => {
6166 return Ok(None);
6167 }
6168 }
6169 ))
6170 }
6171
6172 unsafe fn TryConvertToByteStringSequenceSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<Vec<ByteString>>>, ()> {
6173 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6174 Ok(ConversionResult::Success(value)) => value,
6175 Ok(ConversionResult::Failure(error)) => {
6176 return Ok(None);
6177 }
6178 _ => {
6179 return Err(());
6180 },
6181 }
6182 ))
6183 }
6184
6185 unsafe fn TryConvertToStringByteStringRecord(cx: SafeJSContext, value: HandleValue) -> Result<Option<Record<DOMString, ByteString>>, ()> {
6186 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6187 Ok(ConversionResult::Success(value)) => value,
6188 Ok(ConversionResult::Failure(error)) => {
6189 return Ok(None);
6190 }
6191 _ => {
6192 return Err(());
6193 },
6194 }
6195 ))
6196 }
6197}
6198
6199
6200
6201#[derive(JSTraceable)]
6202pub enum TestBindingOrStringByteStringRecord<D: DomTypes> {
6203 TestBinding(DomRoot<D::TestBinding>),
6204 StringByteStringRecord(Record<DOMString, ByteString>),
6205}
6206
6207impl<D: DomTypes> ToJSValConvertible for TestBindingOrStringByteStringRecord<D> {
6208 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6209 match *self {
6210 TestBindingOrStringByteStringRecord::TestBinding(ref inner) => inner.to_jsval(cx, rval),
6211 TestBindingOrStringByteStringRecord::StringByteStringRecord(ref inner) => inner.to_jsval(cx, rval),
6212 }
6213 }
6214}
6215
6216
6217
6218impl<D: DomTypes> FromJSValConvertible for TestBindingOrStringByteStringRecord<D> {
6219 type Config = ();
6220 unsafe fn from_jsval(cx: *mut RawJSContext,
6221 value: HandleValue,
6222 _option: ())
6223 -> Result<ConversionResult<TestBindingOrStringByteStringRecord<D>>, ()> {
6224 if value.get().is_object() {
6225 match TestBindingOrStringByteStringRecord::<D>::TryConvertToTestBinding(SafeJSContext::from_ptr(cx), value) {
6226 Err(_) => return Err(()),
6227 Ok(Some(value)) => return Ok(ConversionResult::Success(TestBindingOrStringByteStringRecord::TestBinding(value))),
6228 Ok(None) => (),
6229 }
6230
6231 match TestBindingOrStringByteStringRecord::<D>::TryConvertToStringByteStringRecord(SafeJSContext::from_ptr(cx), value) {
6232 Err(_) => return Err(()),
6233 Ok(Some(value)) => return Ok(ConversionResult::Success(TestBindingOrStringByteStringRecord::StringByteStringRecord(value))),
6234 Ok(None) => (),
6235 }
6236
6237 }
6238
6239 Ok(ConversionResult::Failure("argument could not be converted to any of: TestBinding, StringByteStringRecord".into()))
6240 }
6241}
6242
6243impl<D: DomTypes> TestBindingOrStringByteStringRecord<D> {
6244 unsafe fn TryConvertToTestBinding(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TestBinding>>, ()> {
6245 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6246 Ok(val) => val,
6247 Err(()) => {
6248 return Ok(None);
6249 }
6250 }
6251 ))
6252 }
6253
6254 unsafe fn TryConvertToStringByteStringRecord(cx: SafeJSContext, value: HandleValue) -> Result<Option<Record<DOMString, ByteString>>, ()> {
6255 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6256 Ok(ConversionResult::Success(value)) => value,
6257 Ok(ConversionResult::Failure(error)) => {
6258 return Ok(None);
6259 }
6260 _ => {
6261 return Err(());
6262 },
6263 }
6264 ))
6265 }
6266}
6267
6268
6269
6270#[derive(JSTraceable)]
6271pub enum TestDictionaryOrLong<D: DomTypes> {
6272 TestDictionary(RootedTraceableBox<TestDictionary<D>>),
6273 Long(i32),
6274}
6275
6276impl<D: DomTypes> ToJSValConvertible for TestDictionaryOrLong<D> {
6277 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6278 match *self {
6279 TestDictionaryOrLong::TestDictionary(ref inner) => inner.to_jsval(cx, rval),
6280 TestDictionaryOrLong::Long(ref inner) => inner.to_jsval(cx, rval),
6281 }
6282 }
6283}
6284
6285
6286
6287impl<D: DomTypes> FromJSValConvertible for TestDictionaryOrLong<D> {
6288 type Config = ();
6289 unsafe fn from_jsval(cx: *mut RawJSContext,
6290 value: HandleValue,
6291 _option: ())
6292 -> Result<ConversionResult<TestDictionaryOrLong<D>>, ()> {
6293 match TestDictionaryOrLong::<D>::TryConvertToTestDictionary(SafeJSContext::from_ptr(cx), value) {
6294 Err(_) => return Err(()),
6295 Ok(Some(value)) => return Ok(ConversionResult::Success(TestDictionaryOrLong::TestDictionary(value))),
6296 Ok(None) => (),
6297 }
6298
6299
6300 match TestDictionaryOrLong::<D>::TryConvertToLong(SafeJSContext::from_ptr(cx), value) {
6301 Err(_) => return Err(()),
6302 Ok(Some(value)) => return Ok(ConversionResult::Success(TestDictionaryOrLong::Long(value))),
6303 Ok(None) => (),
6304 }
6305
6306
6307 Ok(ConversionResult::Failure("argument could not be converted to any of: TestDictionary".into()))
6308 }
6309}
6310
6311impl<D: DomTypes> TestDictionaryOrLong<D> {
6312 unsafe fn TryConvertToTestDictionary(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<TestDictionary<D>>>, ()> {
6313 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6314 Ok(ConversionResult::Success(value)) => value,
6315 Ok(ConversionResult::Failure(error)) => {
6316 return Ok(None);
6317 }
6318 _ => {
6319 return Err(());
6320 },
6321 }
6322 ))
6323 }
6324
6325 unsafe fn TryConvertToLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<i32>, ()> {
6326 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
6327 Ok(ConversionResult::Success(value)) => value,
6328 Ok(ConversionResult::Failure(error)) => {
6329 return Ok(None);
6330 }
6331 _ => {
6332 return Err(());
6333 },
6334 }
6335 ))
6336 }
6337}
6338
6339
6340
6341#[derive(JSTraceable)]
6342pub enum TrustedHTMLOrNullIsEmptyString<D: DomTypes> {
6343 TrustedHTML(DomRoot<D::TrustedHTML>),
6344 NullIsEmptyString(DOMString),
6345}
6346
6347impl<D: DomTypes> ToJSValConvertible for TrustedHTMLOrNullIsEmptyString<D> {
6348 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6349 match *self {
6350 TrustedHTMLOrNullIsEmptyString::TrustedHTML(ref inner) => inner.to_jsval(cx, rval),
6351 TrustedHTMLOrNullIsEmptyString::NullIsEmptyString(ref inner) => inner.to_jsval(cx, rval),
6352 }
6353 }
6354}
6355
6356
6357
6358impl<D: DomTypes> FromJSValConvertible for TrustedHTMLOrNullIsEmptyString<D> {
6359 type Config = ();
6360 unsafe fn from_jsval(cx: *mut RawJSContext,
6361 value: HandleValue,
6362 _option: ())
6363 -> Result<ConversionResult<TrustedHTMLOrNullIsEmptyString<D>>, ()> {
6364 if value.get().is_object() {
6365 match TrustedHTMLOrNullIsEmptyString::<D>::TryConvertToTrustedHTML(SafeJSContext::from_ptr(cx), value) {
6366 Err(_) => return Err(()),
6367 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrNullIsEmptyString::TrustedHTML(value))),
6368 Ok(None) => (),
6369 }
6370
6371 }
6372
6373 match TrustedHTMLOrNullIsEmptyString::<D>::TryConvertToNullIsEmptyString(SafeJSContext::from_ptr(cx), value) {
6374 Err(_) => return Err(()),
6375 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrNullIsEmptyString::NullIsEmptyString(value))),
6376 Ok(None) => (),
6377 }
6378
6379
6380 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedHTML".into()))
6381 }
6382}
6383
6384impl<D: DomTypes> TrustedHTMLOrNullIsEmptyString<D> {
6385 unsafe fn TryConvertToTrustedHTML(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedHTML>>, ()> {
6386 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6387 Ok(val) => val,
6388 Err(()) => {
6389 return Ok(None);
6390 }
6391 }
6392 ))
6393 }
6394
6395 unsafe fn TryConvertToNullIsEmptyString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
6396 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Empty) {
6397 Ok(ConversionResult::Success(value)) => value,
6398 Ok(ConversionResult::Failure(error)) => {
6399 return Ok(None);
6400 }
6401 _ => {
6402 return Err(());
6403 },
6404 }
6405 ))
6406 }
6407}
6408
6409
6410
6411#[derive(JSTraceable)]
6412pub enum TrustedHTMLOrString<D: DomTypes> {
6413 TrustedHTML(DomRoot<D::TrustedHTML>),
6414 String(DOMString),
6415}
6416
6417impl<D: DomTypes> ToJSValConvertible for TrustedHTMLOrString<D> {
6418 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6419 match *self {
6420 TrustedHTMLOrString::TrustedHTML(ref inner) => inner.to_jsval(cx, rval),
6421 TrustedHTMLOrString::String(ref inner) => inner.to_jsval(cx, rval),
6422 }
6423 }
6424}
6425
6426
6427
6428impl<D: DomTypes> FromJSValConvertible for TrustedHTMLOrString<D> {
6429 type Config = ();
6430 unsafe fn from_jsval(cx: *mut RawJSContext,
6431 value: HandleValue,
6432 _option: ())
6433 -> Result<ConversionResult<TrustedHTMLOrString<D>>, ()> {
6434 if value.get().is_object() {
6435 match TrustedHTMLOrString::<D>::TryConvertToTrustedHTML(SafeJSContext::from_ptr(cx), value) {
6436 Err(_) => return Err(()),
6437 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrString::TrustedHTML(value))),
6438 Ok(None) => (),
6439 }
6440
6441 }
6442
6443 match TrustedHTMLOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
6444 Err(_) => return Err(()),
6445 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrString::String(value))),
6446 Ok(None) => (),
6447 }
6448
6449
6450 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedHTML".into()))
6451 }
6452}
6453
6454impl<D: DomTypes> TrustedHTMLOrString<D> {
6455 unsafe fn TryConvertToTrustedHTML(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedHTML>>, ()> {
6456 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6457 Ok(val) => val,
6458 Err(()) => {
6459 return Ok(None);
6460 }
6461 }
6462 ))
6463 }
6464
6465 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
6466 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
6467 Ok(ConversionResult::Success(value)) => value,
6468 Ok(ConversionResult::Failure(error)) => {
6469 return Ok(None);
6470 }
6471 _ => {
6472 return Err(());
6473 },
6474 }
6475 ))
6476 }
6477}
6478
6479
6480
6481#[derive(JSTraceable)]
6482pub enum TrustedHTMLOrTrustedScriptOrTrustedScriptURL<D: DomTypes> {
6483 TrustedHTML(DomRoot<D::TrustedHTML>),
6484 TrustedScript(DomRoot<D::TrustedScript>),
6485 TrustedScriptURL(DomRoot<D::TrustedScriptURL>),
6486}
6487
6488impl<D: DomTypes> ToJSValConvertible for TrustedHTMLOrTrustedScriptOrTrustedScriptURL<D> {
6489 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6490 match *self {
6491 TrustedHTMLOrTrustedScriptOrTrustedScriptURL::TrustedHTML(ref inner) => inner.to_jsval(cx, rval),
6492 TrustedHTMLOrTrustedScriptOrTrustedScriptURL::TrustedScript(ref inner) => inner.to_jsval(cx, rval),
6493 TrustedHTMLOrTrustedScriptOrTrustedScriptURL::TrustedScriptURL(ref inner) => inner.to_jsval(cx, rval),
6494 }
6495 }
6496}
6497
6498
6499
6500impl<D: DomTypes> FromJSValConvertible for TrustedHTMLOrTrustedScriptOrTrustedScriptURL<D> {
6501 type Config = ();
6502 unsafe fn from_jsval(cx: *mut RawJSContext,
6503 value: HandleValue,
6504 _option: ())
6505 -> Result<ConversionResult<TrustedHTMLOrTrustedScriptOrTrustedScriptURL<D>>, ()> {
6506 if value.get().is_object() {
6507 match TrustedHTMLOrTrustedScriptOrTrustedScriptURL::<D>::TryConvertToTrustedHTML(SafeJSContext::from_ptr(cx), value) {
6508 Err(_) => return Err(()),
6509 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURL::TrustedHTML(value))),
6510 Ok(None) => (),
6511 }
6512 match TrustedHTMLOrTrustedScriptOrTrustedScriptURL::<D>::TryConvertToTrustedScript(SafeJSContext::from_ptr(cx), value) {
6513 Err(_) => return Err(()),
6514 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURL::TrustedScript(value))),
6515 Ok(None) => (),
6516 }
6517 match TrustedHTMLOrTrustedScriptOrTrustedScriptURL::<D>::TryConvertToTrustedScriptURL(SafeJSContext::from_ptr(cx), value) {
6518 Err(_) => return Err(()),
6519 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURL::TrustedScriptURL(value))),
6520 Ok(None) => (),
6521 }
6522
6523 }
6524
6525 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedHTML, TrustedScript, TrustedScriptURL".into()))
6526 }
6527}
6528
6529impl<D: DomTypes> TrustedHTMLOrTrustedScriptOrTrustedScriptURL<D> {
6530 unsafe fn TryConvertToTrustedHTML(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedHTML>>, ()> {
6531 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6532 Ok(val) => val,
6533 Err(()) => {
6534 return Ok(None);
6535 }
6536 }
6537 ))
6538 }
6539
6540 unsafe fn TryConvertToTrustedScript(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScript>>, ()> {
6541 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6542 Ok(val) => val,
6543 Err(()) => {
6544 return Ok(None);
6545 }
6546 }
6547 ))
6548 }
6549
6550 unsafe fn TryConvertToTrustedScriptURL(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScriptURL>>, ()> {
6551 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6552 Ok(val) => val,
6553 Err(()) => {
6554 return Ok(None);
6555 }
6556 }
6557 ))
6558 }
6559}
6560
6561
6562
6563#[derive(JSTraceable)]
6564pub enum TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString<D: DomTypes> {
6565 TrustedHTML(DomRoot<D::TrustedHTML>),
6566 TrustedScript(DomRoot<D::TrustedScript>),
6567 TrustedScriptURL(DomRoot<D::TrustedScriptURL>),
6568 String(DOMString),
6569}
6570
6571impl<D: DomTypes> ToJSValConvertible for TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString<D> {
6572 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6573 match *self {
6574 TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::TrustedHTML(ref inner) => inner.to_jsval(cx, rval),
6575 TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::TrustedScript(ref inner) => inner.to_jsval(cx, rval),
6576 TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::TrustedScriptURL(ref inner) => inner.to_jsval(cx, rval),
6577 TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::String(ref inner) => inner.to_jsval(cx, rval),
6578 }
6579 }
6580}
6581
6582
6583
6584impl<D: DomTypes> FromJSValConvertible for TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString<D> {
6585 type Config = ();
6586 unsafe fn from_jsval(cx: *mut RawJSContext,
6587 value: HandleValue,
6588 _option: ())
6589 -> Result<ConversionResult<TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString<D>>, ()> {
6590 if value.get().is_object() {
6591 match TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::<D>::TryConvertToTrustedHTML(SafeJSContext::from_ptr(cx), value) {
6592 Err(_) => return Err(()),
6593 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::TrustedHTML(value))),
6594 Ok(None) => (),
6595 }
6596 match TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::<D>::TryConvertToTrustedScript(SafeJSContext::from_ptr(cx), value) {
6597 Err(_) => return Err(()),
6598 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::TrustedScript(value))),
6599 Ok(None) => (),
6600 }
6601 match TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::<D>::TryConvertToTrustedScriptURL(SafeJSContext::from_ptr(cx), value) {
6602 Err(_) => return Err(()),
6603 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::TrustedScriptURL(value))),
6604 Ok(None) => (),
6605 }
6606
6607 }
6608
6609 match TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
6610 Err(_) => return Err(()),
6611 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString::String(value))),
6612 Ok(None) => (),
6613 }
6614
6615
6616 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedHTML, TrustedScript, TrustedScriptURL".into()))
6617 }
6618}
6619
6620impl<D: DomTypes> TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString<D> {
6621 unsafe fn TryConvertToTrustedHTML(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedHTML>>, ()> {
6622 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6623 Ok(val) => val,
6624 Err(()) => {
6625 return Ok(None);
6626 }
6627 }
6628 ))
6629 }
6630
6631 unsafe fn TryConvertToTrustedScript(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScript>>, ()> {
6632 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6633 Ok(val) => val,
6634 Err(()) => {
6635 return Ok(None);
6636 }
6637 }
6638 ))
6639 }
6640
6641 unsafe fn TryConvertToTrustedScriptURL(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScriptURL>>, ()> {
6642 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6643 Ok(val) => val,
6644 Err(()) => {
6645 return Ok(None);
6646 }
6647 }
6648 ))
6649 }
6650
6651 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
6652 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
6653 Ok(ConversionResult::Success(value)) => value,
6654 Ok(ConversionResult::Failure(error)) => {
6655 return Ok(None);
6656 }
6657 _ => {
6658 return Err(());
6659 },
6660 }
6661 ))
6662 }
6663}
6664
6665
6666
6667#[derive(JSTraceable)]
6668pub enum TrustedScriptOrString<D: DomTypes> {
6669 TrustedScript(DomRoot<D::TrustedScript>),
6670 String(DOMString),
6671}
6672
6673impl<D: DomTypes> ToJSValConvertible for TrustedScriptOrString<D> {
6674 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6675 match *self {
6676 TrustedScriptOrString::TrustedScript(ref inner) => inner.to_jsval(cx, rval),
6677 TrustedScriptOrString::String(ref inner) => inner.to_jsval(cx, rval),
6678 }
6679 }
6680}
6681
6682
6683
6684impl<D: DomTypes> FromJSValConvertible for TrustedScriptOrString<D> {
6685 type Config = ();
6686 unsafe fn from_jsval(cx: *mut RawJSContext,
6687 value: HandleValue,
6688 _option: ())
6689 -> Result<ConversionResult<TrustedScriptOrString<D>>, ()> {
6690 if value.get().is_object() {
6691 match TrustedScriptOrString::<D>::TryConvertToTrustedScript(SafeJSContext::from_ptr(cx), value) {
6692 Err(_) => return Err(()),
6693 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptOrString::TrustedScript(value))),
6694 Ok(None) => (),
6695 }
6696
6697 }
6698
6699 match TrustedScriptOrString::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
6700 Err(_) => return Err(()),
6701 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptOrString::String(value))),
6702 Ok(None) => (),
6703 }
6704
6705
6706 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedScript".into()))
6707 }
6708}
6709
6710impl<D: DomTypes> TrustedScriptOrString<D> {
6711 unsafe fn TryConvertToTrustedScript(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScript>>, ()> {
6712 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6713 Ok(val) => val,
6714 Err(()) => {
6715 return Ok(None);
6716 }
6717 }
6718 ))
6719 }
6720
6721 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
6722 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
6723 Ok(ConversionResult::Success(value)) => value,
6724 Ok(ConversionResult::Failure(error)) => {
6725 return Ok(None);
6726 }
6727 _ => {
6728 return Err(());
6729 },
6730 }
6731 ))
6732 }
6733}
6734
6735
6736
6737#[derive(JSTraceable)]
6738pub enum TrustedScriptOrStringOrFunction<D: DomTypes> {
6739 TrustedScript(DomRoot<D::TrustedScript>),
6740 String(DOMString),
6741 Function(Rc<Function<D>>),
6742}
6743
6744impl<D: DomTypes> ToJSValConvertible for TrustedScriptOrStringOrFunction<D> {
6745 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6746 match *self {
6747 TrustedScriptOrStringOrFunction::TrustedScript(ref inner) => inner.to_jsval(cx, rval),
6748 TrustedScriptOrStringOrFunction::String(ref inner) => inner.to_jsval(cx, rval),
6749 TrustedScriptOrStringOrFunction::Function(ref inner) => inner.to_jsval(cx, rval),
6750 }
6751 }
6752}
6753
6754
6755
6756impl<D: DomTypes> FromJSValConvertible for TrustedScriptOrStringOrFunction<D> {
6757 type Config = ();
6758 unsafe fn from_jsval(cx: *mut RawJSContext,
6759 value: HandleValue,
6760 _option: ())
6761 -> Result<ConversionResult<TrustedScriptOrStringOrFunction<D>>, ()> {
6762 if value.get().is_object() {
6763 match TrustedScriptOrStringOrFunction::<D>::TryConvertToFunction(SafeJSContext::from_ptr(cx), value) {
6764 Err(_) => return Err(()),
6765 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptOrStringOrFunction::Function(value))),
6766 Ok(None) => (),
6767 }
6768
6769 match TrustedScriptOrStringOrFunction::<D>::TryConvertToTrustedScript(SafeJSContext::from_ptr(cx), value) {
6770 Err(_) => return Err(()),
6771 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptOrStringOrFunction::TrustedScript(value))),
6772 Ok(None) => (),
6773 }
6774
6775 }
6776
6777 match TrustedScriptOrStringOrFunction::<D>::TryConvertToString(SafeJSContext::from_ptr(cx), value) {
6778 Err(_) => return Err(()),
6779 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptOrStringOrFunction::String(value))),
6780 Ok(None) => (),
6781 }
6782
6783
6784 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedScript".into()))
6785 }
6786}
6787
6788impl<D: DomTypes> TrustedScriptOrStringOrFunction<D> {
6789 unsafe fn TryConvertToTrustedScript(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScript>>, ()> {
6790 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6791 Ok(val) => val,
6792 Err(()) => {
6793 return Ok(None);
6794 }
6795 }
6796 ))
6797 }
6798
6799 unsafe fn TryConvertToString(cx: SafeJSContext, value: HandleValue) -> Result<Option<DOMString>, ()> {
6800 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, StringificationBehavior::Default) {
6801 Ok(ConversionResult::Success(value)) => value,
6802 Ok(ConversionResult::Failure(error)) => {
6803 return Ok(None);
6804 }
6805 _ => {
6806 return Err(());
6807 },
6808 }
6809 ))
6810 }
6811
6812 unsafe fn TryConvertToFunction(cx: SafeJSContext, value: HandleValue) -> Result<Option<Rc<Function<D>>>, ()> {
6813 Ok(Some(if IsCallable(value.get().to_object()) {
6814 Function::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), value.get().to_object())
6815 } else {
6816 return Ok(None);
6817 }))
6818 }
6819}
6820
6821
6822
6823#[derive(JSTraceable)]
6824pub enum TrustedScriptURLOrUSVString<D: DomTypes> {
6825 TrustedScriptURL(DomRoot<D::TrustedScriptURL>),
6826 USVString(USVString),
6827}
6828
6829impl<D: DomTypes> ToJSValConvertible for TrustedScriptURLOrUSVString<D> {
6830 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6831 match *self {
6832 TrustedScriptURLOrUSVString::TrustedScriptURL(ref inner) => inner.to_jsval(cx, rval),
6833 TrustedScriptURLOrUSVString::USVString(ref inner) => inner.to_jsval(cx, rval),
6834 }
6835 }
6836}
6837
6838
6839
6840impl<D: DomTypes> FromJSValConvertible for TrustedScriptURLOrUSVString<D> {
6841 type Config = ();
6842 unsafe fn from_jsval(cx: *mut RawJSContext,
6843 value: HandleValue,
6844 _option: ())
6845 -> Result<ConversionResult<TrustedScriptURLOrUSVString<D>>, ()> {
6846 if value.get().is_object() {
6847 match TrustedScriptURLOrUSVString::<D>::TryConvertToTrustedScriptURL(SafeJSContext::from_ptr(cx), value) {
6848 Err(_) => return Err(()),
6849 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptURLOrUSVString::TrustedScriptURL(value))),
6850 Ok(None) => (),
6851 }
6852
6853 }
6854
6855 match TrustedScriptURLOrUSVString::<D>::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
6856 Err(_) => return Err(()),
6857 Ok(Some(value)) => return Ok(ConversionResult::Success(TrustedScriptURLOrUSVString::USVString(value))),
6858 Ok(None) => (),
6859 }
6860
6861
6862 Ok(ConversionResult::Failure("argument could not be converted to any of: TrustedScriptURL".into()))
6863 }
6864}
6865
6866impl<D: DomTypes> TrustedScriptURLOrUSVString<D> {
6867 unsafe fn TryConvertToTrustedScriptURL(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TrustedScriptURL>>, ()> {
6868 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
6869 Ok(val) => val,
6870 Err(()) => {
6871 return Ok(None);
6872 }
6873 }
6874 ))
6875 }
6876
6877 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
6878 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6879 Ok(ConversionResult::Success(value)) => value,
6880 Ok(ConversionResult::Failure(error)) => {
6881 return Ok(None);
6882 }
6883 _ => {
6884 return Err(());
6885 },
6886 }
6887 ))
6888 }
6889}
6890
6891
6892
6893#[derive(JSTraceable)]
6894pub enum USVStringOrNotUsedAnyWhereElse {
6895 USVString(USVString),
6896 NotUsedAnyWhereElse(NotUsedAnyWhereElse),
6897}
6898
6899impl ToJSValConvertible for USVStringOrNotUsedAnyWhereElse {
6900 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6901 match *self {
6902 USVStringOrNotUsedAnyWhereElse::USVString(ref inner) => inner.to_jsval(cx, rval),
6903 USVStringOrNotUsedAnyWhereElse::NotUsedAnyWhereElse(ref inner) => inner.to_jsval(cx, rval),
6904 }
6905 }
6906}
6907
6908
6909
6910impl FromJSValConvertible for USVStringOrNotUsedAnyWhereElse {
6911 type Config = ();
6912 unsafe fn from_jsval(cx: *mut RawJSContext,
6913 value: HandleValue,
6914 _option: ())
6915 -> Result<ConversionResult<USVStringOrNotUsedAnyWhereElse>, ()> {
6916 match USVStringOrNotUsedAnyWhereElse::TryConvertToNotUsedAnyWhereElse(SafeJSContext::from_ptr(cx), value) {
6917 Err(_) => return Err(()),
6918 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringOrNotUsedAnyWhereElse::NotUsedAnyWhereElse(value))),
6919 Ok(None) => (),
6920 }
6921
6922
6923 match USVStringOrNotUsedAnyWhereElse::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
6924 Err(_) => return Err(()),
6925 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringOrNotUsedAnyWhereElse::USVString(value))),
6926 Ok(None) => (),
6927 }
6928
6929
6930 Ok(ConversionResult::Failure("argument could not be converted to any of: NotUsedAnyWhereElse".into()))
6931 }
6932}
6933
6934impl USVStringOrNotUsedAnyWhereElse {
6935 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
6936 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6937 Ok(ConversionResult::Success(value)) => value,
6938 Ok(ConversionResult::Failure(error)) => {
6939 return Ok(None);
6940 }
6941 _ => {
6942 return Err(());
6943 },
6944 }
6945 ))
6946 }
6947
6948 unsafe fn TryConvertToNotUsedAnyWhereElse(cx: SafeJSContext, value: HandleValue) -> Result<Option<NotUsedAnyWhereElse>, ()> {
6949 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
6950 Ok(ConversionResult::Success(value)) => value,
6951 Ok(ConversionResult::Failure(error)) => {
6952 return Ok(None);
6953 }
6954 _ => {
6955 return Err(());
6956 },
6957 }
6958 ))
6959 }
6960}
6961
6962
6963
6964#[derive(JSTraceable)]
6965pub enum USVStringOrURLPatternInit {
6966 USVString(USVString),
6967 URLPatternInit(URLPatternInit),
6968}
6969
6970impl ToJSValConvertible for USVStringOrURLPatternInit {
6971 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
6972 match *self {
6973 USVStringOrURLPatternInit::USVString(ref inner) => inner.to_jsval(cx, rval),
6974 USVStringOrURLPatternInit::URLPatternInit(ref inner) => inner.to_jsval(cx, rval),
6975 }
6976 }
6977}
6978
6979
6980
6981impl FromJSValConvertible for USVStringOrURLPatternInit {
6982 type Config = ();
6983 unsafe fn from_jsval(cx: *mut RawJSContext,
6984 value: HandleValue,
6985 _option: ())
6986 -> Result<ConversionResult<USVStringOrURLPatternInit>, ()> {
6987 match USVStringOrURLPatternInit::TryConvertToURLPatternInit(SafeJSContext::from_ptr(cx), value) {
6988 Err(_) => return Err(()),
6989 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringOrURLPatternInit::URLPatternInit(value))),
6990 Ok(None) => (),
6991 }
6992
6993
6994 match USVStringOrURLPatternInit::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
6995 Err(_) => return Err(()),
6996 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringOrURLPatternInit::USVString(value))),
6997 Ok(None) => (),
6998 }
6999
7000
7001 Ok(ConversionResult::Failure("argument could not be converted to any of: URLPatternInit".into()))
7002 }
7003}
7004
7005impl USVStringOrURLPatternInit {
7006 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
7007 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7008 Ok(ConversionResult::Success(value)) => value,
7009 Ok(ConversionResult::Failure(error)) => {
7010 return Ok(None);
7011 }
7012 _ => {
7013 return Err(());
7014 },
7015 }
7016 ))
7017 }
7018
7019 unsafe fn TryConvertToURLPatternInit(cx: SafeJSContext, value: HandleValue) -> Result<Option<URLPatternInit>, ()> {
7020 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7021 Ok(ConversionResult::Success(value)) => value,
7022 Ok(ConversionResult::Failure(error)) => {
7023 return Ok(None);
7024 }
7025 _ => {
7026 return Err(());
7027 },
7028 }
7029 ))
7030 }
7031}
7032
7033
7034
7035#[derive(JSTraceable)]
7036pub enum USVStringOrUndefined {
7037 USVString(USVString),
7038 Undefined(()),
7039}
7040
7041impl ToJSValConvertible for USVStringOrUndefined {
7042 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7043 match *self {
7044 USVStringOrUndefined::USVString(ref inner) => inner.to_jsval(cx, rval),
7045 USVStringOrUndefined::Undefined(ref inner) => inner.to_jsval(cx, rval),
7046 }
7047 }
7048}
7049
7050
7051
7052impl FromJSValConvertible for USVStringOrUndefined {
7053 type Config = ();
7054 unsafe fn from_jsval(cx: *mut RawJSContext,
7055 value: HandleValue,
7056 _option: ())
7057 -> Result<ConversionResult<USVStringOrUndefined>, ()> {
7058 if value.get().is_undefined() {
7059 return Ok(ConversionResult::Success(Self::Undefined(())));
7060 }
7061
7062 match USVStringOrUndefined::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
7063 Err(_) => return Err(()),
7064 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringOrUndefined::USVString(value))),
7065 Ok(None) => (),
7066 }
7067
7068
7069 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
7070 }
7071}
7072
7073impl USVStringOrUndefined {
7074 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
7075 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7076 Ok(ConversionResult::Success(value)) => value,
7077 Ok(ConversionResult::Failure(error)) => {
7078 return Ok(None);
7079 }
7080 _ => {
7081 return Err(());
7082 },
7083 }
7084 ))
7085 }
7086}
7087
7088
7089
7090#[derive(JSTraceable)]
7091pub enum USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString {
7092 USVStringSequenceSequence(Vec<Vec<USVString>>),
7093 USVStringUSVStringRecord(Record<USVString, USVString>),
7094 USVString(USVString),
7095}
7096
7097impl ToJSValConvertible for USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString {
7098 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7099 match *self {
7100 USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::USVStringSequenceSequence(ref inner) => inner.to_jsval(cx, rval),
7101 USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::USVStringUSVStringRecord(ref inner) => inner.to_jsval(cx, rval),
7102 USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::USVString(ref inner) => inner.to_jsval(cx, rval),
7103 }
7104 }
7105}
7106
7107
7108
7109impl FromJSValConvertible for USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString {
7110 type Config = ();
7111 unsafe fn from_jsval(cx: *mut RawJSContext,
7112 value: HandleValue,
7113 _option: ())
7114 -> Result<ConversionResult<USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString>, ()> {
7115 if value.get().is_object() {
7116 match USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::TryConvertToUSVStringSequenceSequence(SafeJSContext::from_ptr(cx), value) {
7117 Err(_) => return Err(()),
7118 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::USVStringSequenceSequence(value))),
7119 Ok(None) => (),
7120 }
7121
7122 match USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::TryConvertToUSVStringUSVStringRecord(SafeJSContext::from_ptr(cx), value) {
7123 Err(_) => return Err(()),
7124 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::USVStringUSVStringRecord(value))),
7125 Ok(None) => (),
7126 }
7127
7128 }
7129
7130 match USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::TryConvertToUSVString(SafeJSContext::from_ptr(cx), value) {
7131 Err(_) => return Err(()),
7132 Ok(Some(value)) => return Ok(ConversionResult::Success(USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString::USVString(value))),
7133 Ok(None) => (),
7134 }
7135
7136
7137 Ok(ConversionResult::Failure("argument could not be converted to any of: USVStringSequenceSequence, USVStringUSVStringRecord".into()))
7138 }
7139}
7140
7141impl USVStringSequenceSequenceOrUSVStringUSVStringRecordOrUSVString {
7142 unsafe fn TryConvertToUSVStringSequenceSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<Vec<USVString>>>, ()> {
7143 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7144 Ok(ConversionResult::Success(value)) => value,
7145 Ok(ConversionResult::Failure(error)) => {
7146 return Ok(None);
7147 }
7148 _ => {
7149 return Err(());
7150 },
7151 }
7152 ))
7153 }
7154
7155 unsafe fn TryConvertToUSVStringUSVStringRecord(cx: SafeJSContext, value: HandleValue) -> Result<Option<Record<USVString, USVString>>, ()> {
7156 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7157 Ok(ConversionResult::Success(value)) => value,
7158 Ok(ConversionResult::Failure(error)) => {
7159 return Ok(None);
7160 }
7161 _ => {
7162 return Err(());
7163 },
7164 }
7165 ))
7166 }
7167
7168 unsafe fn TryConvertToUSVString(cx: SafeJSContext, value: HandleValue) -> Result<Option<USVString>, ()> {
7169 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7170 Ok(ConversionResult::Success(value)) => value,
7171 Ok(ConversionResult::Failure(error)) => {
7172 return Ok(None);
7173 }
7174 _ => {
7175 return Err(());
7176 },
7177 }
7178 ))
7179 }
7180}
7181
7182
7183
7184#[derive(JSTraceable)]
7185pub enum Uint32ArrayOrUnsignedLongSequence {
7186 Uint32Array(RootedTraceableBox<typedarray::HeapUint32Array>),
7187 UnsignedLongSequence(Vec<u32>),
7188}
7189
7190impl ToJSValConvertible for Uint32ArrayOrUnsignedLongSequence {
7191 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7192 match *self {
7193 Uint32ArrayOrUnsignedLongSequence::Uint32Array(ref inner) => inner.to_jsval(cx, rval),
7194 Uint32ArrayOrUnsignedLongSequence::UnsignedLongSequence(ref inner) => inner.to_jsval(cx, rval),
7195 }
7196 }
7197}
7198
7199
7200
7201impl FromJSValConvertible for Uint32ArrayOrUnsignedLongSequence {
7202 type Config = ();
7203 unsafe fn from_jsval(cx: *mut RawJSContext,
7204 value: HandleValue,
7205 _option: ())
7206 -> Result<ConversionResult<Uint32ArrayOrUnsignedLongSequence>, ()> {
7207 if value.get().is_object() {
7208 match Uint32ArrayOrUnsignedLongSequence::TryConvertToUnsignedLongSequence(SafeJSContext::from_ptr(cx), value) {
7209 Err(_) => return Err(()),
7210 Ok(Some(value)) => return Ok(ConversionResult::Success(Uint32ArrayOrUnsignedLongSequence::UnsignedLongSequence(value))),
7211 Ok(None) => (),
7212 }
7213
7214 match Uint32ArrayOrUnsignedLongSequence::TryConvertToUint32Array(SafeJSContext::from_ptr(cx), value) {
7215 Err(_) => return Err(()),
7216 Ok(Some(value)) => return Ok(ConversionResult::Success(Uint32ArrayOrUnsignedLongSequence::Uint32Array(value))),
7217 Ok(None) => (),
7218 }
7219
7220 }
7221
7222 Ok(ConversionResult::Failure("argument could not be converted to any of: Uint32Array, UnsignedLongSequence".into()))
7223 }
7224}
7225
7226impl Uint32ArrayOrUnsignedLongSequence {
7227 unsafe fn TryConvertToUint32Array(cx: SafeJSContext, value: HandleValue) -> Result<Option<RootedTraceableBox<typedarray::HeapUint32Array>>, ()> {
7228 Ok(Some(match typedarray::HeapUint32Array::from(value.get().to_object()).map(RootedTraceableBox::new) {
7229 Ok(val) => val,
7230 Err(()) => {
7231 return Ok(None);
7232 }
7233 }
7234 ))
7235 }
7236
7237 unsafe fn TryConvertToUnsignedLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<u32>>, ()> {
7238 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
7239 Ok(ConversionResult::Success(value)) => value,
7240 Ok(ConversionResult::Failure(error)) => {
7241 return Ok(None);
7242 }
7243 _ => {
7244 return Err(());
7245 },
7246 }
7247 ))
7248 }
7249}
7250
7251
7252
7253#[derive(JSTraceable)]
7254pub enum UnsignedLongOrBoolean {
7255 UnsignedLong(u32),
7256 Boolean(bool),
7257}
7258
7259impl ToJSValConvertible for UnsignedLongOrBoolean {
7260 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7261 match *self {
7262 UnsignedLongOrBoolean::UnsignedLong(ref inner) => inner.to_jsval(cx, rval),
7263 UnsignedLongOrBoolean::Boolean(ref inner) => inner.to_jsval(cx, rval),
7264 }
7265 }
7266}
7267
7268
7269
7270impl FromJSValConvertible for UnsignedLongOrBoolean {
7271 type Config = ();
7272 unsafe fn from_jsval(cx: *mut RawJSContext,
7273 value: HandleValue,
7274 _option: ())
7275 -> Result<ConversionResult<UnsignedLongOrBoolean>, ()> {
7276 if value.get().is_boolean() {
7277 match UnsignedLongOrBoolean::TryConvertToBoolean(SafeJSContext::from_ptr(cx), value) {
7278 Err(_) => return Err(()),
7279 Ok(Some(value)) => return Ok(ConversionResult::Success(UnsignedLongOrBoolean::Boolean(value))),
7280 Ok(None) => (),
7281 }
7282
7283 }
7284
7285 match UnsignedLongOrBoolean::TryConvertToUnsignedLong(SafeJSContext::from_ptr(cx), value) {
7286 Err(_) => return Err(()),
7287 Ok(Some(value)) => return Ok(ConversionResult::Success(UnsignedLongOrBoolean::UnsignedLong(value))),
7288 Ok(None) => (),
7289 }
7290
7291
7292 Ok(ConversionResult::Failure("argument could not be converted to any of: ".into()))
7293 }
7294}
7295
7296impl UnsignedLongOrBoolean {
7297 unsafe fn TryConvertToUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
7298 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
7299 Ok(ConversionResult::Success(value)) => value,
7300 Ok(ConversionResult::Failure(error)) => {
7301 return Ok(None);
7302 }
7303 _ => {
7304 return Err(());
7305 },
7306 }
7307 ))
7308 }
7309
7310 unsafe fn TryConvertToBoolean(cx: SafeJSContext, value: HandleValue) -> Result<Option<bool>, ()> {
7311 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ()) {
7312 Ok(ConversionResult::Success(value)) => value,
7313 Ok(ConversionResult::Failure(error)) => {
7314 return Ok(None);
7315 }
7316 _ => {
7317 return Err(());
7318 },
7319 }
7320 ))
7321 }
7322}
7323
7324
7325
7326#[derive(JSTraceable)]
7327pub enum UnsignedLongOrUnsignedLongSequence {
7328 UnsignedLong(u32),
7329 UnsignedLongSequence(Vec<u32>),
7330}
7331
7332impl ToJSValConvertible for UnsignedLongOrUnsignedLongSequence {
7333 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7334 match *self {
7335 UnsignedLongOrUnsignedLongSequence::UnsignedLong(ref inner) => inner.to_jsval(cx, rval),
7336 UnsignedLongOrUnsignedLongSequence::UnsignedLongSequence(ref inner) => inner.to_jsval(cx, rval),
7337 }
7338 }
7339}
7340
7341
7342
7343impl FromJSValConvertible for UnsignedLongOrUnsignedLongSequence {
7344 type Config = ();
7345 unsafe fn from_jsval(cx: *mut RawJSContext,
7346 value: HandleValue,
7347 _option: ())
7348 -> Result<ConversionResult<UnsignedLongOrUnsignedLongSequence>, ()> {
7349 if value.get().is_object() {
7350 match UnsignedLongOrUnsignedLongSequence::TryConvertToUnsignedLongSequence(SafeJSContext::from_ptr(cx), value) {
7351 Err(_) => return Err(()),
7352 Ok(Some(value)) => return Ok(ConversionResult::Success(UnsignedLongOrUnsignedLongSequence::UnsignedLongSequence(value))),
7353 Ok(None) => (),
7354 }
7355
7356 }
7357
7358 match UnsignedLongOrUnsignedLongSequence::TryConvertToUnsignedLong(SafeJSContext::from_ptr(cx), value) {
7359 Err(_) => return Err(()),
7360 Ok(Some(value)) => return Ok(ConversionResult::Success(UnsignedLongOrUnsignedLongSequence::UnsignedLong(value))),
7361 Ok(None) => (),
7362 }
7363
7364
7365 Ok(ConversionResult::Failure("argument could not be converted to any of: UnsignedLongSequence".into()))
7366 }
7367}
7368
7369impl UnsignedLongOrUnsignedLongSequence {
7370 unsafe fn TryConvertToUnsignedLong(cx: SafeJSContext, value: HandleValue) -> Result<Option<u32>, ()> {
7371 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
7372 Ok(ConversionResult::Success(value)) => value,
7373 Ok(ConversionResult::Failure(error)) => {
7374 return Ok(None);
7375 }
7376 _ => {
7377 return Err(());
7378 },
7379 }
7380 ))
7381 }
7382
7383 unsafe fn TryConvertToUnsignedLongSequence(cx: SafeJSContext, value: HandleValue) -> Result<Option<Vec<u32>>, ()> {
7384 Ok(Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), value, ConversionBehavior::Default) {
7385 Ok(ConversionResult::Success(value)) => value,
7386 Ok(ConversionResult::Failure(error)) => {
7387 return Ok(None);
7388 }
7389 _ => {
7390 return Err(());
7391 },
7392 }
7393 ))
7394 }
7395}
7396
7397
7398
7399#[derive(JSTraceable)]
7400pub enum VideoTrackOrAudioTrackOrTextTrack<D: DomTypes> {
7401 VideoTrack(DomRoot<D::VideoTrack>),
7402 AudioTrack(DomRoot<D::AudioTrack>),
7403 TextTrack(DomRoot<D::TextTrack>),
7404}
7405
7406impl<D: DomTypes> ToJSValConvertible for VideoTrackOrAudioTrackOrTextTrack<D> {
7407 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7408 match *self {
7409 VideoTrackOrAudioTrackOrTextTrack::VideoTrack(ref inner) => inner.to_jsval(cx, rval),
7410 VideoTrackOrAudioTrackOrTextTrack::AudioTrack(ref inner) => inner.to_jsval(cx, rval),
7411 VideoTrackOrAudioTrackOrTextTrack::TextTrack(ref inner) => inner.to_jsval(cx, rval),
7412 }
7413 }
7414}
7415
7416
7417
7418impl<D: DomTypes> FromJSValConvertible for VideoTrackOrAudioTrackOrTextTrack<D> {
7419 type Config = ();
7420 unsafe fn from_jsval(cx: *mut RawJSContext,
7421 value: HandleValue,
7422 _option: ())
7423 -> Result<ConversionResult<VideoTrackOrAudioTrackOrTextTrack<D>>, ()> {
7424 if value.get().is_object() {
7425 match VideoTrackOrAudioTrackOrTextTrack::<D>::TryConvertToVideoTrack(SafeJSContext::from_ptr(cx), value) {
7426 Err(_) => return Err(()),
7427 Ok(Some(value)) => return Ok(ConversionResult::Success(VideoTrackOrAudioTrackOrTextTrack::VideoTrack(value))),
7428 Ok(None) => (),
7429 }
7430 match VideoTrackOrAudioTrackOrTextTrack::<D>::TryConvertToAudioTrack(SafeJSContext::from_ptr(cx), value) {
7431 Err(_) => return Err(()),
7432 Ok(Some(value)) => return Ok(ConversionResult::Success(VideoTrackOrAudioTrackOrTextTrack::AudioTrack(value))),
7433 Ok(None) => (),
7434 }
7435 match VideoTrackOrAudioTrackOrTextTrack::<D>::TryConvertToTextTrack(SafeJSContext::from_ptr(cx), value) {
7436 Err(_) => return Err(()),
7437 Ok(Some(value)) => return Ok(ConversionResult::Success(VideoTrackOrAudioTrackOrTextTrack::TextTrack(value))),
7438 Ok(None) => (),
7439 }
7440
7441 }
7442
7443 Ok(ConversionResult::Failure("argument could not be converted to any of: VideoTrack, AudioTrack, TextTrack".into()))
7444 }
7445}
7446
7447impl<D: DomTypes> VideoTrackOrAudioTrackOrTextTrack<D> {
7448 unsafe fn TryConvertToVideoTrack(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::VideoTrack>>, ()> {
7449 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7450 Ok(val) => val,
7451 Err(()) => {
7452 return Ok(None);
7453 }
7454 }
7455 ))
7456 }
7457
7458 unsafe fn TryConvertToAudioTrack(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::AudioTrack>>, ()> {
7459 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7460 Ok(val) => val,
7461 Err(()) => {
7462 return Ok(None);
7463 }
7464 }
7465 ))
7466 }
7467
7468 unsafe fn TryConvertToTextTrack(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::TextTrack>>, ()> {
7469 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7470 Ok(val) => val,
7471 Err(()) => {
7472 return Ok(None);
7473 }
7474 }
7475 ))
7476 }
7477}
7478
7479
7480
7481#[derive(JSTraceable)]
7482pub enum WebGLRenderingContextOrWebGL2RenderingContext<D: DomTypes> {
7483 WebGLRenderingContext(DomRoot<D::WebGLRenderingContext>),
7484 WebGL2RenderingContext(DomRoot<D::WebGL2RenderingContext>),
7485}
7486
7487impl<D: DomTypes> ToJSValConvertible for WebGLRenderingContextOrWebGL2RenderingContext<D> {
7488 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7489 match *self {
7490 WebGLRenderingContextOrWebGL2RenderingContext::WebGLRenderingContext(ref inner) => inner.to_jsval(cx, rval),
7491 WebGLRenderingContextOrWebGL2RenderingContext::WebGL2RenderingContext(ref inner) => inner.to_jsval(cx, rval),
7492 }
7493 }
7494}
7495
7496
7497
7498impl<D: DomTypes> FromJSValConvertible for WebGLRenderingContextOrWebGL2RenderingContext<D> {
7499 type Config = ();
7500 unsafe fn from_jsval(cx: *mut RawJSContext,
7501 value: HandleValue,
7502 _option: ())
7503 -> Result<ConversionResult<WebGLRenderingContextOrWebGL2RenderingContext<D>>, ()> {
7504 if value.get().is_object() {
7505 match WebGLRenderingContextOrWebGL2RenderingContext::<D>::TryConvertToWebGLRenderingContext(SafeJSContext::from_ptr(cx), value) {
7506 Err(_) => return Err(()),
7507 Ok(Some(value)) => return Ok(ConversionResult::Success(WebGLRenderingContextOrWebGL2RenderingContext::WebGLRenderingContext(value))),
7508 Ok(None) => (),
7509 }
7510 match WebGLRenderingContextOrWebGL2RenderingContext::<D>::TryConvertToWebGL2RenderingContext(SafeJSContext::from_ptr(cx), value) {
7511 Err(_) => return Err(()),
7512 Ok(Some(value)) => return Ok(ConversionResult::Success(WebGLRenderingContextOrWebGL2RenderingContext::WebGL2RenderingContext(value))),
7513 Ok(None) => (),
7514 }
7515
7516 }
7517
7518 Ok(ConversionResult::Failure("argument could not be converted to any of: WebGLRenderingContext, WebGL2RenderingContext".into()))
7519 }
7520}
7521
7522impl<D: DomTypes> WebGLRenderingContextOrWebGL2RenderingContext<D> {
7523 unsafe fn TryConvertToWebGLRenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WebGLRenderingContext>>, ()> {
7524 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7525 Ok(val) => val,
7526 Err(()) => {
7527 return Ok(None);
7528 }
7529 }
7530 ))
7531 }
7532
7533 unsafe fn TryConvertToWebGL2RenderingContext(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WebGL2RenderingContext>>, ()> {
7534 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7535 Ok(val) => val,
7536 Err(()) => {
7537 return Ok(None);
7538 }
7539 }
7540 ))
7541 }
7542}
7543
7544
7545
7546#[derive(JSTraceable)]
7547pub enum WindowProxyOrElementOrHTMLCollection<D: DomTypes> {
7548 WindowProxy(DomRoot<D::WindowProxy>),
7549 Element(DomRoot<D::Element>),
7550 HTMLCollection(DomRoot<D::HTMLCollection>),
7551}
7552
7553impl<D: DomTypes> ToJSValConvertible for WindowProxyOrElementOrHTMLCollection<D> {
7554 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7555 match *self {
7556 WindowProxyOrElementOrHTMLCollection::WindowProxy(ref inner) => inner.to_jsval(cx, rval),
7557 WindowProxyOrElementOrHTMLCollection::Element(ref inner) => inner.to_jsval(cx, rval),
7558 WindowProxyOrElementOrHTMLCollection::HTMLCollection(ref inner) => inner.to_jsval(cx, rval),
7559 }
7560 }
7561}
7562
7563
7564
7565impl<D: DomTypes> FromJSValConvertible for WindowProxyOrElementOrHTMLCollection<D> {
7566 type Config = ();
7567 unsafe fn from_jsval(cx: *mut RawJSContext,
7568 value: HandleValue,
7569 _option: ())
7570 -> Result<ConversionResult<WindowProxyOrElementOrHTMLCollection<D>>, ()> {
7571 if value.get().is_object() {
7572 match WindowProxyOrElementOrHTMLCollection::<D>::TryConvertToWindowProxy(SafeJSContext::from_ptr(cx), value) {
7573 Err(_) => return Err(()),
7574 Ok(Some(value)) => return Ok(ConversionResult::Success(WindowProxyOrElementOrHTMLCollection::WindowProxy(value))),
7575 Ok(None) => (),
7576 }
7577 match WindowProxyOrElementOrHTMLCollection::<D>::TryConvertToElement(SafeJSContext::from_ptr(cx), value) {
7578 Err(_) => return Err(()),
7579 Ok(Some(value)) => return Ok(ConversionResult::Success(WindowProxyOrElementOrHTMLCollection::Element(value))),
7580 Ok(None) => (),
7581 }
7582 match WindowProxyOrElementOrHTMLCollection::<D>::TryConvertToHTMLCollection(SafeJSContext::from_ptr(cx), value) {
7583 Err(_) => return Err(()),
7584 Ok(Some(value)) => return Ok(ConversionResult::Success(WindowProxyOrElementOrHTMLCollection::HTMLCollection(value))),
7585 Ok(None) => (),
7586 }
7587
7588 }
7589
7590 Ok(ConversionResult::Failure("argument could not be converted to any of: WindowProxy, Element, HTMLCollection".into()))
7591 }
7592}
7593
7594impl<D: DomTypes> WindowProxyOrElementOrHTMLCollection<D> {
7595 unsafe fn TryConvertToWindowProxy(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WindowProxy>>, ()> {
7596 Ok(Some(match windowproxy_from_handlevalue::<D>(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7597 Ok(val) => val,
7598 Err(()) => {
7599 return Ok(None);
7600 }
7601 }
7602 ))
7603 }
7604
7605 unsafe fn TryConvertToElement(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::Element>>, ()> {
7606 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7607 Ok(val) => val,
7608 Err(()) => {
7609 return Ok(None);
7610 }
7611 }
7612 ))
7613 }
7614
7615 unsafe fn TryConvertToHTMLCollection(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::HTMLCollection>>, ()> {
7616 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7617 Ok(val) => val,
7618 Err(()) => {
7619 return Ok(None);
7620 }
7621 }
7622 ))
7623 }
7624}
7625
7626
7627
7628#[derive(JSTraceable)]
7629pub enum WindowProxyOrMessagePortOrServiceWorker<D: DomTypes> {
7630 WindowProxy(DomRoot<D::WindowProxy>),
7631 MessagePort(DomRoot<D::MessagePort>),
7632 ServiceWorker(DomRoot<D::ServiceWorker>),
7633}
7634
7635impl<D: DomTypes> ToJSValConvertible for WindowProxyOrMessagePortOrServiceWorker<D> {
7636 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
7637 match *self {
7638 WindowProxyOrMessagePortOrServiceWorker::WindowProxy(ref inner) => inner.to_jsval(cx, rval),
7639 WindowProxyOrMessagePortOrServiceWorker::MessagePort(ref inner) => inner.to_jsval(cx, rval),
7640 WindowProxyOrMessagePortOrServiceWorker::ServiceWorker(ref inner) => inner.to_jsval(cx, rval),
7641 }
7642 }
7643}
7644
7645
7646
7647impl<D: DomTypes> FromJSValConvertible for WindowProxyOrMessagePortOrServiceWorker<D> {
7648 type Config = ();
7649 unsafe fn from_jsval(cx: *mut RawJSContext,
7650 value: HandleValue,
7651 _option: ())
7652 -> Result<ConversionResult<WindowProxyOrMessagePortOrServiceWorker<D>>, ()> {
7653 if value.get().is_object() {
7654 match WindowProxyOrMessagePortOrServiceWorker::<D>::TryConvertToWindowProxy(SafeJSContext::from_ptr(cx), value) {
7655 Err(_) => return Err(()),
7656 Ok(Some(value)) => return Ok(ConversionResult::Success(WindowProxyOrMessagePortOrServiceWorker::WindowProxy(value))),
7657 Ok(None) => (),
7658 }
7659 match WindowProxyOrMessagePortOrServiceWorker::<D>::TryConvertToMessagePort(SafeJSContext::from_ptr(cx), value) {
7660 Err(_) => return Err(()),
7661 Ok(Some(value)) => return Ok(ConversionResult::Success(WindowProxyOrMessagePortOrServiceWorker::MessagePort(value))),
7662 Ok(None) => (),
7663 }
7664 match WindowProxyOrMessagePortOrServiceWorker::<D>::TryConvertToServiceWorker(SafeJSContext::from_ptr(cx), value) {
7665 Err(_) => return Err(()),
7666 Ok(Some(value)) => return Ok(ConversionResult::Success(WindowProxyOrMessagePortOrServiceWorker::ServiceWorker(value))),
7667 Ok(None) => (),
7668 }
7669
7670 }
7671
7672 Ok(ConversionResult::Failure("argument could not be converted to any of: WindowProxy, MessagePort, ServiceWorker".into()))
7673 }
7674}
7675
7676impl<D: DomTypes> WindowProxyOrMessagePortOrServiceWorker<D> {
7677 unsafe fn TryConvertToWindowProxy(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::WindowProxy>>, ()> {
7678 Ok(Some(match windowproxy_from_handlevalue::<D>(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7679 Ok(val) => val,
7680 Err(()) => {
7681 return Ok(None);
7682 }
7683 }
7684 ))
7685 }
7686
7687 unsafe fn TryConvertToMessagePort(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::MessagePort>>, ()> {
7688 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7689 Ok(val) => val,
7690 Err(()) => {
7691 return Ok(None);
7692 }
7693 }
7694 ))
7695 }
7696
7697 unsafe fn TryConvertToServiceWorker(cx: SafeJSContext, value: HandleValue) -> Result<Option<DomRoot<D::ServiceWorker>>, ()> {
7698 Ok(Some(match root_from_handlevalue(value, SafeJSContext::from_ptr(cx.raw_cx())) {
7699 Ok(val) => val,
7700 Err(()) => {
7701 return Ok(None);
7702 }
7703 }
7704 ))
7705 }
7706}