1/*
2 * Copyright (C) 2013 Google Inc. All rights reserved.
3 * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
4 * Copyright (C) 2014 University of Washington. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
19 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
25 * THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28// DO NOT EDIT THIS FILE. It is automatically generated from CombinedDomains.json
29// by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py
30
31#pragma once
32
33#include "InspectorProtocolTypes.h"
34#include <wtf/Assertions.h>
35
36namespace Inspector {
37
38
39
40namespace Protocol {
41
42// Versions.
43namespace Audit {
44static const unsigned VERSION = 3;
45} // Audit
46
47namespace Recording {
48static const unsigned VERSION = 1;
49} // Recording
50// End of versions.
51
52
53// Forward declarations.
54namespace ApplicationCache {
55class ApplicationCacheResource;
56class ApplicationCache;
57class FrameWithManifest;
58} // ApplicationCache
59
60namespace CSS {
61class CSSStyleId;
62class CSSRuleId;
63class PseudoIdMatches;
64class InheritedStyleEntry;
65class RuleMatch;
66class CSSSelector;
67class SelectorList;
68class CSSStyleAttribute;
69class CSSStyleSheetHeader;
70class CSSStyleSheetBody;
71class CSSRule;
72class SourceRange;
73class ShorthandEntry;
74class CSSPropertyInfo;
75class CSSComputedStyleProperty;
76class CSSStyle;
77class CSSProperty;
78class CSSMedia;
79enum class StyleSheetOrigin;
80enum class PseudoId;
81enum class CSSPropertyStatus;
82} // CSS
83
84namespace Canvas {
85class ContextAttributes;
86class Canvas;
87enum class ContextType;
88enum class ShaderType;
89} // Canvas
90
91namespace Console {
92class Channel;
93class ConsoleMessage;
94class CallFrame;
95class StackTrace;
96enum class ChannelSource;
97enum class ChannelLevel;
98} // Console
99
100namespace DOM {
101class Node;
102class DataBinding;
103class EventListener;
104class AccessibilityProperties;
105class RGBAColor;
106class HighlightConfig;
107enum class PseudoType;
108enum class ShadowRootType;
109enum class CustomElementState;
110enum class LiveRegionRelevant;
111} // DOM
112
113namespace DOMDebugger {
114enum class DOMBreakpointType;
115enum class EventBreakpointType;
116} // DOMDebugger
117
118namespace DOMStorage {
119class StorageId;
120} // DOMStorage
121
122namespace Database {
123class Database;
124class Error;
125} // Database
126
127namespace Debugger {
128class Location;
129class BreakpointAction;
130class BreakpointOptions;
131class FunctionDetails;
132class CallFrame;
133class Scope;
134class ProbeSample;
135class AssertPauseReason;
136class BreakpointPauseReason;
137class CSPViolationPauseReason;
138} // Debugger
139
140namespace GenericTypes {
141class SearchMatch;
142} // GenericTypes
143
144namespace Heap {
145class GarbageCollection;
146} // Heap
147
148#if ENABLE(INDEXED_DATABASE)
149namespace IndexedDB {
150class DatabaseWithObjectStores;
151class ObjectStore;
152class ObjectStoreIndex;
153class Key;
154class KeyRange;
155class DataEntry;
156class KeyPath;
157} // IndexedDB
158#endif // ENABLE(INDEXED_DATABASE)
159
160namespace LayerTree {
161class IntRect;
162class Layer;
163class CompositingReasons;
164} // LayerTree
165
166namespace Network {
167class Headers;
168class ResourceTiming;
169class Request;
170class Response;
171class Metrics;
172class WebSocketRequest;
173class WebSocketResponse;
174class WebSocketFrame;
175class CachedResource;
176class Initiator;
177} // Network
178
179namespace Page {
180class Frame;
181class FrameResource;
182class FrameResourceTree;
183class SearchResult;
184class Cookie;
185enum class Setting;
186enum class ResourceType;
187enum class CoordinateSystem;
188enum class CookieSameSitePolicy;
189enum class Appearance;
190} // Page
191
192namespace Recording {
193class InitialState;
194class Frame;
195class Recording;
196enum class Type;
197enum class Initiator;
198} // Recording
199
200namespace Runtime {
201class RemoteObject;
202class ObjectPreview;
203class PropertyPreview;
204class EntryPreview;
205class CollectionEntry;
206class PropertyDescriptor;
207class InternalPropertyDescriptor;
208class CallArgument;
209class ExecutionContextDescription;
210class ErrorRange;
211class StructureDescription;
212class TypeSet;
213class TypeDescription;
214class TypeLocation;
215class BasicBlock;
216enum class SyntaxErrorType;
217} // Runtime
218
219namespace ScriptProfiler {
220class Event;
221class ExpressionLocation;
222class StackFrame;
223class StackTrace;
224class Samples;
225enum class EventType;
226} // ScriptProfiler
227
228namespace Security {
229class Connection;
230class Certificate;
231class Security;
232} // Security
233
234namespace Target {
235class TargetInfo;
236} // Target
237
238namespace Timeline {
239class TimelineEvent;
240enum class EventType;
241enum class Instrument;
242} // Timeline
243// End of forward declarations.
244
245
246// Typedefs.
247namespace CSS {
248typedef String StyleSheetId;
249} // CSS
250
251namespace Canvas {
252/* Unique canvas identifier. */
253typedef String CanvasId;
254/* Unique shader program identifier. */
255typedef String ProgramId;
256} // Canvas
257
258namespace DOM {
259/* Unique DOM node identifier. */
260typedef int NodeId;
261/* Unique event listener identifier. */
262typedef int EventListenerId;
263/* An array of quad vertices, x immediately followed by y for each point, points clock-wise. */
264typedef JSON::ArrayOf<double> Quad;
265} // DOM
266
267namespace DOMStorage {
268/* DOM Storage item. */
269typedef JSON::ArrayOf<String> Item;
270} // DOMStorage
271
272namespace Database {
273/* Unique identifier of Database object. */
274typedef String DatabaseId;
275} // Database
276
277namespace Debugger {
278/* Breakpoint identifier. */
279typedef String BreakpointId;
280/* Breakpoint action identifier. */
281typedef int BreakpointActionIdentifier;
282/* Unique script identifier. */
283typedef String ScriptId;
284/* Call frame identifier. */
285typedef String CallFrameId;
286} // Debugger
287
288namespace Heap {
289/* JavaScriptCore HeapSnapshot JSON data. */
290typedef String HeapSnapshotData;
291} // Heap
292
293namespace LayerTree {
294/* Unique RenderLayer identifier. */
295typedef String LayerId;
296/* Unique PseudoElement identifier. */
297typedef String PseudoElementId;
298} // LayerTree
299
300namespace Network {
301/* Unique loader identifier. */
302typedef String LoaderId;
303/* Unique frame identifier. */
304typedef String FrameId;
305/* Unique request identifier. */
306typedef String RequestId;
307/* Elapsed seconds since frontend connected. */
308typedef double Timestamp;
309/* Number of seconds since epoch. */
310typedef double Walltime;
311} // Network
312
313namespace Runtime {
314/* Unique object identifier. */
315typedef String RemoteObjectId;
316/* Id of an execution context. */
317typedef int ExecutionContextId;
318} // Runtime
319// End of typedefs.
320
321namespace InspectorHelpers {
322
323JS_EXPORT_PRIVATE String getEnumConstantValue(int code);
324
325template<typename T> String getEnumConstantValue(T enumValue)
326{
327 return getEnumConstantValue(static_cast<int>(enumValue));
328}
329
330} // namespace InspectorHelpers
331
332namespace ApplicationCache {
333/* Detailed application cache resource information. */
334class ApplicationCacheResource : public JSON::ObjectBase {
335public:
336 enum {
337 NoFieldsSet = 0,
338 UrlSet = 1 << 0,
339 SizeSet = 1 << 1,
340 TypeSet = 1 << 2,
341 AllFieldsSet = (UrlSet | SizeSet | TypeSet)
342 };
343
344 template<int STATE>
345 class Builder {
346 private:
347 RefPtr<JSON::Object> m_result;
348
349 template<int STEP> Builder<STATE | STEP>& castState()
350 {
351 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
352 }
353
354 Builder(Ref</*ApplicationCacheResource*/JSON::Object>&& object)
355 : m_result(WTFMove(object))
356 {
357 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
358 }
359 friend class ApplicationCacheResource;
360 public:
361
362 Builder<STATE | UrlSet>& setUrl(const String& value)
363 {
364 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
365 m_result->setString("url"_s, value);
366 return castState<UrlSet>();
367 }
368
369 Builder<STATE | SizeSet>& setSize(int value)
370 {
371 COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
372 m_result->setInteger("size"_s, value);
373 return castState<SizeSet>();
374 }
375
376 Builder<STATE | TypeSet>& setType(const String& value)
377 {
378 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
379 m_result->setString("type"_s, value);
380 return castState<TypeSet>();
381 }
382
383 Ref<ApplicationCacheResource> release()
384 {
385 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
386 COMPILE_ASSERT(sizeof(ApplicationCacheResource) == sizeof(JSON::Object), cannot_cast);
387
388 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
389 auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCacheResource>*>(&jsonResult));
390 return result;
391 }
392 };
393
394 /*
395 * Synthetic constructor:
396 * Ref<ApplicationCacheResource> result = ApplicationCacheResource::create()
397 * .setUrl(...)
398 * .setSize(...)
399 * .setType(...)
400 * .release();
401 */
402 static Builder<NoFieldsSet> create()
403 {
404 return Builder<NoFieldsSet>(JSON::Object::create());
405 }
406};
407
408/* Detailed application cache information. */
409class ApplicationCache : public JSON::ObjectBase {
410public:
411 enum {
412 NoFieldsSet = 0,
413 ManifestURLSet = 1 << 0,
414 SizeSet = 1 << 1,
415 CreationTimeSet = 1 << 2,
416 UpdateTimeSet = 1 << 3,
417 ResourcesSet = 1 << 4,
418 AllFieldsSet = (ManifestURLSet | SizeSet | CreationTimeSet | UpdateTimeSet | ResourcesSet)
419 };
420
421 template<int STATE>
422 class Builder {
423 private:
424 RefPtr<JSON::Object> m_result;
425
426 template<int STEP> Builder<STATE | STEP>& castState()
427 {
428 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
429 }
430
431 Builder(Ref</*ApplicationCache*/JSON::Object>&& object)
432 : m_result(WTFMove(object))
433 {
434 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
435 }
436 friend class ApplicationCache;
437 public:
438
439 Builder<STATE | ManifestURLSet>& setManifestURL(const String& value)
440 {
441 COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
442 m_result->setString("manifestURL"_s, value);
443 return castState<ManifestURLSet>();
444 }
445
446 Builder<STATE | SizeSet>& setSize(double value)
447 {
448 COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
449 m_result->setDouble("size"_s, value);
450 return castState<SizeSet>();
451 }
452
453 Builder<STATE | CreationTimeSet>& setCreationTime(double value)
454 {
455 COMPILE_ASSERT(!(STATE & CreationTimeSet), property_creationTime_already_set);
456 m_result->setDouble("creationTime"_s, value);
457 return castState<CreationTimeSet>();
458 }
459
460 Builder<STATE | UpdateTimeSet>& setUpdateTime(double value)
461 {
462 COMPILE_ASSERT(!(STATE & UpdateTimeSet), property_updateTime_already_set);
463 m_result->setDouble("updateTime"_s, value);
464 return castState<UpdateTimeSet>();
465 }
466
467 Builder<STATE | ResourcesSet>& setResources(RefPtr<JSON::ArrayOf<Inspector::Protocol::ApplicationCache::ApplicationCacheResource>> value)
468 {
469 COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
470 m_result->setArray("resources"_s, value);
471 return castState<ResourcesSet>();
472 }
473
474 Ref<ApplicationCache> release()
475 {
476 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
477 COMPILE_ASSERT(sizeof(ApplicationCache) == sizeof(JSON::Object), cannot_cast);
478
479 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
480 auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCache>*>(&jsonResult));
481 return result;
482 }
483 };
484
485 /*
486 * Synthetic constructor:
487 * Ref<ApplicationCache> result = ApplicationCache::create()
488 * .setManifestURL(...)
489 * .setSize(...)
490 * .setCreationTime(...)
491 * .setUpdateTime(...)
492 * .setResources(...)
493 * .release();
494 */
495 static Builder<NoFieldsSet> create()
496 {
497 return Builder<NoFieldsSet>(JSON::Object::create());
498 }
499};
500
501/* Frame identifier - manifest URL pair. */
502class FrameWithManifest : public JSON::ObjectBase {
503public:
504 enum {
505 NoFieldsSet = 0,
506 FrameIdSet = 1 << 0,
507 ManifestURLSet = 1 << 1,
508 StatusSet = 1 << 2,
509 AllFieldsSet = (FrameIdSet | ManifestURLSet | StatusSet)
510 };
511
512 template<int STATE>
513 class Builder {
514 private:
515 RefPtr<JSON::Object> m_result;
516
517 template<int STEP> Builder<STATE | STEP>& castState()
518 {
519 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
520 }
521
522 Builder(Ref</*FrameWithManifest*/JSON::Object>&& object)
523 : m_result(WTFMove(object))
524 {
525 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
526 }
527 friend class FrameWithManifest;
528 public:
529
530 Builder<STATE | FrameIdSet>& setFrameId(const String& value)
531 {
532 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
533 m_result->setString("frameId"_s, value);
534 return castState<FrameIdSet>();
535 }
536
537 Builder<STATE | ManifestURLSet>& setManifestURL(const String& value)
538 {
539 COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set);
540 m_result->setString("manifestURL"_s, value);
541 return castState<ManifestURLSet>();
542 }
543
544 Builder<STATE | StatusSet>& setStatus(int value)
545 {
546 COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
547 m_result->setInteger("status"_s, value);
548 return castState<StatusSet>();
549 }
550
551 Ref<FrameWithManifest> release()
552 {
553 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
554 COMPILE_ASSERT(sizeof(FrameWithManifest) == sizeof(JSON::Object), cannot_cast);
555
556 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
557 auto result = WTFMove(*reinterpret_cast<Ref<FrameWithManifest>*>(&jsonResult));
558 return result;
559 }
560 };
561
562 /*
563 * Synthetic constructor:
564 * Ref<FrameWithManifest> result = FrameWithManifest::create()
565 * .setFrameId(...)
566 * .setManifestURL(...)
567 * .setStatus(...)
568 * .release();
569 */
570 static Builder<NoFieldsSet> create()
571 {
572 return Builder<NoFieldsSet>(JSON::Object::create());
573 }
574};
575
576} // ApplicationCache
577
578namespace CSS {
579/* This object identifies a CSS style in a unique way. */
580class CSSStyleId : public JSON::ObjectBase {
581public:
582 enum {
583 NoFieldsSet = 0,
584 StyleSheetIdSet = 1 << 0,
585 OrdinalSet = 1 << 1,
586 AllFieldsSet = (StyleSheetIdSet | OrdinalSet)
587 };
588
589 template<int STATE>
590 class Builder {
591 private:
592 RefPtr<JSON::Object> m_result;
593
594 template<int STEP> Builder<STATE | STEP>& castState()
595 {
596 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
597 }
598
599 Builder(Ref</*CSSStyleId*/JSON::Object>&& object)
600 : m_result(WTFMove(object))
601 {
602 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
603 }
604 friend class CSSStyleId;
605 public:
606
607 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& value)
608 {
609 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
610 m_result->setString("styleSheetId"_s, value);
611 return castState<StyleSheetIdSet>();
612 }
613
614 Builder<STATE | OrdinalSet>& setOrdinal(int value)
615 {
616 COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
617 m_result->setInteger("ordinal"_s, value);
618 return castState<OrdinalSet>();
619 }
620
621 Ref<CSSStyleId> release()
622 {
623 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
624 COMPILE_ASSERT(sizeof(CSSStyleId) == sizeof(JSON::Object), cannot_cast);
625
626 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
627 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleId>*>(&jsonResult));
628 return result;
629 }
630 };
631
632 /*
633 * Synthetic constructor:
634 * Ref<CSSStyleId> result = CSSStyleId::create()
635 * .setStyleSheetId(...)
636 * .setOrdinal(...)
637 * .release();
638 */
639 static Builder<NoFieldsSet> create()
640 {
641 return Builder<NoFieldsSet>(JSON::Object::create());
642 }
643};
644
645/* Stylesheet type: "user" for user stylesheets, "user-agent" for user-agent stylesheets, "inspector" for stylesheets created by the inspector (i.e. those holding the "via inspector" rules), "regular" for regular stylesheets. */
646enum class StyleSheetOrigin {
647 User = 0,
648 UserAgent = 1,
649 Inspector = 2,
650 Regular = 3,
651}; // enum class StyleSheetOrigin
652/* This object identifies a CSS rule in a unique way. */
653class CSSRuleId : public JSON::ObjectBase {
654public:
655 enum {
656 NoFieldsSet = 0,
657 StyleSheetIdSet = 1 << 0,
658 OrdinalSet = 1 << 1,
659 AllFieldsSet = (StyleSheetIdSet | OrdinalSet)
660 };
661
662 template<int STATE>
663 class Builder {
664 private:
665 RefPtr<JSON::Object> m_result;
666
667 template<int STEP> Builder<STATE | STEP>& castState()
668 {
669 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
670 }
671
672 Builder(Ref</*CSSRuleId*/JSON::Object>&& object)
673 : m_result(WTFMove(object))
674 {
675 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
676 }
677 friend class CSSRuleId;
678 public:
679
680 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& value)
681 {
682 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
683 m_result->setString("styleSheetId"_s, value);
684 return castState<StyleSheetIdSet>();
685 }
686
687 Builder<STATE | OrdinalSet>& setOrdinal(int value)
688 {
689 COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set);
690 m_result->setInteger("ordinal"_s, value);
691 return castState<OrdinalSet>();
692 }
693
694 Ref<CSSRuleId> release()
695 {
696 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
697 COMPILE_ASSERT(sizeof(CSSRuleId) == sizeof(JSON::Object), cannot_cast);
698
699 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
700 auto result = WTFMove(*reinterpret_cast<Ref<CSSRuleId>*>(&jsonResult));
701 return result;
702 }
703 };
704
705 /*
706 * Synthetic constructor:
707 * Ref<CSSRuleId> result = CSSRuleId::create()
708 * .setStyleSheetId(...)
709 * .setOrdinal(...)
710 * .release();
711 */
712 static Builder<NoFieldsSet> create()
713 {
714 return Builder<NoFieldsSet>(JSON::Object::create());
715 }
716};
717
718/* Pseudo-style identifier (see <code>enum PseudoId</code> in <code>RenderStyleConstants.h</code>). */
719enum class PseudoId {
720 FirstLine = 4,
721 FirstLetter = 5,
722 Marker = 6,
723 Before = 7,
724 After = 8,
725 Selection = 9,
726 Scrollbar = 10,
727 ScrollbarThumb = 11,
728 ScrollbarButton = 12,
729 ScrollbarTrack = 13,
730 ScrollbarTrackPiece = 14,
731 ScrollbarCorner = 15,
732 Resizer = 16,
733}; // enum class PseudoId
734/* CSS rule collection for a single pseudo style. */
735class PseudoIdMatches : public JSON::ObjectBase {
736public:
737 enum {
738 NoFieldsSet = 0,
739 PseudoIdSet = 1 << 0,
740 MatchesSet = 1 << 1,
741 AllFieldsSet = (PseudoIdSet | MatchesSet)
742 };
743
744 template<int STATE>
745 class Builder {
746 private:
747 RefPtr<JSON::Object> m_result;
748
749 template<int STEP> Builder<STATE | STEP>& castState()
750 {
751 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
752 }
753
754 Builder(Ref</*PseudoIdMatches*/JSON::Object>&& object)
755 : m_result(WTFMove(object))
756 {
757 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
758 }
759 friend class PseudoIdMatches;
760 public:
761
762 Builder<STATE | PseudoIdSet>& setPseudoId(Inspector::Protocol::CSS::PseudoId value)
763 {
764 COMPILE_ASSERT(!(STATE & PseudoIdSet), property_pseudoId_already_set);
765 m_result->setString("pseudoId"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
766 return castState<PseudoIdSet>();
767 }
768
769 Builder<STATE | MatchesSet>& setMatches(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::RuleMatch>> value)
770 {
771 COMPILE_ASSERT(!(STATE & MatchesSet), property_matches_already_set);
772 m_result->setArray("matches"_s, value);
773 return castState<MatchesSet>();
774 }
775
776 Ref<PseudoIdMatches> release()
777 {
778 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
779 COMPILE_ASSERT(sizeof(PseudoIdMatches) == sizeof(JSON::Object), cannot_cast);
780
781 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
782 auto result = WTFMove(*reinterpret_cast<Ref<PseudoIdMatches>*>(&jsonResult));
783 return result;
784 }
785 };
786
787 /*
788 * Synthetic constructor:
789 * Ref<PseudoIdMatches> result = PseudoIdMatches::create()
790 * .setPseudoId(...)
791 * .setMatches(...)
792 * .release();
793 */
794 static Builder<NoFieldsSet> create()
795 {
796 return Builder<NoFieldsSet>(JSON::Object::create());
797 }
798};
799
800/* CSS rule collection for a single pseudo style. */
801class InheritedStyleEntry : public JSON::ObjectBase {
802public:
803 enum {
804 NoFieldsSet = 0,
805 MatchedCSSRulesSet = 1 << 0,
806 AllFieldsSet = (MatchedCSSRulesSet)
807 };
808
809 template<int STATE>
810 class Builder {
811 private:
812 RefPtr<JSON::Object> m_result;
813
814 template<int STEP> Builder<STATE | STEP>& castState()
815 {
816 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
817 }
818
819 Builder(Ref</*InheritedStyleEntry*/JSON::Object>&& object)
820 : m_result(WTFMove(object))
821 {
822 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
823 }
824 friend class InheritedStyleEntry;
825 public:
826
827 Builder<STATE | MatchedCSSRulesSet>& setMatchedCSSRules(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::RuleMatch>> value)
828 {
829 COMPILE_ASSERT(!(STATE & MatchedCSSRulesSet), property_matchedCSSRules_already_set);
830 m_result->setArray("matchedCSSRules"_s, value);
831 return castState<MatchedCSSRulesSet>();
832 }
833
834 Ref<InheritedStyleEntry> release()
835 {
836 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
837 COMPILE_ASSERT(sizeof(InheritedStyleEntry) == sizeof(JSON::Object), cannot_cast);
838
839 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
840 auto result = WTFMove(*reinterpret_cast<Ref<InheritedStyleEntry>*>(&jsonResult));
841 return result;
842 }
843 };
844
845 /*
846 * Synthetic constructor:
847 * Ref<InheritedStyleEntry> result = InheritedStyleEntry::create()
848 * .setMatchedCSSRules(...)
849 * .release();
850 */
851 static Builder<NoFieldsSet> create()
852 {
853 return Builder<NoFieldsSet>(JSON::Object::create());
854 }
855
856 void setInlineStyle(RefPtr<Inspector::Protocol::CSS::CSSStyle> value)
857 {
858 JSON::ObjectBase::setObject("inlineStyle"_s, WTFMove(value));
859 }
860};
861
862/* Match data for a CSS rule. */
863class RuleMatch : public JSON::ObjectBase {
864public:
865 enum {
866 NoFieldsSet = 0,
867 RuleSet = 1 << 0,
868 MatchingSelectorsSet = 1 << 1,
869 AllFieldsSet = (RuleSet | MatchingSelectorsSet)
870 };
871
872 template<int STATE>
873 class Builder {
874 private:
875 RefPtr<JSON::Object> m_result;
876
877 template<int STEP> Builder<STATE | STEP>& castState()
878 {
879 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
880 }
881
882 Builder(Ref</*RuleMatch*/JSON::Object>&& object)
883 : m_result(WTFMove(object))
884 {
885 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
886 }
887 friend class RuleMatch;
888 public:
889
890 Builder<STATE | RuleSet>& setRule(RefPtr<Inspector::Protocol::CSS::CSSRule> value)
891 {
892 COMPILE_ASSERT(!(STATE & RuleSet), property_rule_already_set);
893 m_result->setObject("rule"_s, value);
894 return castState<RuleSet>();
895 }
896
897 Builder<STATE | MatchingSelectorsSet>& setMatchingSelectors(RefPtr<JSON::ArrayOf<int>> value)
898 {
899 COMPILE_ASSERT(!(STATE & MatchingSelectorsSet), property_matchingSelectors_already_set);
900 m_result->setArray("matchingSelectors"_s, value);
901 return castState<MatchingSelectorsSet>();
902 }
903
904 Ref<RuleMatch> release()
905 {
906 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
907 COMPILE_ASSERT(sizeof(RuleMatch) == sizeof(JSON::Object), cannot_cast);
908
909 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
910 auto result = WTFMove(*reinterpret_cast<Ref<RuleMatch>*>(&jsonResult));
911 return result;
912 }
913 };
914
915 /*
916 * Synthetic constructor:
917 * Ref<RuleMatch> result = RuleMatch::create()
918 * .setRule(...)
919 * .setMatchingSelectors(...)
920 * .release();
921 */
922 static Builder<NoFieldsSet> create()
923 {
924 return Builder<NoFieldsSet>(JSON::Object::create());
925 }
926};
927
928/* CSS selector. */
929class CSSSelector : public JSON::ObjectBase {
930public:
931 enum {
932 NoFieldsSet = 0,
933 TextSet = 1 << 0,
934 AllFieldsSet = (TextSet)
935 };
936
937 template<int STATE>
938 class Builder {
939 private:
940 RefPtr<JSON::Object> m_result;
941
942 template<int STEP> Builder<STATE | STEP>& castState()
943 {
944 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
945 }
946
947 Builder(Ref</*CSSSelector*/JSON::Object>&& object)
948 : m_result(WTFMove(object))
949 {
950 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
951 }
952 friend class CSSSelector;
953 public:
954
955 Builder<STATE | TextSet>& setText(const String& value)
956 {
957 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
958 m_result->setString("text"_s, value);
959 return castState<TextSet>();
960 }
961
962 Ref<CSSSelector> release()
963 {
964 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
965 COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(JSON::Object), cannot_cast);
966
967 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
968 auto result = WTFMove(*reinterpret_cast<Ref<CSSSelector>*>(&jsonResult));
969 return result;
970 }
971 };
972
973 /*
974 * Synthetic constructor:
975 * Ref<CSSSelector> result = CSSSelector::create()
976 * .setText(...)
977 * .release();
978 */
979 static Builder<NoFieldsSet> create()
980 {
981 return Builder<NoFieldsSet>(JSON::Object::create());
982 }
983
984 void setSpecificity(RefPtr<JSON::ArrayOf<int>> value)
985 {
986 JSON::ObjectBase::setArray("specificity"_s, WTFMove(value));
987 }
988
989 void setDynamic(bool value)
990 {
991 JSON::ObjectBase::setBoolean("dynamic"_s, value);
992 }
993};
994
995/* Selector list data. */
996class SelectorList : public JSON::ObjectBase {
997public:
998 enum {
999 NoFieldsSet = 0,
1000 SelectorsSet = 1 << 0,
1001 TextSet = 1 << 1,
1002 AllFieldsSet = (SelectorsSet | TextSet)
1003 };
1004
1005 template<int STATE>
1006 class Builder {
1007 private:
1008 RefPtr<JSON::Object> m_result;
1009
1010 template<int STEP> Builder<STATE | STEP>& castState()
1011 {
1012 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1013 }
1014
1015 Builder(Ref</*SelectorList*/JSON::Object>&& object)
1016 : m_result(WTFMove(object))
1017 {
1018 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1019 }
1020 friend class SelectorList;
1021 public:
1022
1023 Builder<STATE | SelectorsSet>& setSelectors(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSSelector>> value)
1024 {
1025 COMPILE_ASSERT(!(STATE & SelectorsSet), property_selectors_already_set);
1026 m_result->setArray("selectors"_s, value);
1027 return castState<SelectorsSet>();
1028 }
1029
1030 Builder<STATE | TextSet>& setText(const String& value)
1031 {
1032 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1033 m_result->setString("text"_s, value);
1034 return castState<TextSet>();
1035 }
1036
1037 Ref<SelectorList> release()
1038 {
1039 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1040 COMPILE_ASSERT(sizeof(SelectorList) == sizeof(JSON::Object), cannot_cast);
1041
1042 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1043 auto result = WTFMove(*reinterpret_cast<Ref<SelectorList>*>(&jsonResult));
1044 return result;
1045 }
1046 };
1047
1048 /*
1049 * Synthetic constructor:
1050 * Ref<SelectorList> result = SelectorList::create()
1051 * .setSelectors(...)
1052 * .setText(...)
1053 * .release();
1054 */
1055 static Builder<NoFieldsSet> create()
1056 {
1057 return Builder<NoFieldsSet>(JSON::Object::create());
1058 }
1059
1060 void setRange(RefPtr<Inspector::Protocol::CSS::SourceRange> value)
1061 {
1062 JSON::ObjectBase::setObject("range"_s, WTFMove(value));
1063 }
1064};
1065
1066/* CSS style information for a DOM style attribute. */
1067class CSSStyleAttribute : public JSON::ObjectBase {
1068public:
1069 enum {
1070 NoFieldsSet = 0,
1071 NameSet = 1 << 0,
1072 StyleSet = 1 << 1,
1073 AllFieldsSet = (NameSet | StyleSet)
1074 };
1075
1076 template<int STATE>
1077 class Builder {
1078 private:
1079 RefPtr<JSON::Object> m_result;
1080
1081 template<int STEP> Builder<STATE | STEP>& castState()
1082 {
1083 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1084 }
1085
1086 Builder(Ref</*CSSStyleAttribute*/JSON::Object>&& object)
1087 : m_result(WTFMove(object))
1088 {
1089 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1090 }
1091 friend class CSSStyleAttribute;
1092 public:
1093
1094 Builder<STATE | NameSet>& setName(const String& value)
1095 {
1096 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1097 m_result->setString("name"_s, value);
1098 return castState<NameSet>();
1099 }
1100
1101 Builder<STATE | StyleSet>& setStyle(RefPtr<Inspector::Protocol::CSS::CSSStyle> value)
1102 {
1103 COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
1104 m_result->setObject("style"_s, value);
1105 return castState<StyleSet>();
1106 }
1107
1108 Ref<CSSStyleAttribute> release()
1109 {
1110 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1111 COMPILE_ASSERT(sizeof(CSSStyleAttribute) == sizeof(JSON::Object), cannot_cast);
1112
1113 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1114 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleAttribute>*>(&jsonResult));
1115 return result;
1116 }
1117 };
1118
1119 /*
1120 * Synthetic constructor:
1121 * Ref<CSSStyleAttribute> result = CSSStyleAttribute::create()
1122 * .setName(...)
1123 * .setStyle(...)
1124 * .release();
1125 */
1126 static Builder<NoFieldsSet> create()
1127 {
1128 return Builder<NoFieldsSet>(JSON::Object::create());
1129 }
1130};
1131
1132/* CSS stylesheet meta-information. */
1133class CSSStyleSheetHeader : public JSON::ObjectBase {
1134public:
1135 enum {
1136 NoFieldsSet = 0,
1137 StyleSheetIdSet = 1 << 0,
1138 FrameIdSet = 1 << 1,
1139 SourceURLSet = 1 << 2,
1140 OriginSet = 1 << 3,
1141 TitleSet = 1 << 4,
1142 DisabledSet = 1 << 5,
1143 IsInlineSet = 1 << 6,
1144 StartLineSet = 1 << 7,
1145 StartColumnSet = 1 << 8,
1146 AllFieldsSet = (StyleSheetIdSet | FrameIdSet | SourceURLSet | OriginSet | TitleSet | DisabledSet | IsInlineSet | StartLineSet | StartColumnSet)
1147 };
1148
1149 template<int STATE>
1150 class Builder {
1151 private:
1152 RefPtr<JSON::Object> m_result;
1153
1154 template<int STEP> Builder<STATE | STEP>& castState()
1155 {
1156 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1157 }
1158
1159 Builder(Ref</*CSSStyleSheetHeader*/JSON::Object>&& object)
1160 : m_result(WTFMove(object))
1161 {
1162 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1163 }
1164 friend class CSSStyleSheetHeader;
1165 public:
1166
1167 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& value)
1168 {
1169 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1170 m_result->setString("styleSheetId"_s, value);
1171 return castState<StyleSheetIdSet>();
1172 }
1173
1174 Builder<STATE | FrameIdSet>& setFrameId(const String& value)
1175 {
1176 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
1177 m_result->setString("frameId"_s, value);
1178 return castState<FrameIdSet>();
1179 }
1180
1181 Builder<STATE | SourceURLSet>& setSourceURL(const String& value)
1182 {
1183 COMPILE_ASSERT(!(STATE & SourceURLSet), property_sourceURL_already_set);
1184 m_result->setString("sourceURL"_s, value);
1185 return castState<SourceURLSet>();
1186 }
1187
1188 Builder<STATE | OriginSet>& setOrigin(Inspector::Protocol::CSS::StyleSheetOrigin value)
1189 {
1190 COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
1191 m_result->setString("origin"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
1192 return castState<OriginSet>();
1193 }
1194
1195 Builder<STATE | TitleSet>& setTitle(const String& value)
1196 {
1197 COMPILE_ASSERT(!(STATE & TitleSet), property_title_already_set);
1198 m_result->setString("title"_s, value);
1199 return castState<TitleSet>();
1200 }
1201
1202 Builder<STATE | DisabledSet>& setDisabled(bool value)
1203 {
1204 COMPILE_ASSERT(!(STATE & DisabledSet), property_disabled_already_set);
1205 m_result->setBoolean("disabled"_s, value);
1206 return castState<DisabledSet>();
1207 }
1208
1209 Builder<STATE | IsInlineSet>& setIsInline(bool value)
1210 {
1211 COMPILE_ASSERT(!(STATE & IsInlineSet), property_isInline_already_set);
1212 m_result->setBoolean("isInline"_s, value);
1213 return castState<IsInlineSet>();
1214 }
1215
1216 Builder<STATE | StartLineSet>& setStartLine(double value)
1217 {
1218 COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
1219 m_result->setDouble("startLine"_s, value);
1220 return castState<StartLineSet>();
1221 }
1222
1223 Builder<STATE | StartColumnSet>& setStartColumn(double value)
1224 {
1225 COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
1226 m_result->setDouble("startColumn"_s, value);
1227 return castState<StartColumnSet>();
1228 }
1229
1230 Ref<CSSStyleSheetHeader> release()
1231 {
1232 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1233 COMPILE_ASSERT(sizeof(CSSStyleSheetHeader) == sizeof(JSON::Object), cannot_cast);
1234
1235 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1236 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetHeader>*>(&jsonResult));
1237 return result;
1238 }
1239 };
1240
1241 /*
1242 * Synthetic constructor:
1243 * Ref<CSSStyleSheetHeader> result = CSSStyleSheetHeader::create()
1244 * .setStyleSheetId(...)
1245 * .setFrameId(...)
1246 * .setSourceURL(...)
1247 * .setOrigin(...)
1248 * .setTitle(...)
1249 * .setDisabled(...)
1250 * .setIsInline(...)
1251 * .setStartLine(...)
1252 * .setStartColumn(...)
1253 * .release();
1254 */
1255 static Builder<NoFieldsSet> create()
1256 {
1257 return Builder<NoFieldsSet>(JSON::Object::create());
1258 }
1259};
1260
1261/* CSS stylesheet contents. */
1262class CSSStyleSheetBody : public JSON::ObjectBase {
1263public:
1264 enum {
1265 NoFieldsSet = 0,
1266 StyleSheetIdSet = 1 << 0,
1267 RulesSet = 1 << 1,
1268 AllFieldsSet = (StyleSheetIdSet | RulesSet)
1269 };
1270
1271 template<int STATE>
1272 class Builder {
1273 private:
1274 RefPtr<JSON::Object> m_result;
1275
1276 template<int STEP> Builder<STATE | STEP>& castState()
1277 {
1278 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1279 }
1280
1281 Builder(Ref</*CSSStyleSheetBody*/JSON::Object>&& object)
1282 : m_result(WTFMove(object))
1283 {
1284 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1285 }
1286 friend class CSSStyleSheetBody;
1287 public:
1288
1289 Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& value)
1290 {
1291 COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set);
1292 m_result->setString("styleSheetId"_s, value);
1293 return castState<StyleSheetIdSet>();
1294 }
1295
1296 Builder<STATE | RulesSet>& setRules(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSRule>> value)
1297 {
1298 COMPILE_ASSERT(!(STATE & RulesSet), property_rules_already_set);
1299 m_result->setArray("rules"_s, value);
1300 return castState<RulesSet>();
1301 }
1302
1303 Ref<CSSStyleSheetBody> release()
1304 {
1305 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1306 COMPILE_ASSERT(sizeof(CSSStyleSheetBody) == sizeof(JSON::Object), cannot_cast);
1307
1308 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1309 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetBody>*>(&jsonResult));
1310 return result;
1311 }
1312 };
1313
1314 /*
1315 * Synthetic constructor:
1316 * Ref<CSSStyleSheetBody> result = CSSStyleSheetBody::create()
1317 * .setStyleSheetId(...)
1318 * .setRules(...)
1319 * .release();
1320 */
1321 static Builder<NoFieldsSet> create()
1322 {
1323 return Builder<NoFieldsSet>(JSON::Object::create());
1324 }
1325
1326 void setText(const String& value)
1327 {
1328 JSON::ObjectBase::setString("text"_s, value);
1329 }
1330};
1331
1332/* CSS rule representation. */
1333class CSSRule : public JSON::ObjectBase {
1334public:
1335 enum {
1336 NoFieldsSet = 0,
1337 SelectorListSet = 1 << 0,
1338 SourceLineSet = 1 << 1,
1339 OriginSet = 1 << 2,
1340 StyleSet = 1 << 3,
1341 AllFieldsSet = (SelectorListSet | SourceLineSet | OriginSet | StyleSet)
1342 };
1343
1344 template<int STATE>
1345 class Builder {
1346 private:
1347 RefPtr<JSON::Object> m_result;
1348
1349 template<int STEP> Builder<STATE | STEP>& castState()
1350 {
1351 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1352 }
1353
1354 Builder(Ref</*CSSRule*/JSON::Object>&& object)
1355 : m_result(WTFMove(object))
1356 {
1357 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1358 }
1359 friend class CSSRule;
1360 public:
1361
1362 Builder<STATE | SelectorListSet>& setSelectorList(RefPtr<Inspector::Protocol::CSS::SelectorList> value)
1363 {
1364 COMPILE_ASSERT(!(STATE & SelectorListSet), property_selectorList_already_set);
1365 m_result->setObject("selectorList"_s, value);
1366 return castState<SelectorListSet>();
1367 }
1368
1369 Builder<STATE | SourceLineSet>& setSourceLine(int value)
1370 {
1371 COMPILE_ASSERT(!(STATE & SourceLineSet), property_sourceLine_already_set);
1372 m_result->setInteger("sourceLine"_s, value);
1373 return castState<SourceLineSet>();
1374 }
1375
1376 Builder<STATE | OriginSet>& setOrigin(Inspector::Protocol::CSS::StyleSheetOrigin value)
1377 {
1378 COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set);
1379 m_result->setString("origin"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
1380 return castState<OriginSet>();
1381 }
1382
1383 Builder<STATE | StyleSet>& setStyle(RefPtr<Inspector::Protocol::CSS::CSSStyle> value)
1384 {
1385 COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set);
1386 m_result->setObject("style"_s, value);
1387 return castState<StyleSet>();
1388 }
1389
1390 Ref<CSSRule> release()
1391 {
1392 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1393 COMPILE_ASSERT(sizeof(CSSRule) == sizeof(JSON::Object), cannot_cast);
1394
1395 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1396 auto result = WTFMove(*reinterpret_cast<Ref<CSSRule>*>(&jsonResult));
1397 return result;
1398 }
1399 };
1400
1401 /*
1402 * Synthetic constructor:
1403 * Ref<CSSRule> result = CSSRule::create()
1404 * .setSelectorList(...)
1405 * .setSourceLine(...)
1406 * .setOrigin(...)
1407 * .setStyle(...)
1408 * .release();
1409 */
1410 static Builder<NoFieldsSet> create()
1411 {
1412 return Builder<NoFieldsSet>(JSON::Object::create());
1413 }
1414
1415 void setRuleId(RefPtr<Inspector::Protocol::CSS::CSSRuleId> value)
1416 {
1417 JSON::ObjectBase::setObject("ruleId"_s, WTFMove(value));
1418 }
1419
1420 void setSourceURL(const String& value)
1421 {
1422 JSON::ObjectBase::setString("sourceURL"_s, value);
1423 }
1424
1425 void setMedia(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSMedia>> value)
1426 {
1427 JSON::ObjectBase::setArray("media"_s, WTFMove(value));
1428 }
1429};
1430
1431/* Text range within a resource. */
1432class SourceRange : public JSON::ObjectBase {
1433public:
1434 enum {
1435 NoFieldsSet = 0,
1436 StartLineSet = 1 << 0,
1437 StartColumnSet = 1 << 1,
1438 EndLineSet = 1 << 2,
1439 EndColumnSet = 1 << 3,
1440 AllFieldsSet = (StartLineSet | StartColumnSet | EndLineSet | EndColumnSet)
1441 };
1442
1443 template<int STATE>
1444 class Builder {
1445 private:
1446 RefPtr<JSON::Object> m_result;
1447
1448 template<int STEP> Builder<STATE | STEP>& castState()
1449 {
1450 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1451 }
1452
1453 Builder(Ref</*SourceRange*/JSON::Object>&& object)
1454 : m_result(WTFMove(object))
1455 {
1456 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1457 }
1458 friend class SourceRange;
1459 public:
1460
1461 Builder<STATE | StartLineSet>& setStartLine(int value)
1462 {
1463 COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set);
1464 m_result->setInteger("startLine"_s, value);
1465 return castState<StartLineSet>();
1466 }
1467
1468 Builder<STATE | StartColumnSet>& setStartColumn(int value)
1469 {
1470 COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set);
1471 m_result->setInteger("startColumn"_s, value);
1472 return castState<StartColumnSet>();
1473 }
1474
1475 Builder<STATE | EndLineSet>& setEndLine(int value)
1476 {
1477 COMPILE_ASSERT(!(STATE & EndLineSet), property_endLine_already_set);
1478 m_result->setInteger("endLine"_s, value);
1479 return castState<EndLineSet>();
1480 }
1481
1482 Builder<STATE | EndColumnSet>& setEndColumn(int value)
1483 {
1484 COMPILE_ASSERT(!(STATE & EndColumnSet), property_endColumn_already_set);
1485 m_result->setInteger("endColumn"_s, value);
1486 return castState<EndColumnSet>();
1487 }
1488
1489 Ref<SourceRange> release()
1490 {
1491 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1492 COMPILE_ASSERT(sizeof(SourceRange) == sizeof(JSON::Object), cannot_cast);
1493
1494 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1495 auto result = WTFMove(*reinterpret_cast<Ref<SourceRange>*>(&jsonResult));
1496 return result;
1497 }
1498 };
1499
1500 /*
1501 * Synthetic constructor:
1502 * Ref<SourceRange> result = SourceRange::create()
1503 * .setStartLine(...)
1504 * .setStartColumn(...)
1505 * .setEndLine(...)
1506 * .setEndColumn(...)
1507 * .release();
1508 */
1509 static Builder<NoFieldsSet> create()
1510 {
1511 return Builder<NoFieldsSet>(JSON::Object::create());
1512 }
1513};
1514
1515class ShorthandEntry : public JSON::ObjectBase {
1516public:
1517 enum {
1518 NoFieldsSet = 0,
1519 NameSet = 1 << 0,
1520 ValueSet = 1 << 1,
1521 AllFieldsSet = (NameSet | ValueSet)
1522 };
1523
1524 template<int STATE>
1525 class Builder {
1526 private:
1527 RefPtr<JSON::Object> m_result;
1528
1529 template<int STEP> Builder<STATE | STEP>& castState()
1530 {
1531 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1532 }
1533
1534 Builder(Ref</*ShorthandEntry*/JSON::Object>&& object)
1535 : m_result(WTFMove(object))
1536 {
1537 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1538 }
1539 friend class ShorthandEntry;
1540 public:
1541
1542 Builder<STATE | NameSet>& setName(const String& value)
1543 {
1544 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1545 m_result->setString("name"_s, value);
1546 return castState<NameSet>();
1547 }
1548
1549 Builder<STATE | ValueSet>& setValue(const String& value)
1550 {
1551 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
1552 m_result->setString("value"_s, value);
1553 return castState<ValueSet>();
1554 }
1555
1556 Ref<ShorthandEntry> release()
1557 {
1558 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1559 COMPILE_ASSERT(sizeof(ShorthandEntry) == sizeof(JSON::Object), cannot_cast);
1560
1561 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1562 auto result = WTFMove(*reinterpret_cast<Ref<ShorthandEntry>*>(&jsonResult));
1563 return result;
1564 }
1565 };
1566
1567 /*
1568 * Synthetic constructor:
1569 * Ref<ShorthandEntry> result = ShorthandEntry::create()
1570 * .setName(...)
1571 * .setValue(...)
1572 * .release();
1573 */
1574 static Builder<NoFieldsSet> create()
1575 {
1576 return Builder<NoFieldsSet>(JSON::Object::create());
1577 }
1578};
1579
1580class CSSPropertyInfo : public JSON::ObjectBase {
1581public:
1582 enum {
1583 NoFieldsSet = 0,
1584 NameSet = 1 << 0,
1585 AllFieldsSet = (NameSet)
1586 };
1587
1588 template<int STATE>
1589 class Builder {
1590 private:
1591 RefPtr<JSON::Object> m_result;
1592
1593 template<int STEP> Builder<STATE | STEP>& castState()
1594 {
1595 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1596 }
1597
1598 Builder(Ref</*CSSPropertyInfo*/JSON::Object>&& object)
1599 : m_result(WTFMove(object))
1600 {
1601 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1602 }
1603 friend class CSSPropertyInfo;
1604 public:
1605
1606 Builder<STATE | NameSet>& setName(const String& value)
1607 {
1608 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1609 m_result->setString("name"_s, value);
1610 return castState<NameSet>();
1611 }
1612
1613 Ref<CSSPropertyInfo> release()
1614 {
1615 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1616 COMPILE_ASSERT(sizeof(CSSPropertyInfo) == sizeof(JSON::Object), cannot_cast);
1617
1618 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1619 auto result = WTFMove(*reinterpret_cast<Ref<CSSPropertyInfo>*>(&jsonResult));
1620 return result;
1621 }
1622 };
1623
1624 /*
1625 * Synthetic constructor:
1626 * Ref<CSSPropertyInfo> result = CSSPropertyInfo::create()
1627 * .setName(...)
1628 * .release();
1629 */
1630 static Builder<NoFieldsSet> create()
1631 {
1632 return Builder<NoFieldsSet>(JSON::Object::create());
1633 }
1634
1635 void setAliases(RefPtr<JSON::ArrayOf<String>> value)
1636 {
1637 JSON::ObjectBase::setArray("aliases"_s, WTFMove(value));
1638 }
1639
1640 void setLonghands(RefPtr<JSON::ArrayOf<String>> value)
1641 {
1642 JSON::ObjectBase::setArray("longhands"_s, WTFMove(value));
1643 }
1644
1645 void setValues(RefPtr<JSON::ArrayOf<String>> value)
1646 {
1647 JSON::ObjectBase::setArray("values"_s, WTFMove(value));
1648 }
1649
1650 void setInherited(bool value)
1651 {
1652 JSON::ObjectBase::setBoolean("inherited"_s, value);
1653 }
1654};
1655
1656class CSSComputedStyleProperty : public JSON::ObjectBase {
1657public:
1658 enum {
1659 NoFieldsSet = 0,
1660 NameSet = 1 << 0,
1661 ValueSet = 1 << 1,
1662 AllFieldsSet = (NameSet | ValueSet)
1663 };
1664
1665 template<int STATE>
1666 class Builder {
1667 private:
1668 RefPtr<JSON::Object> m_result;
1669
1670 template<int STEP> Builder<STATE | STEP>& castState()
1671 {
1672 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1673 }
1674
1675 Builder(Ref</*CSSComputedStyleProperty*/JSON::Object>&& object)
1676 : m_result(WTFMove(object))
1677 {
1678 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1679 }
1680 friend class CSSComputedStyleProperty;
1681 public:
1682
1683 Builder<STATE | NameSet>& setName(const String& value)
1684 {
1685 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1686 m_result->setString("name"_s, value);
1687 return castState<NameSet>();
1688 }
1689
1690 Builder<STATE | ValueSet>& setValue(const String& value)
1691 {
1692 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
1693 m_result->setString("value"_s, value);
1694 return castState<ValueSet>();
1695 }
1696
1697 Ref<CSSComputedStyleProperty> release()
1698 {
1699 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1700 COMPILE_ASSERT(sizeof(CSSComputedStyleProperty) == sizeof(JSON::Object), cannot_cast);
1701
1702 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1703 auto result = WTFMove(*reinterpret_cast<Ref<CSSComputedStyleProperty>*>(&jsonResult));
1704 return result;
1705 }
1706 };
1707
1708 /*
1709 * Synthetic constructor:
1710 * Ref<CSSComputedStyleProperty> result = CSSComputedStyleProperty::create()
1711 * .setName(...)
1712 * .setValue(...)
1713 * .release();
1714 */
1715 static Builder<NoFieldsSet> create()
1716 {
1717 return Builder<NoFieldsSet>(JSON::Object::create());
1718 }
1719};
1720
1721/* CSS style representation. */
1722class CSSStyle : public JSON::ObjectBase {
1723public:
1724 enum {
1725 NoFieldsSet = 0,
1726 CssPropertiesSet = 1 << 0,
1727 ShorthandEntriesSet = 1 << 1,
1728 AllFieldsSet = (CssPropertiesSet | ShorthandEntriesSet)
1729 };
1730
1731 template<int STATE>
1732 class Builder {
1733 private:
1734 RefPtr<JSON::Object> m_result;
1735
1736 template<int STEP> Builder<STATE | STEP>& castState()
1737 {
1738 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1739 }
1740
1741 Builder(Ref</*CSSStyle*/JSON::Object>&& object)
1742 : m_result(WTFMove(object))
1743 {
1744 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1745 }
1746 friend class CSSStyle;
1747 public:
1748
1749 Builder<STATE | CssPropertiesSet>& setCssProperties(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::CSSProperty>> value)
1750 {
1751 COMPILE_ASSERT(!(STATE & CssPropertiesSet), property_cssProperties_already_set);
1752 m_result->setArray("cssProperties"_s, value);
1753 return castState<CssPropertiesSet>();
1754 }
1755
1756 Builder<STATE | ShorthandEntriesSet>& setShorthandEntries(RefPtr<JSON::ArrayOf<Inspector::Protocol::CSS::ShorthandEntry>> value)
1757 {
1758 COMPILE_ASSERT(!(STATE & ShorthandEntriesSet), property_shorthandEntries_already_set);
1759 m_result->setArray("shorthandEntries"_s, value);
1760 return castState<ShorthandEntriesSet>();
1761 }
1762
1763 Ref<CSSStyle> release()
1764 {
1765 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1766 COMPILE_ASSERT(sizeof(CSSStyle) == sizeof(JSON::Object), cannot_cast);
1767
1768 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1769 auto result = WTFMove(*reinterpret_cast<Ref<CSSStyle>*>(&jsonResult));
1770 return result;
1771 }
1772 };
1773
1774 /*
1775 * Synthetic constructor:
1776 * Ref<CSSStyle> result = CSSStyle::create()
1777 * .setCssProperties(...)
1778 * .setShorthandEntries(...)
1779 * .release();
1780 */
1781 static Builder<NoFieldsSet> create()
1782 {
1783 return Builder<NoFieldsSet>(JSON::Object::create());
1784 }
1785
1786 void setStyleId(RefPtr<Inspector::Protocol::CSS::CSSStyleId> value)
1787 {
1788 JSON::ObjectBase::setObject("styleId"_s, WTFMove(value));
1789 }
1790
1791 void setCssText(const String& value)
1792 {
1793 JSON::ObjectBase::setString("cssText"_s, value);
1794 }
1795
1796 void setRange(RefPtr<Inspector::Protocol::CSS::SourceRange> value)
1797 {
1798 JSON::ObjectBase::setObject("range"_s, WTFMove(value));
1799 }
1800
1801 void setWidth(const String& value)
1802 {
1803 JSON::ObjectBase::setString("width"_s, value);
1804 }
1805
1806 void setHeight(const String& value)
1807 {
1808 JSON::ObjectBase::setString("height"_s, value);
1809 }
1810};
1811
1812/* The property status: "active" if the property is effective in the style, "inactive" if the property is overridden by a same-named property in this style later on, "disabled" if the property is disabled by the user, "style" (implied if absent) if the property is reported by the browser rather than by the CSS source parser. */
1813enum class CSSPropertyStatus {
1814 Active = 17,
1815 Inactive = 18,
1816 Disabled = 19,
1817 Style = 20,
1818}; // enum class CSSPropertyStatus
1819/* CSS style effective visual dimensions and source offsets. */
1820class CSSProperty : public JSON::Object {
1821public:
1822 enum {
1823 NoFieldsSet = 0,
1824 NameSet = 1 << 0,
1825 ValueSet = 1 << 1,
1826 AllFieldsSet = (NameSet | ValueSet)
1827 };
1828
1829 template<int STATE>
1830 class Builder {
1831 private:
1832 RefPtr<JSON::Object> m_result;
1833
1834 template<int STEP> Builder<STATE | STEP>& castState()
1835 {
1836 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1837 }
1838
1839 Builder(Ref</*CSSProperty*/JSON::Object>&& object)
1840 : m_result(WTFMove(object))
1841 {
1842 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1843 }
1844 friend class CSSProperty;
1845 public:
1846
1847 Builder<STATE | NameSet>& setName(const String& value)
1848 {
1849 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
1850 m_result->setString("name"_s, value);
1851 return castState<NameSet>();
1852 }
1853
1854 Builder<STATE | ValueSet>& setValue(const String& value)
1855 {
1856 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
1857 m_result->setString("value"_s, value);
1858 return castState<ValueSet>();
1859 }
1860
1861 Ref<CSSProperty> release()
1862 {
1863 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1864 COMPILE_ASSERT(sizeof(CSSProperty) == sizeof(JSON::Object), cannot_cast);
1865
1866 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1867 auto result = WTFMove(*reinterpret_cast<Ref<CSSProperty>*>(&jsonResult));
1868 return result;
1869 }
1870 };
1871
1872 /*
1873 * Synthetic constructor:
1874 * Ref<CSSProperty> result = CSSProperty::create()
1875 * .setName(...)
1876 * .setValue(...)
1877 * .release();
1878 */
1879 static Builder<NoFieldsSet> create()
1880 {
1881 return Builder<NoFieldsSet>(JSON::Object::create());
1882 }
1883
1884 void setPriority(const String& value)
1885 {
1886 JSON::ObjectBase::setString("priority"_s, value);
1887 }
1888
1889 void setImplicit(bool value)
1890 {
1891 JSON::ObjectBase::setBoolean("implicit"_s, value);
1892 }
1893
1894 void setText(const String& value)
1895 {
1896 JSON::ObjectBase::setString("text"_s, value);
1897 }
1898
1899 void setParsedOk(bool value)
1900 {
1901 JSON::ObjectBase::setBoolean("parsedOk"_s, value);
1902 }
1903
1904 void setStatus(Inspector::Protocol::CSS::CSSPropertyStatus value)
1905 {
1906 JSON::ObjectBase::setString("status"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
1907 }
1908
1909 void setRange(RefPtr<Inspector::Protocol::CSS::SourceRange> value)
1910 {
1911 JSON::ObjectBase::setObject("range"_s, WTFMove(value));
1912 }
1913
1914 // Property names for type generated as open.
1915 JS_EXPORT_PRIVATE static const char* Name;
1916 JS_EXPORT_PRIVATE static const char* Value;
1917 JS_EXPORT_PRIVATE static const char* Priority;
1918 JS_EXPORT_PRIVATE static const char* Implicit;
1919 JS_EXPORT_PRIVATE static const char* Text;
1920 JS_EXPORT_PRIVATE static const char* ParsedOk;
1921 JS_EXPORT_PRIVATE static const char* Status;
1922 JS_EXPORT_PRIVATE static const char* Range;
1923};
1924
1925/* CSS media query descriptor. */
1926class CSSMedia : public JSON::ObjectBase {
1927public:
1928 // Named after property name 'source' while generating CSSMedia.
1929 enum class Source {
1930 MediaRule = 21,
1931 ImportRule = 22,
1932 LinkedSheet = 23,
1933 InlineSheet = 24,
1934 }; // enum class Source
1935 enum {
1936 NoFieldsSet = 0,
1937 TextSet = 1 << 0,
1938 SourceSet = 1 << 1,
1939 AllFieldsSet = (TextSet | SourceSet)
1940 };
1941
1942 template<int STATE>
1943 class Builder {
1944 private:
1945 RefPtr<JSON::Object> m_result;
1946
1947 template<int STEP> Builder<STATE | STEP>& castState()
1948 {
1949 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
1950 }
1951
1952 Builder(Ref</*CSSMedia*/JSON::Object>&& object)
1953 : m_result(WTFMove(object))
1954 {
1955 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
1956 }
1957 friend class CSSMedia;
1958 public:
1959
1960 Builder<STATE | TextSet>& setText(const String& value)
1961 {
1962 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
1963 m_result->setString("text"_s, value);
1964 return castState<TextSet>();
1965 }
1966
1967 Builder<STATE | SourceSet>& setSource(Source value)
1968 {
1969 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
1970 m_result->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
1971 return castState<SourceSet>();
1972 }
1973
1974 Ref<CSSMedia> release()
1975 {
1976 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
1977 COMPILE_ASSERT(sizeof(CSSMedia) == sizeof(JSON::Object), cannot_cast);
1978
1979 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
1980 auto result = WTFMove(*reinterpret_cast<Ref<CSSMedia>*>(&jsonResult));
1981 return result;
1982 }
1983 };
1984
1985 /*
1986 * Synthetic constructor:
1987 * Ref<CSSMedia> result = CSSMedia::create()
1988 * .setText(...)
1989 * .setSource(...)
1990 * .release();
1991 */
1992 static Builder<NoFieldsSet> create()
1993 {
1994 return Builder<NoFieldsSet>(JSON::Object::create());
1995 }
1996
1997 void setSourceURL(const String& value)
1998 {
1999 JSON::ObjectBase::setString("sourceURL"_s, value);
2000 }
2001
2002 void setSourceLine(int value)
2003 {
2004 JSON::ObjectBase::setInteger("sourceLine"_s, value);
2005 }
2006};
2007
2008} // CSS
2009
2010namespace Canvas {
2011/* The type of rendering context backing the canvas element. */
2012enum class ContextType {
2013 Canvas2D = 25,
2014 BitmapRenderer = 26,
2015 WebGL = 27,
2016 WebGL2 = 28,
2017 WebGPU = 29,
2018}; // enum class ContextType
2019/* Shader type. WebGL supports vertex and fragment shaders. */
2020enum class ShaderType {
2021 Fragment = 30,
2022 Vertex = 31,
2023}; // enum class ShaderType
2024/* Drawing surface attributes. */
2025class ContextAttributes : public JSON::ObjectBase {
2026public:
2027 enum {
2028 NoFieldsSet = 0,
2029 AllFieldsSet = 0
2030 };
2031
2032 template<int STATE>
2033 class Builder {
2034 private:
2035 RefPtr<JSON::Object> m_result;
2036
2037 template<int STEP> Builder<STATE | STEP>& castState()
2038 {
2039 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2040 }
2041
2042 Builder(Ref</*ContextAttributes*/JSON::Object>&& object)
2043 : m_result(WTFMove(object))
2044 {
2045 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2046 }
2047 friend class ContextAttributes;
2048 public:
2049
2050 Ref<ContextAttributes> release()
2051 {
2052 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2053 COMPILE_ASSERT(sizeof(ContextAttributes) == sizeof(JSON::Object), cannot_cast);
2054
2055 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2056 auto result = WTFMove(*reinterpret_cast<Ref<ContextAttributes>*>(&jsonResult));
2057 return result;
2058 }
2059 };
2060
2061 /*
2062 * Synthetic constructor:
2063 * Ref<ContextAttributes> result = ContextAttributes::create()
2064 * .release();
2065 */
2066 static Builder<NoFieldsSet> create()
2067 {
2068 return Builder<NoFieldsSet>(JSON::Object::create());
2069 }
2070
2071 void setAlpha(bool value)
2072 {
2073 JSON::ObjectBase::setBoolean("alpha"_s, value);
2074 }
2075
2076 void setDepth(bool value)
2077 {
2078 JSON::ObjectBase::setBoolean("depth"_s, value);
2079 }
2080
2081 void setStencil(bool value)
2082 {
2083 JSON::ObjectBase::setBoolean("stencil"_s, value);
2084 }
2085
2086 void setAntialias(bool value)
2087 {
2088 JSON::ObjectBase::setBoolean("antialias"_s, value);
2089 }
2090
2091 void setPremultipliedAlpha(bool value)
2092 {
2093 JSON::ObjectBase::setBoolean("premultipliedAlpha"_s, value);
2094 }
2095
2096 void setPreserveDrawingBuffer(bool value)
2097 {
2098 JSON::ObjectBase::setBoolean("preserveDrawingBuffer"_s, value);
2099 }
2100
2101 void setFailIfMajorPerformanceCaveat(bool value)
2102 {
2103 JSON::ObjectBase::setBoolean("failIfMajorPerformanceCaveat"_s, value);
2104 }
2105};
2106
2107/* Information about a canvas for which a rendering context has been created. */
2108class Canvas : public JSON::ObjectBase {
2109public:
2110 enum {
2111 NoFieldsSet = 0,
2112 CanvasIdSet = 1 << 0,
2113 ContextTypeSet = 1 << 1,
2114 AllFieldsSet = (CanvasIdSet | ContextTypeSet)
2115 };
2116
2117 template<int STATE>
2118 class Builder {
2119 private:
2120 RefPtr<JSON::Object> m_result;
2121
2122 template<int STEP> Builder<STATE | STEP>& castState()
2123 {
2124 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2125 }
2126
2127 Builder(Ref</*Canvas*/JSON::Object>&& object)
2128 : m_result(WTFMove(object))
2129 {
2130 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2131 }
2132 friend class Canvas;
2133 public:
2134
2135 Builder<STATE | CanvasIdSet>& setCanvasId(const String& value)
2136 {
2137 COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set);
2138 m_result->setString("canvasId"_s, value);
2139 return castState<CanvasIdSet>();
2140 }
2141
2142 Builder<STATE | ContextTypeSet>& setContextType(Inspector::Protocol::Canvas::ContextType value)
2143 {
2144 COMPILE_ASSERT(!(STATE & ContextTypeSet), property_contextType_already_set);
2145 m_result->setString("contextType"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2146 return castState<ContextTypeSet>();
2147 }
2148
2149 Ref<Canvas> release()
2150 {
2151 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2152 COMPILE_ASSERT(sizeof(Canvas) == sizeof(JSON::Object), cannot_cast);
2153
2154 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2155 auto result = WTFMove(*reinterpret_cast<Ref<Canvas>*>(&jsonResult));
2156 return result;
2157 }
2158 };
2159
2160 /*
2161 * Synthetic constructor:
2162 * Ref<Canvas> result = Canvas::create()
2163 * .setCanvasId(...)
2164 * .setContextType(...)
2165 * .release();
2166 */
2167 static Builder<NoFieldsSet> create()
2168 {
2169 return Builder<NoFieldsSet>(JSON::Object::create());
2170 }
2171
2172 void setNodeId(int value)
2173 {
2174 JSON::ObjectBase::setInteger("nodeId"_s, value);
2175 }
2176
2177 void setCssCanvasName(const String& value)
2178 {
2179 JSON::ObjectBase::setString("cssCanvasName"_s, value);
2180 }
2181
2182 void setContextAttributes(RefPtr<Inspector::Protocol::Canvas::ContextAttributes> value)
2183 {
2184 JSON::ObjectBase::setObject("contextAttributes"_s, WTFMove(value));
2185 }
2186
2187 void setMemoryCost(double value)
2188 {
2189 JSON::ObjectBase::setDouble("memoryCost"_s, value);
2190 }
2191
2192 void setBacktrace(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
2193 {
2194 JSON::ObjectBase::setArray("backtrace"_s, WTFMove(value));
2195 }
2196};
2197
2198} // Canvas
2199
2200namespace Console {
2201/* Channels for different types of log messages. */
2202enum class ChannelSource {
2203 XML = 32,
2204 JavaScript = 33,
2205 Network = 34,
2206 ConsoleAPI = 35,
2207 Storage = 36,
2208 Appcache = 37,
2209 Rendering = 38,
2210 CSS = 39,
2211 Security = 40,
2212 ContentBlocker = 41,
2213 Media = 42,
2214 MediaSource = 43,
2215 WebRTC = 44,
2216 Other = 45,
2217}; // enum class ChannelSource
2218/* Level of logging. */
2219enum class ChannelLevel {
2220 Off = 46,
2221 Basic = 47,
2222 Verbose = 48,
2223}; // enum class ChannelLevel
2224/* Logging channel. */
2225class Channel : public JSON::ObjectBase {
2226public:
2227 enum {
2228 NoFieldsSet = 0,
2229 SourceSet = 1 << 0,
2230 LevelSet = 1 << 1,
2231 AllFieldsSet = (SourceSet | LevelSet)
2232 };
2233
2234 template<int STATE>
2235 class Builder {
2236 private:
2237 RefPtr<JSON::Object> m_result;
2238
2239 template<int STEP> Builder<STATE | STEP>& castState()
2240 {
2241 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2242 }
2243
2244 Builder(Ref</*Channel*/JSON::Object>&& object)
2245 : m_result(WTFMove(object))
2246 {
2247 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2248 }
2249 friend class Channel;
2250 public:
2251
2252 Builder<STATE | SourceSet>& setSource(Inspector::Protocol::Console::ChannelSource value)
2253 {
2254 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
2255 m_result->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2256 return castState<SourceSet>();
2257 }
2258
2259 Builder<STATE | LevelSet>& setLevel(Inspector::Protocol::Console::ChannelLevel value)
2260 {
2261 COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
2262 m_result->setString("level"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2263 return castState<LevelSet>();
2264 }
2265
2266 Ref<Channel> release()
2267 {
2268 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2269 COMPILE_ASSERT(sizeof(Channel) == sizeof(JSON::Object), cannot_cast);
2270
2271 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2272 auto result = WTFMove(*reinterpret_cast<Ref<Channel>*>(&jsonResult));
2273 return result;
2274 }
2275 };
2276
2277 /*
2278 * Synthetic constructor:
2279 * Ref<Channel> result = Channel::create()
2280 * .setSource(...)
2281 * .setLevel(...)
2282 * .release();
2283 */
2284 static Builder<NoFieldsSet> create()
2285 {
2286 return Builder<NoFieldsSet>(JSON::Object::create());
2287 }
2288};
2289
2290/* Console message. */
2291class ConsoleMessage : public JSON::ObjectBase {
2292public:
2293 // Named after property name 'level' while generating ConsoleMessage.
2294 enum class Level {
2295 Log = 49,
2296 Info = 50,
2297 Warning = 51,
2298 Error = 52,
2299 Debug = 53,
2300 }; // enum class Level
2301 // Named after property name 'type' while generating ConsoleMessage.
2302 enum class Type {
2303 Log = 49,
2304 Dir = 54,
2305 DirXML = 55,
2306 Table = 56,
2307 Trace = 57,
2308 Clear = 58,
2309 StartGroup = 59,
2310 StartGroupCollapsed = 60,
2311 EndGroup = 61,
2312 Assert = 62,
2313 Timing = 63,
2314 Profile = 64,
2315 ProfileEnd = 65,
2316 Image = 66,
2317 }; // enum class Type
2318 enum {
2319 NoFieldsSet = 0,
2320 SourceSet = 1 << 0,
2321 LevelSet = 1 << 1,
2322 TextSet = 1 << 2,
2323 AllFieldsSet = (SourceSet | LevelSet | TextSet)
2324 };
2325
2326 template<int STATE>
2327 class Builder {
2328 private:
2329 RefPtr<JSON::Object> m_result;
2330
2331 template<int STEP> Builder<STATE | STEP>& castState()
2332 {
2333 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2334 }
2335
2336 Builder(Ref</*ConsoleMessage*/JSON::Object>&& object)
2337 : m_result(WTFMove(object))
2338 {
2339 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2340 }
2341 friend class ConsoleMessage;
2342 public:
2343
2344 Builder<STATE | SourceSet>& setSource(Inspector::Protocol::Console::ChannelSource value)
2345 {
2346 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
2347 m_result->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2348 return castState<SourceSet>();
2349 }
2350
2351 Builder<STATE | LevelSet>& setLevel(Level value)
2352 {
2353 COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set);
2354 m_result->setString("level"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2355 return castState<LevelSet>();
2356 }
2357
2358 Builder<STATE | TextSet>& setText(const String& value)
2359 {
2360 COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set);
2361 m_result->setString("text"_s, value);
2362 return castState<TextSet>();
2363 }
2364
2365 Ref<ConsoleMessage> release()
2366 {
2367 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2368 COMPILE_ASSERT(sizeof(ConsoleMessage) == sizeof(JSON::Object), cannot_cast);
2369
2370 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2371 auto result = WTFMove(*reinterpret_cast<Ref<ConsoleMessage>*>(&jsonResult));
2372 return result;
2373 }
2374 };
2375
2376 /*
2377 * Synthetic constructor:
2378 * Ref<ConsoleMessage> result = ConsoleMessage::create()
2379 * .setSource(...)
2380 * .setLevel(...)
2381 * .setText(...)
2382 * .release();
2383 */
2384 static Builder<NoFieldsSet> create()
2385 {
2386 return Builder<NoFieldsSet>(JSON::Object::create());
2387 }
2388
2389 void setType(Type value)
2390 {
2391 JSON::ObjectBase::setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2392 }
2393
2394 void setUrl(const String& value)
2395 {
2396 JSON::ObjectBase::setString("url"_s, value);
2397 }
2398
2399 void setLine(int value)
2400 {
2401 JSON::ObjectBase::setInteger("line"_s, value);
2402 }
2403
2404 void setColumn(int value)
2405 {
2406 JSON::ObjectBase::setInteger("column"_s, value);
2407 }
2408
2409 void setRepeatCount(int value)
2410 {
2411 JSON::ObjectBase::setInteger("repeatCount"_s, value);
2412 }
2413
2414 void setParameters(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::RemoteObject>> value)
2415 {
2416 JSON::ObjectBase::setArray("parameters"_s, WTFMove(value));
2417 }
2418
2419 void setStackTrace(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
2420 {
2421 JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(value));
2422 }
2423
2424 void setNetworkRequestId(const String& value)
2425 {
2426 JSON::ObjectBase::setString("networkRequestId"_s, value);
2427 }
2428};
2429
2430/* Stack entry for console errors and assertions. */
2431class CallFrame : public JSON::ObjectBase {
2432public:
2433 enum {
2434 NoFieldsSet = 0,
2435 FunctionNameSet = 1 << 0,
2436 UrlSet = 1 << 1,
2437 ScriptIdSet = 1 << 2,
2438 LineNumberSet = 1 << 3,
2439 ColumnNumberSet = 1 << 4,
2440 AllFieldsSet = (FunctionNameSet | UrlSet | ScriptIdSet | LineNumberSet | ColumnNumberSet)
2441 };
2442
2443 template<int STATE>
2444 class Builder {
2445 private:
2446 RefPtr<JSON::Object> m_result;
2447
2448 template<int STEP> Builder<STATE | STEP>& castState()
2449 {
2450 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2451 }
2452
2453 Builder(Ref</*CallFrame*/JSON::Object>&& object)
2454 : m_result(WTFMove(object))
2455 {
2456 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2457 }
2458 friend class CallFrame;
2459 public:
2460
2461 Builder<STATE | FunctionNameSet>& setFunctionName(const String& value)
2462 {
2463 COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
2464 m_result->setString("functionName"_s, value);
2465 return castState<FunctionNameSet>();
2466 }
2467
2468 Builder<STATE | UrlSet>& setUrl(const String& value)
2469 {
2470 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
2471 m_result->setString("url"_s, value);
2472 return castState<UrlSet>();
2473 }
2474
2475 Builder<STATE | ScriptIdSet>& setScriptId(const String& value)
2476 {
2477 COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
2478 m_result->setString("scriptId"_s, value);
2479 return castState<ScriptIdSet>();
2480 }
2481
2482 Builder<STATE | LineNumberSet>& setLineNumber(int value)
2483 {
2484 COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
2485 m_result->setInteger("lineNumber"_s, value);
2486 return castState<LineNumberSet>();
2487 }
2488
2489 Builder<STATE | ColumnNumberSet>& setColumnNumber(int value)
2490 {
2491 COMPILE_ASSERT(!(STATE & ColumnNumberSet), property_columnNumber_already_set);
2492 m_result->setInteger("columnNumber"_s, value);
2493 return castState<ColumnNumberSet>();
2494 }
2495
2496 Ref<CallFrame> release()
2497 {
2498 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2499 COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
2500
2501 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2502 auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
2503 return result;
2504 }
2505 };
2506
2507 /*
2508 * Synthetic constructor:
2509 * Ref<CallFrame> result = CallFrame::create()
2510 * .setFunctionName(...)
2511 * .setUrl(...)
2512 * .setScriptId(...)
2513 * .setLineNumber(...)
2514 * .setColumnNumber(...)
2515 * .release();
2516 */
2517 static Builder<NoFieldsSet> create()
2518 {
2519 return Builder<NoFieldsSet>(JSON::Object::create());
2520 }
2521};
2522
2523/* Call frames for async function calls, console assertions, and error messages. */
2524class StackTrace : public JSON::ObjectBase {
2525public:
2526 enum {
2527 NoFieldsSet = 0,
2528 CallFramesSet = 1 << 0,
2529 AllFieldsSet = (CallFramesSet)
2530 };
2531
2532 template<int STATE>
2533 class Builder {
2534 private:
2535 RefPtr<JSON::Object> m_result;
2536
2537 template<int STEP> Builder<STATE | STEP>& castState()
2538 {
2539 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2540 }
2541
2542 Builder(Ref</*StackTrace*/JSON::Object>&& object)
2543 : m_result(WTFMove(object))
2544 {
2545 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2546 }
2547 friend class StackTrace;
2548 public:
2549
2550 Builder<STATE | CallFramesSet>& setCallFrames(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
2551 {
2552 COMPILE_ASSERT(!(STATE & CallFramesSet), property_callFrames_already_set);
2553 m_result->setArray("callFrames"_s, value);
2554 return castState<CallFramesSet>();
2555 }
2556
2557 Ref<StackTrace> release()
2558 {
2559 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2560 COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
2561
2562 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2563 auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
2564 return result;
2565 }
2566 };
2567
2568 /*
2569 * Synthetic constructor:
2570 * Ref<StackTrace> result = StackTrace::create()
2571 * .setCallFrames(...)
2572 * .release();
2573 */
2574 static Builder<NoFieldsSet> create()
2575 {
2576 return Builder<NoFieldsSet>(JSON::Object::create());
2577 }
2578
2579 void setTopCallFrameIsBoundary(bool value)
2580 {
2581 JSON::ObjectBase::setBoolean("topCallFrameIsBoundary"_s, value);
2582 }
2583
2584 void setTruncated(bool value)
2585 {
2586 JSON::ObjectBase::setBoolean("truncated"_s, value);
2587 }
2588
2589 void setParentStackTrace(RefPtr<Inspector::Protocol::Console::StackTrace> value)
2590 {
2591 JSON::ObjectBase::setObject("parentStackTrace"_s, WTFMove(value));
2592 }
2593};
2594
2595} // Console
2596
2597namespace DOM {
2598/* Pseudo element type. */
2599enum class PseudoType {
2600 Before = 7,
2601 After = 8,
2602}; // enum class PseudoType
2603/* Shadow root type. */
2604enum class ShadowRootType {
2605 UserAgent = 1,
2606 Open = 67,
2607 Closed = 68,
2608}; // enum class ShadowRootType
2609/* Custom element state. */
2610enum class CustomElementState {
2611 Builtin = 69,
2612 Custom = 70,
2613 Waiting = 71,
2614 Failed = 72,
2615}; // enum class CustomElementState
2616/* Token values of @aria-relevant attribute. */
2617enum class LiveRegionRelevant {
2618 Additions = 73,
2619 Removals = 74,
2620 Text = 75,
2621}; // enum class LiveRegionRelevant
2622/* DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type. */
2623class Node : public JSON::ObjectBase {
2624public:
2625 enum {
2626 NoFieldsSet = 0,
2627 NodeIdSet = 1 << 0,
2628 NodeTypeSet = 1 << 1,
2629 NodeNameSet = 1 << 2,
2630 LocalNameSet = 1 << 3,
2631 NodeValueSet = 1 << 4,
2632 AllFieldsSet = (NodeIdSet | NodeTypeSet | NodeNameSet | LocalNameSet | NodeValueSet)
2633 };
2634
2635 template<int STATE>
2636 class Builder {
2637 private:
2638 RefPtr<JSON::Object> m_result;
2639
2640 template<int STEP> Builder<STATE | STEP>& castState()
2641 {
2642 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2643 }
2644
2645 Builder(Ref</*Node*/JSON::Object>&& object)
2646 : m_result(WTFMove(object))
2647 {
2648 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2649 }
2650 friend class Node;
2651 public:
2652
2653 Builder<STATE | NodeIdSet>& setNodeId(int value)
2654 {
2655 COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
2656 m_result->setInteger("nodeId"_s, value);
2657 return castState<NodeIdSet>();
2658 }
2659
2660 Builder<STATE | NodeTypeSet>& setNodeType(int value)
2661 {
2662 COMPILE_ASSERT(!(STATE & NodeTypeSet), property_nodeType_already_set);
2663 m_result->setInteger("nodeType"_s, value);
2664 return castState<NodeTypeSet>();
2665 }
2666
2667 Builder<STATE | NodeNameSet>& setNodeName(const String& value)
2668 {
2669 COMPILE_ASSERT(!(STATE & NodeNameSet), property_nodeName_already_set);
2670 m_result->setString("nodeName"_s, value);
2671 return castState<NodeNameSet>();
2672 }
2673
2674 Builder<STATE | LocalNameSet>& setLocalName(const String& value)
2675 {
2676 COMPILE_ASSERT(!(STATE & LocalNameSet), property_localName_already_set);
2677 m_result->setString("localName"_s, value);
2678 return castState<LocalNameSet>();
2679 }
2680
2681 Builder<STATE | NodeValueSet>& setNodeValue(const String& value)
2682 {
2683 COMPILE_ASSERT(!(STATE & NodeValueSet), property_nodeValue_already_set);
2684 m_result->setString("nodeValue"_s, value);
2685 return castState<NodeValueSet>();
2686 }
2687
2688 Ref<Node> release()
2689 {
2690 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2691 COMPILE_ASSERT(sizeof(Node) == sizeof(JSON::Object), cannot_cast);
2692
2693 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2694 auto result = WTFMove(*reinterpret_cast<Ref<Node>*>(&jsonResult));
2695 return result;
2696 }
2697 };
2698
2699 /*
2700 * Synthetic constructor:
2701 * Ref<Node> result = Node::create()
2702 * .setNodeId(...)
2703 * .setNodeType(...)
2704 * .setNodeName(...)
2705 * .setLocalName(...)
2706 * .setNodeValue(...)
2707 * .release();
2708 */
2709 static Builder<NoFieldsSet> create()
2710 {
2711 return Builder<NoFieldsSet>(JSON::Object::create());
2712 }
2713
2714 void setFrameId(const String& value)
2715 {
2716 JSON::ObjectBase::setString("frameId"_s, value);
2717 }
2718
2719 void setChildNodeCount(int value)
2720 {
2721 JSON::ObjectBase::setInteger("childNodeCount"_s, value);
2722 }
2723
2724 void setChildren(RefPtr<JSON::ArrayOf<Inspector::Protocol::DOM::Node>> value)
2725 {
2726 JSON::ObjectBase::setArray("children"_s, WTFMove(value));
2727 }
2728
2729 void setAttributes(RefPtr<JSON::ArrayOf<String>> value)
2730 {
2731 JSON::ObjectBase::setArray("attributes"_s, WTFMove(value));
2732 }
2733
2734 void setDocumentURL(const String& value)
2735 {
2736 JSON::ObjectBase::setString("documentURL"_s, value);
2737 }
2738
2739 void setBaseURL(const String& value)
2740 {
2741 JSON::ObjectBase::setString("baseURL"_s, value);
2742 }
2743
2744 void setPublicId(const String& value)
2745 {
2746 JSON::ObjectBase::setString("publicId"_s, value);
2747 }
2748
2749 void setSystemId(const String& value)
2750 {
2751 JSON::ObjectBase::setString("systemId"_s, value);
2752 }
2753
2754 void setXmlVersion(const String& value)
2755 {
2756 JSON::ObjectBase::setString("xmlVersion"_s, value);
2757 }
2758
2759 void setName(const String& value)
2760 {
2761 JSON::ObjectBase::setString("name"_s, value);
2762 }
2763
2764 void setValue(const String& value)
2765 {
2766 JSON::ObjectBase::setString("value"_s, value);
2767 }
2768
2769 void setPseudoType(Inspector::Protocol::DOM::PseudoType value)
2770 {
2771 JSON::ObjectBase::setString("pseudoType"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2772 }
2773
2774 void setShadowRootType(Inspector::Protocol::DOM::ShadowRootType value)
2775 {
2776 JSON::ObjectBase::setString("shadowRootType"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2777 }
2778
2779 void setCustomElementState(Inspector::Protocol::DOM::CustomElementState value)
2780 {
2781 JSON::ObjectBase::setString("customElementState"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
2782 }
2783
2784 void setContentDocument(RefPtr<Inspector::Protocol::DOM::Node> value)
2785 {
2786 JSON::ObjectBase::setObject("contentDocument"_s, WTFMove(value));
2787 }
2788
2789 void setShadowRoots(RefPtr<JSON::ArrayOf<Inspector::Protocol::DOM::Node>> value)
2790 {
2791 JSON::ObjectBase::setArray("shadowRoots"_s, WTFMove(value));
2792 }
2793
2794 void setTemplateContent(RefPtr<Inspector::Protocol::DOM::Node> value)
2795 {
2796 JSON::ObjectBase::setObject("templateContent"_s, WTFMove(value));
2797 }
2798
2799 void setPseudoElements(RefPtr<JSON::ArrayOf<Inspector::Protocol::DOM::Node>> value)
2800 {
2801 JSON::ObjectBase::setArray("pseudoElements"_s, WTFMove(value));
2802 }
2803
2804 void setContentSecurityPolicyHash(const String& value)
2805 {
2806 JSON::ObjectBase::setString("contentSecurityPolicyHash"_s, value);
2807 }
2808};
2809
2810/* Relationship between data that is associated with a node and the node itself. */
2811class DataBinding : public JSON::ObjectBase {
2812public:
2813 enum {
2814 NoFieldsSet = 0,
2815 BindingSet = 1 << 0,
2816 ValueSet = 1 << 1,
2817 AllFieldsSet = (BindingSet | ValueSet)
2818 };
2819
2820 template<int STATE>
2821 class Builder {
2822 private:
2823 RefPtr<JSON::Object> m_result;
2824
2825 template<int STEP> Builder<STATE | STEP>& castState()
2826 {
2827 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2828 }
2829
2830 Builder(Ref</*DataBinding*/JSON::Object>&& object)
2831 : m_result(WTFMove(object))
2832 {
2833 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2834 }
2835 friend class DataBinding;
2836 public:
2837
2838 Builder<STATE | BindingSet>& setBinding(const String& value)
2839 {
2840 COMPILE_ASSERT(!(STATE & BindingSet), property_binding_already_set);
2841 m_result->setString("binding"_s, value);
2842 return castState<BindingSet>();
2843 }
2844
2845 Builder<STATE | ValueSet>& setValue(const String& value)
2846 {
2847 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
2848 m_result->setString("value"_s, value);
2849 return castState<ValueSet>();
2850 }
2851
2852 Ref<DataBinding> release()
2853 {
2854 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2855 COMPILE_ASSERT(sizeof(DataBinding) == sizeof(JSON::Object), cannot_cast);
2856
2857 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2858 auto result = WTFMove(*reinterpret_cast<Ref<DataBinding>*>(&jsonResult));
2859 return result;
2860 }
2861 };
2862
2863 /*
2864 * Synthetic constructor:
2865 * Ref<DataBinding> result = DataBinding::create()
2866 * .setBinding(...)
2867 * .setValue(...)
2868 * .release();
2869 */
2870 static Builder<NoFieldsSet> create()
2871 {
2872 return Builder<NoFieldsSet>(JSON::Object::create());
2873 }
2874
2875 void setType(const String& value)
2876 {
2877 JSON::ObjectBase::setString("type"_s, value);
2878 }
2879};
2880
2881/* A structure holding event listener properties. */
2882class EventListener : public JSON::ObjectBase {
2883public:
2884 enum {
2885 NoFieldsSet = 0,
2886 EventListenerIdSet = 1 << 0,
2887 TypeSet = 1 << 1,
2888 UseCaptureSet = 1 << 2,
2889 IsAttributeSet = 1 << 3,
2890 AllFieldsSet = (EventListenerIdSet | TypeSet | UseCaptureSet | IsAttributeSet)
2891 };
2892
2893 template<int STATE>
2894 class Builder {
2895 private:
2896 RefPtr<JSON::Object> m_result;
2897
2898 template<int STEP> Builder<STATE | STEP>& castState()
2899 {
2900 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
2901 }
2902
2903 Builder(Ref</*EventListener*/JSON::Object>&& object)
2904 : m_result(WTFMove(object))
2905 {
2906 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
2907 }
2908 friend class EventListener;
2909 public:
2910
2911 Builder<STATE | EventListenerIdSet>& setEventListenerId(int value)
2912 {
2913 COMPILE_ASSERT(!(STATE & EventListenerIdSet), property_eventListenerId_already_set);
2914 m_result->setInteger("eventListenerId"_s, value);
2915 return castState<EventListenerIdSet>();
2916 }
2917
2918 Builder<STATE | TypeSet>& setType(const String& value)
2919 {
2920 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
2921 m_result->setString("type"_s, value);
2922 return castState<TypeSet>();
2923 }
2924
2925 Builder<STATE | UseCaptureSet>& setUseCapture(bool value)
2926 {
2927 COMPILE_ASSERT(!(STATE & UseCaptureSet), property_useCapture_already_set);
2928 m_result->setBoolean("useCapture"_s, value);
2929 return castState<UseCaptureSet>();
2930 }
2931
2932 Builder<STATE | IsAttributeSet>& setIsAttribute(bool value)
2933 {
2934 COMPILE_ASSERT(!(STATE & IsAttributeSet), property_isAttribute_already_set);
2935 m_result->setBoolean("isAttribute"_s, value);
2936 return castState<IsAttributeSet>();
2937 }
2938
2939 Ref<EventListener> release()
2940 {
2941 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
2942 COMPILE_ASSERT(sizeof(EventListener) == sizeof(JSON::Object), cannot_cast);
2943
2944 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
2945 auto result = WTFMove(*reinterpret_cast<Ref<EventListener>*>(&jsonResult));
2946 return result;
2947 }
2948 };
2949
2950 /*
2951 * Synthetic constructor:
2952 * Ref<EventListener> result = EventListener::create()
2953 * .setEventListenerId(...)
2954 * .setType(...)
2955 * .setUseCapture(...)
2956 * .setIsAttribute(...)
2957 * .release();
2958 */
2959 static Builder<NoFieldsSet> create()
2960 {
2961 return Builder<NoFieldsSet>(JSON::Object::create());
2962 }
2963
2964 void setNodeId(int value)
2965 {
2966 JSON::ObjectBase::setInteger("nodeId"_s, value);
2967 }
2968
2969 void setOnWindow(bool value)
2970 {
2971 JSON::ObjectBase::setBoolean("onWindow"_s, value);
2972 }
2973
2974 void setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
2975 {
2976 JSON::ObjectBase::setObject("location"_s, WTFMove(value));
2977 }
2978
2979 void setHandlerName(const String& value)
2980 {
2981 JSON::ObjectBase::setString("handlerName"_s, value);
2982 }
2983
2984 void setPassive(bool value)
2985 {
2986 JSON::ObjectBase::setBoolean("passive"_s, value);
2987 }
2988
2989 void setOnce(bool value)
2990 {
2991 JSON::ObjectBase::setBoolean("once"_s, value);
2992 }
2993
2994 void setDisabled(bool value)
2995 {
2996 JSON::ObjectBase::setBoolean("disabled"_s, value);
2997 }
2998
2999 void setHasBreakpoint(bool value)
3000 {
3001 JSON::ObjectBase::setBoolean("hasBreakpoint"_s, value);
3002 }
3003};
3004
3005/* A structure holding accessibility properties. */
3006class AccessibilityProperties : public JSON::ObjectBase {
3007public:
3008 // Named after property name 'checked' while generating AccessibilityProperties.
3009 enum class Checked {
3010 True = 76,
3011 False = 77,
3012 Mixed = 78,
3013 }; // enum class Checked
3014 // Named after property name 'current' while generating AccessibilityProperties.
3015 enum class Current {
3016 True = 76,
3017 False = 77,
3018 Page = 79,
3019 Step = 80,
3020 Location = 81,
3021 Date = 82,
3022 Time = 83,
3023 }; // enum class Current
3024 // Named after property name 'invalid' while generating AccessibilityProperties.
3025 enum class Invalid {
3026 True = 76,
3027 False = 77,
3028 Grammar = 84,
3029 Spelling = 85,
3030 }; // enum class Invalid
3031 // Named after property name 'liveRegionStatus' while generating AccessibilityProperties.
3032 enum class LiveRegionStatus {
3033 Assertive = 86,
3034 Polite = 87,
3035 Off = 46,
3036 }; // enum class LiveRegionStatus
3037 enum {
3038 NoFieldsSet = 0,
3039 ExistsSet = 1 << 0,
3040 LabelSet = 1 << 1,
3041 NodeIdSet = 1 << 2,
3042 RoleSet = 1 << 3,
3043 AllFieldsSet = (ExistsSet | LabelSet | NodeIdSet | RoleSet)
3044 };
3045
3046 template<int STATE>
3047 class Builder {
3048 private:
3049 RefPtr<JSON::Object> m_result;
3050
3051 template<int STEP> Builder<STATE | STEP>& castState()
3052 {
3053 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3054 }
3055
3056 Builder(Ref</*AccessibilityProperties*/JSON::Object>&& object)
3057 : m_result(WTFMove(object))
3058 {
3059 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3060 }
3061 friend class AccessibilityProperties;
3062 public:
3063
3064 Builder<STATE | ExistsSet>& setExists(bool value)
3065 {
3066 COMPILE_ASSERT(!(STATE & ExistsSet), property_exists_already_set);
3067 m_result->setBoolean("exists"_s, value);
3068 return castState<ExistsSet>();
3069 }
3070
3071 Builder<STATE | LabelSet>& setLabel(const String& value)
3072 {
3073 COMPILE_ASSERT(!(STATE & LabelSet), property_label_already_set);
3074 m_result->setString("label"_s, value);
3075 return castState<LabelSet>();
3076 }
3077
3078 Builder<STATE | NodeIdSet>& setNodeId(int value)
3079 {
3080 COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
3081 m_result->setInteger("nodeId"_s, value);
3082 return castState<NodeIdSet>();
3083 }
3084
3085 Builder<STATE | RoleSet>& setRole(const String& value)
3086 {
3087 COMPILE_ASSERT(!(STATE & RoleSet), property_role_already_set);
3088 m_result->setString("role"_s, value);
3089 return castState<RoleSet>();
3090 }
3091
3092 Ref<AccessibilityProperties> release()
3093 {
3094 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3095 COMPILE_ASSERT(sizeof(AccessibilityProperties) == sizeof(JSON::Object), cannot_cast);
3096
3097 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3098 auto result = WTFMove(*reinterpret_cast<Ref<AccessibilityProperties>*>(&jsonResult));
3099 return result;
3100 }
3101 };
3102
3103 /*
3104 * Synthetic constructor:
3105 * Ref<AccessibilityProperties> result = AccessibilityProperties::create()
3106 * .setExists(...)
3107 * .setLabel(...)
3108 * .setNodeId(...)
3109 * .setRole(...)
3110 * .release();
3111 */
3112 static Builder<NoFieldsSet> create()
3113 {
3114 return Builder<NoFieldsSet>(JSON::Object::create());
3115 }
3116
3117 void setActiveDescendantNodeId(int value)
3118 {
3119 JSON::ObjectBase::setInteger("activeDescendantNodeId"_s, value);
3120 }
3121
3122 void setBusy(bool value)
3123 {
3124 JSON::ObjectBase::setBoolean("busy"_s, value);
3125 }
3126
3127 void setChecked(Checked value)
3128 {
3129 JSON::ObjectBase::setString("checked"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3130 }
3131
3132 void setChildNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3133 {
3134 JSON::ObjectBase::setArray("childNodeIds"_s, WTFMove(value));
3135 }
3136
3137 void setControlledNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3138 {
3139 JSON::ObjectBase::setArray("controlledNodeIds"_s, WTFMove(value));
3140 }
3141
3142 void setCurrent(Current value)
3143 {
3144 JSON::ObjectBase::setString("current"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3145 }
3146
3147 void setDisabled(bool value)
3148 {
3149 JSON::ObjectBase::setBoolean("disabled"_s, value);
3150 }
3151
3152 void setHeadingLevel(double value)
3153 {
3154 JSON::ObjectBase::setDouble("headingLevel"_s, value);
3155 }
3156
3157 void setHierarchyLevel(double value)
3158 {
3159 JSON::ObjectBase::setDouble("hierarchyLevel"_s, value);
3160 }
3161
3162 void setIsPopUpButton(bool value)
3163 {
3164 JSON::ObjectBase::setBoolean("isPopUpButton"_s, value);
3165 }
3166
3167 void setExpanded(bool value)
3168 {
3169 JSON::ObjectBase::setBoolean("expanded"_s, value);
3170 }
3171
3172 void setFlowedNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3173 {
3174 JSON::ObjectBase::setArray("flowedNodeIds"_s, WTFMove(value));
3175 }
3176
3177 void setFocused(bool value)
3178 {
3179 JSON::ObjectBase::setBoolean("focused"_s, value);
3180 }
3181
3182 void setIgnored(bool value)
3183 {
3184 JSON::ObjectBase::setBoolean("ignored"_s, value);
3185 }
3186
3187 void setIgnoredByDefault(bool value)
3188 {
3189 JSON::ObjectBase::setBoolean("ignoredByDefault"_s, value);
3190 }
3191
3192 void setInvalid(Invalid value)
3193 {
3194 JSON::ObjectBase::setString("invalid"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3195 }
3196
3197 void setHidden(bool value)
3198 {
3199 JSON::ObjectBase::setBoolean("hidden"_s, value);
3200 }
3201
3202 void setLiveRegionAtomic(bool value)
3203 {
3204 JSON::ObjectBase::setBoolean("liveRegionAtomic"_s, value);
3205 }
3206
3207 void setLiveRegionRelevant(RefPtr<JSON::ArrayOf<String>> value)
3208 {
3209 JSON::ObjectBase::setArray("liveRegionRelevant"_s, WTFMove(value));
3210 }
3211
3212 void setLiveRegionStatus(LiveRegionStatus value)
3213 {
3214 JSON::ObjectBase::setString("liveRegionStatus"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3215 }
3216
3217 void setMouseEventNodeId(int value)
3218 {
3219 JSON::ObjectBase::setInteger("mouseEventNodeId"_s, value);
3220 }
3221
3222 void setOwnedNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3223 {
3224 JSON::ObjectBase::setArray("ownedNodeIds"_s, WTFMove(value));
3225 }
3226
3227 void setParentNodeId(int value)
3228 {
3229 JSON::ObjectBase::setInteger("parentNodeId"_s, value);
3230 }
3231
3232 void setPressed(bool value)
3233 {
3234 JSON::ObjectBase::setBoolean("pressed"_s, value);
3235 }
3236
3237 void setReadonly(bool value)
3238 {
3239 JSON::ObjectBase::setBoolean("readonly"_s, value);
3240 }
3241
3242 void setRequired(bool value)
3243 {
3244 JSON::ObjectBase::setBoolean("required"_s, value);
3245 }
3246
3247 void setSelected(bool value)
3248 {
3249 JSON::ObjectBase::setBoolean("selected"_s, value);
3250 }
3251
3252 void setSelectedChildNodeIds(RefPtr<JSON::ArrayOf<int>> value)
3253 {
3254 JSON::ObjectBase::setArray("selectedChildNodeIds"_s, WTFMove(value));
3255 }
3256};
3257
3258/* A structure holding an RGBA color. */
3259class RGBAColor : public JSON::ObjectBase {
3260public:
3261 enum {
3262 NoFieldsSet = 0,
3263 RSet = 1 << 0,
3264 GSet = 1 << 1,
3265 BSet = 1 << 2,
3266 AllFieldsSet = (RSet | GSet | BSet)
3267 };
3268
3269 template<int STATE>
3270 class Builder {
3271 private:
3272 RefPtr<JSON::Object> m_result;
3273
3274 template<int STEP> Builder<STATE | STEP>& castState()
3275 {
3276 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3277 }
3278
3279 Builder(Ref</*RGBAColor*/JSON::Object>&& object)
3280 : m_result(WTFMove(object))
3281 {
3282 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3283 }
3284 friend class RGBAColor;
3285 public:
3286
3287 Builder<STATE | RSet>& setR(int value)
3288 {
3289 COMPILE_ASSERT(!(STATE & RSet), property_r_already_set);
3290 m_result->setInteger("r"_s, value);
3291 return castState<RSet>();
3292 }
3293
3294 Builder<STATE | GSet>& setG(int value)
3295 {
3296 COMPILE_ASSERT(!(STATE & GSet), property_g_already_set);
3297 m_result->setInteger("g"_s, value);
3298 return castState<GSet>();
3299 }
3300
3301 Builder<STATE | BSet>& setB(int value)
3302 {
3303 COMPILE_ASSERT(!(STATE & BSet), property_b_already_set);
3304 m_result->setInteger("b"_s, value);
3305 return castState<BSet>();
3306 }
3307
3308 Ref<RGBAColor> release()
3309 {
3310 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3311 COMPILE_ASSERT(sizeof(RGBAColor) == sizeof(JSON::Object), cannot_cast);
3312
3313 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3314 auto result = WTFMove(*reinterpret_cast<Ref<RGBAColor>*>(&jsonResult));
3315 return result;
3316 }
3317 };
3318
3319 /*
3320 * Synthetic constructor:
3321 * Ref<RGBAColor> result = RGBAColor::create()
3322 * .setR(...)
3323 * .setG(...)
3324 * .setB(...)
3325 * .release();
3326 */
3327 static Builder<NoFieldsSet> create()
3328 {
3329 return Builder<NoFieldsSet>(JSON::Object::create());
3330 }
3331
3332 void setA(double value)
3333 {
3334 JSON::ObjectBase::setDouble("a"_s, value);
3335 }
3336};
3337
3338/* Configuration data for the highlighting of page elements. */
3339class HighlightConfig : public JSON::ObjectBase {
3340public:
3341 enum {
3342 NoFieldsSet = 0,
3343 AllFieldsSet = 0
3344 };
3345
3346 template<int STATE>
3347 class Builder {
3348 private:
3349 RefPtr<JSON::Object> m_result;
3350
3351 template<int STEP> Builder<STATE | STEP>& castState()
3352 {
3353 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3354 }
3355
3356 Builder(Ref</*HighlightConfig*/JSON::Object>&& object)
3357 : m_result(WTFMove(object))
3358 {
3359 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3360 }
3361 friend class HighlightConfig;
3362 public:
3363
3364 Ref<HighlightConfig> release()
3365 {
3366 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3367 COMPILE_ASSERT(sizeof(HighlightConfig) == sizeof(JSON::Object), cannot_cast);
3368
3369 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3370 auto result = WTFMove(*reinterpret_cast<Ref<HighlightConfig>*>(&jsonResult));
3371 return result;
3372 }
3373 };
3374
3375 /*
3376 * Synthetic constructor:
3377 * Ref<HighlightConfig> result = HighlightConfig::create()
3378 * .release();
3379 */
3380 static Builder<NoFieldsSet> create()
3381 {
3382 return Builder<NoFieldsSet>(JSON::Object::create());
3383 }
3384
3385 void setShowInfo(bool value)
3386 {
3387 JSON::ObjectBase::setBoolean("showInfo"_s, value);
3388 }
3389
3390 void setContentColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3391 {
3392 JSON::ObjectBase::setObject("contentColor"_s, WTFMove(value));
3393 }
3394
3395 void setPaddingColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3396 {
3397 JSON::ObjectBase::setObject("paddingColor"_s, WTFMove(value));
3398 }
3399
3400 void setBorderColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3401 {
3402 JSON::ObjectBase::setObject("borderColor"_s, WTFMove(value));
3403 }
3404
3405 void setMarginColor(RefPtr<Inspector::Protocol::DOM::RGBAColor> value)
3406 {
3407 JSON::ObjectBase::setObject("marginColor"_s, WTFMove(value));
3408 }
3409};
3410
3411} // DOM
3412
3413namespace DOMDebugger {
3414/* DOM breakpoint type. */
3415enum class DOMBreakpointType {
3416 SubtreeModified = 88,
3417 AttributeModified = 89,
3418 NodeRemoved = 90,
3419}; // enum class DOMBreakpointType
3420/* Event breakpoint type. */
3421enum class EventBreakpointType {
3422 AnimationFrame = 91,
3423 Listener = 92,
3424 Timer = 93,
3425}; // enum class EventBreakpointType
3426} // DOMDebugger
3427
3428namespace DOMStorage {
3429/* DOM Storage identifier. */
3430class StorageId : public JSON::ObjectBase {
3431public:
3432 enum {
3433 NoFieldsSet = 0,
3434 SecurityOriginSet = 1 << 0,
3435 IsLocalStorageSet = 1 << 1,
3436 AllFieldsSet = (SecurityOriginSet | IsLocalStorageSet)
3437 };
3438
3439 template<int STATE>
3440 class Builder {
3441 private:
3442 RefPtr<JSON::Object> m_result;
3443
3444 template<int STEP> Builder<STATE | STEP>& castState()
3445 {
3446 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3447 }
3448
3449 Builder(Ref</*StorageId*/JSON::Object>&& object)
3450 : m_result(WTFMove(object))
3451 {
3452 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3453 }
3454 friend class StorageId;
3455 public:
3456
3457 Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& value)
3458 {
3459 COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
3460 m_result->setString("securityOrigin"_s, value);
3461 return castState<SecurityOriginSet>();
3462 }
3463
3464 Builder<STATE | IsLocalStorageSet>& setIsLocalStorage(bool value)
3465 {
3466 COMPILE_ASSERT(!(STATE & IsLocalStorageSet), property_isLocalStorage_already_set);
3467 m_result->setBoolean("isLocalStorage"_s, value);
3468 return castState<IsLocalStorageSet>();
3469 }
3470
3471 Ref<StorageId> release()
3472 {
3473 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3474 COMPILE_ASSERT(sizeof(StorageId) == sizeof(JSON::Object), cannot_cast);
3475
3476 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3477 auto result = WTFMove(*reinterpret_cast<Ref<StorageId>*>(&jsonResult));
3478 return result;
3479 }
3480 };
3481
3482 /*
3483 * Synthetic constructor:
3484 * Ref<StorageId> result = StorageId::create()
3485 * .setSecurityOrigin(...)
3486 * .setIsLocalStorage(...)
3487 * .release();
3488 */
3489 static Builder<NoFieldsSet> create()
3490 {
3491 return Builder<NoFieldsSet>(JSON::Object::create());
3492 }
3493};
3494
3495} // DOMStorage
3496
3497namespace Database {
3498/* Database object. */
3499class Database : public JSON::ObjectBase {
3500public:
3501 enum {
3502 NoFieldsSet = 0,
3503 IdSet = 1 << 0,
3504 DomainSet = 1 << 1,
3505 NameSet = 1 << 2,
3506 VersionSet = 1 << 3,
3507 AllFieldsSet = (IdSet | DomainSet | NameSet | VersionSet)
3508 };
3509
3510 template<int STATE>
3511 class Builder {
3512 private:
3513 RefPtr<JSON::Object> m_result;
3514
3515 template<int STEP> Builder<STATE | STEP>& castState()
3516 {
3517 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3518 }
3519
3520 Builder(Ref</*Database*/JSON::Object>&& object)
3521 : m_result(WTFMove(object))
3522 {
3523 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3524 }
3525 friend class Database;
3526 public:
3527
3528 Builder<STATE | IdSet>& setId(const String& value)
3529 {
3530 COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
3531 m_result->setString("id"_s, value);
3532 return castState<IdSet>();
3533 }
3534
3535 Builder<STATE | DomainSet>& setDomain(const String& value)
3536 {
3537 COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
3538 m_result->setString("domain"_s, value);
3539 return castState<DomainSet>();
3540 }
3541
3542 Builder<STATE | NameSet>& setName(const String& value)
3543 {
3544 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
3545 m_result->setString("name"_s, value);
3546 return castState<NameSet>();
3547 }
3548
3549 Builder<STATE | VersionSet>& setVersion(const String& value)
3550 {
3551 COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
3552 m_result->setString("version"_s, value);
3553 return castState<VersionSet>();
3554 }
3555
3556 Ref<Database> release()
3557 {
3558 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3559 COMPILE_ASSERT(sizeof(Database) == sizeof(JSON::Object), cannot_cast);
3560
3561 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3562 auto result = WTFMove(*reinterpret_cast<Ref<Database>*>(&jsonResult));
3563 return result;
3564 }
3565 };
3566
3567 /*
3568 * Synthetic constructor:
3569 * Ref<Database> result = Database::create()
3570 * .setId(...)
3571 * .setDomain(...)
3572 * .setName(...)
3573 * .setVersion(...)
3574 * .release();
3575 */
3576 static Builder<NoFieldsSet> create()
3577 {
3578 return Builder<NoFieldsSet>(JSON::Object::create());
3579 }
3580};
3581
3582/* Database error. */
3583class Error : public JSON::ObjectBase {
3584public:
3585 enum {
3586 NoFieldsSet = 0,
3587 MessageSet = 1 << 0,
3588 CodeSet = 1 << 1,
3589 AllFieldsSet = (MessageSet | CodeSet)
3590 };
3591
3592 template<int STATE>
3593 class Builder {
3594 private:
3595 RefPtr<JSON::Object> m_result;
3596
3597 template<int STEP> Builder<STATE | STEP>& castState()
3598 {
3599 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3600 }
3601
3602 Builder(Ref</*Error*/JSON::Object>&& object)
3603 : m_result(WTFMove(object))
3604 {
3605 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3606 }
3607 friend class Error;
3608 public:
3609
3610 Builder<STATE | MessageSet>& setMessage(const String& value)
3611 {
3612 COMPILE_ASSERT(!(STATE & MessageSet), property_message_already_set);
3613 m_result->setString("message"_s, value);
3614 return castState<MessageSet>();
3615 }
3616
3617 Builder<STATE | CodeSet>& setCode(int value)
3618 {
3619 COMPILE_ASSERT(!(STATE & CodeSet), property_code_already_set);
3620 m_result->setInteger("code"_s, value);
3621 return castState<CodeSet>();
3622 }
3623
3624 Ref<Error> release()
3625 {
3626 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3627 COMPILE_ASSERT(sizeof(Error) == sizeof(JSON::Object), cannot_cast);
3628
3629 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3630 auto result = WTFMove(*reinterpret_cast<Ref<Error>*>(&jsonResult));
3631 return result;
3632 }
3633 };
3634
3635 /*
3636 * Synthetic constructor:
3637 * Ref<Error> result = Error::create()
3638 * .setMessage(...)
3639 * .setCode(...)
3640 * .release();
3641 */
3642 static Builder<NoFieldsSet> create()
3643 {
3644 return Builder<NoFieldsSet>(JSON::Object::create());
3645 }
3646};
3647
3648} // Database
3649
3650namespace Debugger {
3651/* Location in the source code. */
3652class Location : public JSON::ObjectBase {
3653public:
3654 enum {
3655 NoFieldsSet = 0,
3656 ScriptIdSet = 1 << 0,
3657 LineNumberSet = 1 << 1,
3658 AllFieldsSet = (ScriptIdSet | LineNumberSet)
3659 };
3660
3661 template<int STATE>
3662 class Builder {
3663 private:
3664 RefPtr<JSON::Object> m_result;
3665
3666 template<int STEP> Builder<STATE | STEP>& castState()
3667 {
3668 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3669 }
3670
3671 Builder(Ref</*Location*/JSON::Object>&& object)
3672 : m_result(WTFMove(object))
3673 {
3674 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3675 }
3676 friend class Location;
3677 public:
3678
3679 Builder<STATE | ScriptIdSet>& setScriptId(const String& value)
3680 {
3681 COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set);
3682 m_result->setString("scriptId"_s, value);
3683 return castState<ScriptIdSet>();
3684 }
3685
3686 Builder<STATE | LineNumberSet>& setLineNumber(int value)
3687 {
3688 COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
3689 m_result->setInteger("lineNumber"_s, value);
3690 return castState<LineNumberSet>();
3691 }
3692
3693 Ref<Location> release()
3694 {
3695 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3696 COMPILE_ASSERT(sizeof(Location) == sizeof(JSON::Object), cannot_cast);
3697
3698 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3699 auto result = WTFMove(*reinterpret_cast<Ref<Location>*>(&jsonResult));
3700 return result;
3701 }
3702 };
3703
3704 /*
3705 * Synthetic constructor:
3706 * Ref<Location> result = Location::create()
3707 * .setScriptId(...)
3708 * .setLineNumber(...)
3709 * .release();
3710 */
3711 static Builder<NoFieldsSet> create()
3712 {
3713 return Builder<NoFieldsSet>(JSON::Object::create());
3714 }
3715
3716 void setColumnNumber(int value)
3717 {
3718 JSON::ObjectBase::setInteger("columnNumber"_s, value);
3719 }
3720};
3721
3722/* Action to perform when a breakpoint is triggered. */
3723class BreakpointAction : public JSON::ObjectBase {
3724public:
3725 // Named after property name 'type' while generating BreakpointAction.
3726 enum class Type {
3727 Log = 49,
3728 Evaluate = 94,
3729 Sound = 95,
3730 Probe = 96,
3731 }; // enum class Type
3732 enum {
3733 NoFieldsSet = 0,
3734 TypeSet = 1 << 0,
3735 AllFieldsSet = (TypeSet)
3736 };
3737
3738 template<int STATE>
3739 class Builder {
3740 private:
3741 RefPtr<JSON::Object> m_result;
3742
3743 template<int STEP> Builder<STATE | STEP>& castState()
3744 {
3745 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3746 }
3747
3748 Builder(Ref</*BreakpointAction*/JSON::Object>&& object)
3749 : m_result(WTFMove(object))
3750 {
3751 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3752 }
3753 friend class BreakpointAction;
3754 public:
3755
3756 Builder<STATE | TypeSet>& setType(Type value)
3757 {
3758 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
3759 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
3760 return castState<TypeSet>();
3761 }
3762
3763 Ref<BreakpointAction> release()
3764 {
3765 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3766 COMPILE_ASSERT(sizeof(BreakpointAction) == sizeof(JSON::Object), cannot_cast);
3767
3768 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3769 auto result = WTFMove(*reinterpret_cast<Ref<BreakpointAction>*>(&jsonResult));
3770 return result;
3771 }
3772 };
3773
3774 /*
3775 * Synthetic constructor:
3776 * Ref<BreakpointAction> result = BreakpointAction::create()
3777 * .setType(...)
3778 * .release();
3779 */
3780 static Builder<NoFieldsSet> create()
3781 {
3782 return Builder<NoFieldsSet>(JSON::Object::create());
3783 }
3784
3785 void setData(const String& value)
3786 {
3787 JSON::ObjectBase::setString("data"_s, value);
3788 }
3789
3790 void setId(int value)
3791 {
3792 JSON::ObjectBase::setInteger("id"_s, value);
3793 }
3794};
3795
3796/* Extra options that modify breakpoint behavior. */
3797class BreakpointOptions : public JSON::ObjectBase {
3798public:
3799 enum {
3800 NoFieldsSet = 0,
3801 AllFieldsSet = 0
3802 };
3803
3804 template<int STATE>
3805 class Builder {
3806 private:
3807 RefPtr<JSON::Object> m_result;
3808
3809 template<int STEP> Builder<STATE | STEP>& castState()
3810 {
3811 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3812 }
3813
3814 Builder(Ref</*BreakpointOptions*/JSON::Object>&& object)
3815 : m_result(WTFMove(object))
3816 {
3817 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3818 }
3819 friend class BreakpointOptions;
3820 public:
3821
3822 Ref<BreakpointOptions> release()
3823 {
3824 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3825 COMPILE_ASSERT(sizeof(BreakpointOptions) == sizeof(JSON::Object), cannot_cast);
3826
3827 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3828 auto result = WTFMove(*reinterpret_cast<Ref<BreakpointOptions>*>(&jsonResult));
3829 return result;
3830 }
3831 };
3832
3833 /*
3834 * Synthetic constructor:
3835 * Ref<BreakpointOptions> result = BreakpointOptions::create()
3836 * .release();
3837 */
3838 static Builder<NoFieldsSet> create()
3839 {
3840 return Builder<NoFieldsSet>(JSON::Object::create());
3841 }
3842
3843 void setCondition(const String& value)
3844 {
3845 JSON::ObjectBase::setString("condition"_s, value);
3846 }
3847
3848 void setActions(RefPtr<JSON::ArrayOf<Inspector::Protocol::Debugger::BreakpointAction>> value)
3849 {
3850 JSON::ObjectBase::setArray("actions"_s, WTFMove(value));
3851 }
3852
3853 void setAutoContinue(bool value)
3854 {
3855 JSON::ObjectBase::setBoolean("autoContinue"_s, value);
3856 }
3857
3858 void setIgnoreCount(int value)
3859 {
3860 JSON::ObjectBase::setInteger("ignoreCount"_s, value);
3861 }
3862};
3863
3864/* Information about the function. */
3865class FunctionDetails : public JSON::ObjectBase {
3866public:
3867 enum {
3868 NoFieldsSet = 0,
3869 LocationSet = 1 << 0,
3870 AllFieldsSet = (LocationSet)
3871 };
3872
3873 template<int STATE>
3874 class Builder {
3875 private:
3876 RefPtr<JSON::Object> m_result;
3877
3878 template<int STEP> Builder<STATE | STEP>& castState()
3879 {
3880 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3881 }
3882
3883 Builder(Ref</*FunctionDetails*/JSON::Object>&& object)
3884 : m_result(WTFMove(object))
3885 {
3886 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3887 }
3888 friend class FunctionDetails;
3889 public:
3890
3891 Builder<STATE | LocationSet>& setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
3892 {
3893 COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
3894 m_result->setObject("location"_s, value);
3895 return castState<LocationSet>();
3896 }
3897
3898 Ref<FunctionDetails> release()
3899 {
3900 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
3901 COMPILE_ASSERT(sizeof(FunctionDetails) == sizeof(JSON::Object), cannot_cast);
3902
3903 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
3904 auto result = WTFMove(*reinterpret_cast<Ref<FunctionDetails>*>(&jsonResult));
3905 return result;
3906 }
3907 };
3908
3909 /*
3910 * Synthetic constructor:
3911 * Ref<FunctionDetails> result = FunctionDetails::create()
3912 * .setLocation(...)
3913 * .release();
3914 */
3915 static Builder<NoFieldsSet> create()
3916 {
3917 return Builder<NoFieldsSet>(JSON::Object::create());
3918 }
3919
3920 void setName(const String& value)
3921 {
3922 JSON::ObjectBase::setString("name"_s, value);
3923 }
3924
3925 void setDisplayName(const String& value)
3926 {
3927 JSON::ObjectBase::setString("displayName"_s, value);
3928 }
3929
3930 void setScopeChain(RefPtr<JSON::ArrayOf<Inspector::Protocol::Debugger::Scope>> value)
3931 {
3932 JSON::ObjectBase::setArray("scopeChain"_s, WTFMove(value));
3933 }
3934};
3935
3936/* JavaScript call frame. Array of call frames form the call stack. */
3937class CallFrame : public JSON::ObjectBase {
3938public:
3939 enum {
3940 NoFieldsSet = 0,
3941 CallFrameIdSet = 1 << 0,
3942 FunctionNameSet = 1 << 1,
3943 LocationSet = 1 << 2,
3944 ScopeChainSet = 1 << 3,
3945 ThisSet = 1 << 4,
3946 IsTailDeletedSet = 1 << 5,
3947 AllFieldsSet = (CallFrameIdSet | FunctionNameSet | LocationSet | ScopeChainSet | ThisSet | IsTailDeletedSet)
3948 };
3949
3950 template<int STATE>
3951 class Builder {
3952 private:
3953 RefPtr<JSON::Object> m_result;
3954
3955 template<int STEP> Builder<STATE | STEP>& castState()
3956 {
3957 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
3958 }
3959
3960 Builder(Ref</*CallFrame*/JSON::Object>&& object)
3961 : m_result(WTFMove(object))
3962 {
3963 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
3964 }
3965 friend class CallFrame;
3966 public:
3967
3968 Builder<STATE | CallFrameIdSet>& setCallFrameId(const String& value)
3969 {
3970 COMPILE_ASSERT(!(STATE & CallFrameIdSet), property_callFrameId_already_set);
3971 m_result->setString("callFrameId"_s, value);
3972 return castState<CallFrameIdSet>();
3973 }
3974
3975 Builder<STATE | FunctionNameSet>& setFunctionName(const String& value)
3976 {
3977 COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set);
3978 m_result->setString("functionName"_s, value);
3979 return castState<FunctionNameSet>();
3980 }
3981
3982 Builder<STATE | LocationSet>& setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
3983 {
3984 COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set);
3985 m_result->setObject("location"_s, value);
3986 return castState<LocationSet>();
3987 }
3988
3989 Builder<STATE | ScopeChainSet>& setScopeChain(RefPtr<JSON::ArrayOf<Inspector::Protocol::Debugger::Scope>> value)
3990 {
3991 COMPILE_ASSERT(!(STATE & ScopeChainSet), property_scopeChain_already_set);
3992 m_result->setArray("scopeChain"_s, value);
3993 return castState<ScopeChainSet>();
3994 }
3995
3996 Builder<STATE | ThisSet>& setThis(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
3997 {
3998 COMPILE_ASSERT(!(STATE & ThisSet), property_this_already_set);
3999 m_result->setObject("this"_s, value);
4000 return castState<ThisSet>();
4001 }
4002
4003 Builder<STATE | IsTailDeletedSet>& setIsTailDeleted(bool value)
4004 {
4005 COMPILE_ASSERT(!(STATE & IsTailDeletedSet), property_isTailDeleted_already_set);
4006 m_result->setBoolean("isTailDeleted"_s, value);
4007 return castState<IsTailDeletedSet>();
4008 }
4009
4010 Ref<CallFrame> release()
4011 {
4012 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4013 COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast);
4014
4015 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4016 auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult));
4017 return result;
4018 }
4019 };
4020
4021 /*
4022 * Synthetic constructor:
4023 * Ref<CallFrame> result = CallFrame::create()
4024 * .setCallFrameId(...)
4025 * .setFunctionName(...)
4026 * .setLocation(...)
4027 * .setScopeChain(...)
4028 * .setThis(...)
4029 * .setIsTailDeleted(...)
4030 * .release();
4031 */
4032 static Builder<NoFieldsSet> create()
4033 {
4034 return Builder<NoFieldsSet>(JSON::Object::create());
4035 }
4036};
4037
4038/* Scope description. */
4039class Scope : public JSON::ObjectBase {
4040public:
4041 // Named after property name 'type' while generating Scope.
4042 enum class Type {
4043 Global = 97,
4044 With = 98,
4045 Closure = 99,
4046 Catch = 100,
4047 FunctionName = 101,
4048 GlobalLexicalEnvironment = 102,
4049 NestedLexical = 103,
4050 }; // enum class Type
4051 enum {
4052 NoFieldsSet = 0,
4053 ObjectSet = 1 << 0,
4054 TypeSet = 1 << 1,
4055 AllFieldsSet = (ObjectSet | TypeSet)
4056 };
4057
4058 template<int STATE>
4059 class Builder {
4060 private:
4061 RefPtr<JSON::Object> m_result;
4062
4063 template<int STEP> Builder<STATE | STEP>& castState()
4064 {
4065 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4066 }
4067
4068 Builder(Ref</*Scope*/JSON::Object>&& object)
4069 : m_result(WTFMove(object))
4070 {
4071 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4072 }
4073 friend class Scope;
4074 public:
4075
4076 Builder<STATE | ObjectSet>& setObject(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4077 {
4078 COMPILE_ASSERT(!(STATE & ObjectSet), property_object_already_set);
4079 m_result->setObject("object"_s, value);
4080 return castState<ObjectSet>();
4081 }
4082
4083 Builder<STATE | TypeSet>& setType(Type value)
4084 {
4085 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4086 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
4087 return castState<TypeSet>();
4088 }
4089
4090 Ref<Scope> release()
4091 {
4092 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4093 COMPILE_ASSERT(sizeof(Scope) == sizeof(JSON::Object), cannot_cast);
4094
4095 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4096 auto result = WTFMove(*reinterpret_cast<Ref<Scope>*>(&jsonResult));
4097 return result;
4098 }
4099 };
4100
4101 /*
4102 * Synthetic constructor:
4103 * Ref<Scope> result = Scope::create()
4104 * .setObject(...)
4105 * .setType(...)
4106 * .release();
4107 */
4108 static Builder<NoFieldsSet> create()
4109 {
4110 return Builder<NoFieldsSet>(JSON::Object::create());
4111 }
4112
4113 void setName(const String& value)
4114 {
4115 JSON::ObjectBase::setString("name"_s, value);
4116 }
4117
4118 void setLocation(RefPtr<Inspector::Protocol::Debugger::Location> value)
4119 {
4120 JSON::ObjectBase::setObject("location"_s, WTFMove(value));
4121 }
4122
4123 void setEmpty(bool value)
4124 {
4125 JSON::ObjectBase::setBoolean("empty"_s, value);
4126 }
4127};
4128
4129/* A sample collected by evaluating a probe breakpoint action. */
4130class ProbeSample : public JSON::ObjectBase {
4131public:
4132 enum {
4133 NoFieldsSet = 0,
4134 ProbeIdSet = 1 << 0,
4135 SampleIdSet = 1 << 1,
4136 BatchIdSet = 1 << 2,
4137 TimestampSet = 1 << 3,
4138 PayloadSet = 1 << 4,
4139 AllFieldsSet = (ProbeIdSet | SampleIdSet | BatchIdSet | TimestampSet | PayloadSet)
4140 };
4141
4142 template<int STATE>
4143 class Builder {
4144 private:
4145 RefPtr<JSON::Object> m_result;
4146
4147 template<int STEP> Builder<STATE | STEP>& castState()
4148 {
4149 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4150 }
4151
4152 Builder(Ref</*ProbeSample*/JSON::Object>&& object)
4153 : m_result(WTFMove(object))
4154 {
4155 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4156 }
4157 friend class ProbeSample;
4158 public:
4159
4160 Builder<STATE | ProbeIdSet>& setProbeId(int value)
4161 {
4162 COMPILE_ASSERT(!(STATE & ProbeIdSet), property_probeId_already_set);
4163 m_result->setInteger("probeId"_s, value);
4164 return castState<ProbeIdSet>();
4165 }
4166
4167 Builder<STATE | SampleIdSet>& setSampleId(int value)
4168 {
4169 COMPILE_ASSERT(!(STATE & SampleIdSet), property_sampleId_already_set);
4170 m_result->setInteger("sampleId"_s, value);
4171 return castState<SampleIdSet>();
4172 }
4173
4174 Builder<STATE | BatchIdSet>& setBatchId(int value)
4175 {
4176 COMPILE_ASSERT(!(STATE & BatchIdSet), property_batchId_already_set);
4177 m_result->setInteger("batchId"_s, value);
4178 return castState<BatchIdSet>();
4179 }
4180
4181 Builder<STATE | TimestampSet>& setTimestamp(double value)
4182 {
4183 COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
4184 m_result->setDouble("timestamp"_s, value);
4185 return castState<TimestampSet>();
4186 }
4187
4188 Builder<STATE | PayloadSet>& setPayload(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4189 {
4190 COMPILE_ASSERT(!(STATE & PayloadSet), property_payload_already_set);
4191 m_result->setObject("payload"_s, value);
4192 return castState<PayloadSet>();
4193 }
4194
4195 Ref<ProbeSample> release()
4196 {
4197 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4198 COMPILE_ASSERT(sizeof(ProbeSample) == sizeof(JSON::Object), cannot_cast);
4199
4200 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4201 auto result = WTFMove(*reinterpret_cast<Ref<ProbeSample>*>(&jsonResult));
4202 return result;
4203 }
4204 };
4205
4206 /*
4207 * Synthetic constructor:
4208 * Ref<ProbeSample> result = ProbeSample::create()
4209 * .setProbeId(...)
4210 * .setSampleId(...)
4211 * .setBatchId(...)
4212 * .setTimestamp(...)
4213 * .setPayload(...)
4214 * .release();
4215 */
4216 static Builder<NoFieldsSet> create()
4217 {
4218 return Builder<NoFieldsSet>(JSON::Object::create());
4219 }
4220};
4221
4222/* The pause reason auxiliary data when paused because of an assertion. */
4223class AssertPauseReason : public JSON::ObjectBase {
4224public:
4225 enum {
4226 NoFieldsSet = 0,
4227 AllFieldsSet = 0
4228 };
4229
4230 template<int STATE>
4231 class Builder {
4232 private:
4233 RefPtr<JSON::Object> m_result;
4234
4235 template<int STEP> Builder<STATE | STEP>& castState()
4236 {
4237 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4238 }
4239
4240 Builder(Ref</*AssertPauseReason*/JSON::Object>&& object)
4241 : m_result(WTFMove(object))
4242 {
4243 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4244 }
4245 friend class AssertPauseReason;
4246 public:
4247
4248 Ref<AssertPauseReason> release()
4249 {
4250 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4251 COMPILE_ASSERT(sizeof(AssertPauseReason) == sizeof(JSON::Object), cannot_cast);
4252
4253 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4254 auto result = WTFMove(*reinterpret_cast<Ref<AssertPauseReason>*>(&jsonResult));
4255 return result;
4256 }
4257 };
4258
4259 /*
4260 * Synthetic constructor:
4261 * Ref<AssertPauseReason> result = AssertPauseReason::create()
4262 * .release();
4263 */
4264 static Builder<NoFieldsSet> create()
4265 {
4266 return Builder<NoFieldsSet>(JSON::Object::create());
4267 }
4268
4269 void setMessage(const String& value)
4270 {
4271 JSON::ObjectBase::setString("message"_s, value);
4272 }
4273};
4274
4275/* The pause reason auxiliary data when paused because of hitting a breakpoint. */
4276class BreakpointPauseReason : public JSON::ObjectBase {
4277public:
4278 enum {
4279 NoFieldsSet = 0,
4280 BreakpointIdSet = 1 << 0,
4281 AllFieldsSet = (BreakpointIdSet)
4282 };
4283
4284 template<int STATE>
4285 class Builder {
4286 private:
4287 RefPtr<JSON::Object> m_result;
4288
4289 template<int STEP> Builder<STATE | STEP>& castState()
4290 {
4291 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4292 }
4293
4294 Builder(Ref</*BreakpointPauseReason*/JSON::Object>&& object)
4295 : m_result(WTFMove(object))
4296 {
4297 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4298 }
4299 friend class BreakpointPauseReason;
4300 public:
4301
4302 Builder<STATE | BreakpointIdSet>& setBreakpointId(const String& value)
4303 {
4304 COMPILE_ASSERT(!(STATE & BreakpointIdSet), property_breakpointId_already_set);
4305 m_result->setString("breakpointId"_s, value);
4306 return castState<BreakpointIdSet>();
4307 }
4308
4309 Ref<BreakpointPauseReason> release()
4310 {
4311 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4312 COMPILE_ASSERT(sizeof(BreakpointPauseReason) == sizeof(JSON::Object), cannot_cast);
4313
4314 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4315 auto result = WTFMove(*reinterpret_cast<Ref<BreakpointPauseReason>*>(&jsonResult));
4316 return result;
4317 }
4318 };
4319
4320 /*
4321 * Synthetic constructor:
4322 * Ref<BreakpointPauseReason> result = BreakpointPauseReason::create()
4323 * .setBreakpointId(...)
4324 * .release();
4325 */
4326 static Builder<NoFieldsSet> create()
4327 {
4328 return Builder<NoFieldsSet>(JSON::Object::create());
4329 }
4330};
4331
4332/* The pause reason auxiliary data when paused because of a Content Security Policy directive. */
4333class CSPViolationPauseReason : public JSON::ObjectBase {
4334public:
4335 enum {
4336 NoFieldsSet = 0,
4337 DirectiveSet = 1 << 0,
4338 AllFieldsSet = (DirectiveSet)
4339 };
4340
4341 template<int STATE>
4342 class Builder {
4343 private:
4344 RefPtr<JSON::Object> m_result;
4345
4346 template<int STEP> Builder<STATE | STEP>& castState()
4347 {
4348 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4349 }
4350
4351 Builder(Ref</*CSPViolationPauseReason*/JSON::Object>&& object)
4352 : m_result(WTFMove(object))
4353 {
4354 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4355 }
4356 friend class CSPViolationPauseReason;
4357 public:
4358
4359 Builder<STATE | DirectiveSet>& setDirective(const String& value)
4360 {
4361 COMPILE_ASSERT(!(STATE & DirectiveSet), property_directive_already_set);
4362 m_result->setString("directive"_s, value);
4363 return castState<DirectiveSet>();
4364 }
4365
4366 Ref<CSPViolationPauseReason> release()
4367 {
4368 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4369 COMPILE_ASSERT(sizeof(CSPViolationPauseReason) == sizeof(JSON::Object), cannot_cast);
4370
4371 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4372 auto result = WTFMove(*reinterpret_cast<Ref<CSPViolationPauseReason>*>(&jsonResult));
4373 return result;
4374 }
4375 };
4376
4377 /*
4378 * Synthetic constructor:
4379 * Ref<CSPViolationPauseReason> result = CSPViolationPauseReason::create()
4380 * .setDirective(...)
4381 * .release();
4382 */
4383 static Builder<NoFieldsSet> create()
4384 {
4385 return Builder<NoFieldsSet>(JSON::Object::create());
4386 }
4387};
4388
4389} // Debugger
4390
4391namespace GenericTypes {
4392/* Search match in a resource. */
4393class SearchMatch : public JSON::ObjectBase {
4394public:
4395 enum {
4396 NoFieldsSet = 0,
4397 LineNumberSet = 1 << 0,
4398 LineContentSet = 1 << 1,
4399 AllFieldsSet = (LineNumberSet | LineContentSet)
4400 };
4401
4402 template<int STATE>
4403 class Builder {
4404 private:
4405 RefPtr<JSON::Object> m_result;
4406
4407 template<int STEP> Builder<STATE | STEP>& castState()
4408 {
4409 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4410 }
4411
4412 Builder(Ref</*SearchMatch*/JSON::Object>&& object)
4413 : m_result(WTFMove(object))
4414 {
4415 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4416 }
4417 friend class SearchMatch;
4418 public:
4419
4420 Builder<STATE | LineNumberSet>& setLineNumber(double value)
4421 {
4422 COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set);
4423 m_result->setDouble("lineNumber"_s, value);
4424 return castState<LineNumberSet>();
4425 }
4426
4427 Builder<STATE | LineContentSet>& setLineContent(const String& value)
4428 {
4429 COMPILE_ASSERT(!(STATE & LineContentSet), property_lineContent_already_set);
4430 m_result->setString("lineContent"_s, value);
4431 return castState<LineContentSet>();
4432 }
4433
4434 Ref<SearchMatch> release()
4435 {
4436 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4437 COMPILE_ASSERT(sizeof(SearchMatch) == sizeof(JSON::Object), cannot_cast);
4438
4439 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4440 auto result = WTFMove(*reinterpret_cast<Ref<SearchMatch>*>(&jsonResult));
4441 return result;
4442 }
4443 };
4444
4445 /*
4446 * Synthetic constructor:
4447 * Ref<SearchMatch> result = SearchMatch::create()
4448 * .setLineNumber(...)
4449 * .setLineContent(...)
4450 * .release();
4451 */
4452 static Builder<NoFieldsSet> create()
4453 {
4454 return Builder<NoFieldsSet>(JSON::Object::create());
4455 }
4456};
4457
4458} // GenericTypes
4459
4460namespace Heap {
4461/* Information about a garbage collection. */
4462class GarbageCollection : public JSON::ObjectBase {
4463public:
4464 // Named after property name 'type' while generating GarbageCollection.
4465 enum class Type {
4466 Full = 104,
4467 Partial = 105,
4468 }; // enum class Type
4469 enum {
4470 NoFieldsSet = 0,
4471 TypeSet = 1 << 0,
4472 StartTimeSet = 1 << 1,
4473 EndTimeSet = 1 << 2,
4474 AllFieldsSet = (TypeSet | StartTimeSet | EndTimeSet)
4475 };
4476
4477 template<int STATE>
4478 class Builder {
4479 private:
4480 RefPtr<JSON::Object> m_result;
4481
4482 template<int STEP> Builder<STATE | STEP>& castState()
4483 {
4484 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4485 }
4486
4487 Builder(Ref</*GarbageCollection*/JSON::Object>&& object)
4488 : m_result(WTFMove(object))
4489 {
4490 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4491 }
4492 friend class GarbageCollection;
4493 public:
4494
4495 Builder<STATE | TypeSet>& setType(Type value)
4496 {
4497 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4498 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
4499 return castState<TypeSet>();
4500 }
4501
4502 Builder<STATE | StartTimeSet>& setStartTime(double value)
4503 {
4504 COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
4505 m_result->setDouble("startTime"_s, value);
4506 return castState<StartTimeSet>();
4507 }
4508
4509 Builder<STATE | EndTimeSet>& setEndTime(double value)
4510 {
4511 COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
4512 m_result->setDouble("endTime"_s, value);
4513 return castState<EndTimeSet>();
4514 }
4515
4516 Ref<GarbageCollection> release()
4517 {
4518 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4519 COMPILE_ASSERT(sizeof(GarbageCollection) == sizeof(JSON::Object), cannot_cast);
4520
4521 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4522 auto result = WTFMove(*reinterpret_cast<Ref<GarbageCollection>*>(&jsonResult));
4523 return result;
4524 }
4525 };
4526
4527 /*
4528 * Synthetic constructor:
4529 * Ref<GarbageCollection> result = GarbageCollection::create()
4530 * .setType(...)
4531 * .setStartTime(...)
4532 * .setEndTime(...)
4533 * .release();
4534 */
4535 static Builder<NoFieldsSet> create()
4536 {
4537 return Builder<NoFieldsSet>(JSON::Object::create());
4538 }
4539};
4540
4541} // Heap
4542
4543#if ENABLE(INDEXED_DATABASE)
4544namespace IndexedDB {
4545/* Database with an array of object stores. */
4546class DatabaseWithObjectStores : public JSON::ObjectBase {
4547public:
4548 enum {
4549 NoFieldsSet = 0,
4550 NameSet = 1 << 0,
4551 VersionSet = 1 << 1,
4552 ObjectStoresSet = 1 << 2,
4553 AllFieldsSet = (NameSet | VersionSet | ObjectStoresSet)
4554 };
4555
4556 template<int STATE>
4557 class Builder {
4558 private:
4559 RefPtr<JSON::Object> m_result;
4560
4561 template<int STEP> Builder<STATE | STEP>& castState()
4562 {
4563 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4564 }
4565
4566 Builder(Ref</*DatabaseWithObjectStores*/JSON::Object>&& object)
4567 : m_result(WTFMove(object))
4568 {
4569 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4570 }
4571 friend class DatabaseWithObjectStores;
4572 public:
4573
4574 Builder<STATE | NameSet>& setName(const String& value)
4575 {
4576 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4577 m_result->setString("name"_s, value);
4578 return castState<NameSet>();
4579 }
4580
4581 Builder<STATE | VersionSet>& setVersion(double value)
4582 {
4583 COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
4584 m_result->setDouble("version"_s, value);
4585 return castState<VersionSet>();
4586 }
4587
4588 Builder<STATE | ObjectStoresSet>& setObjectStores(RefPtr<JSON::ArrayOf<Inspector::Protocol::IndexedDB::ObjectStore>> value)
4589 {
4590 COMPILE_ASSERT(!(STATE & ObjectStoresSet), property_objectStores_already_set);
4591 m_result->setArray("objectStores"_s, value);
4592 return castState<ObjectStoresSet>();
4593 }
4594
4595 Ref<DatabaseWithObjectStores> release()
4596 {
4597 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4598 COMPILE_ASSERT(sizeof(DatabaseWithObjectStores) == sizeof(JSON::Object), cannot_cast);
4599
4600 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4601 auto result = WTFMove(*reinterpret_cast<Ref<DatabaseWithObjectStores>*>(&jsonResult));
4602 return result;
4603 }
4604 };
4605
4606 /*
4607 * Synthetic constructor:
4608 * Ref<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
4609 * .setName(...)
4610 * .setVersion(...)
4611 * .setObjectStores(...)
4612 * .release();
4613 */
4614 static Builder<NoFieldsSet> create()
4615 {
4616 return Builder<NoFieldsSet>(JSON::Object::create());
4617 }
4618};
4619
4620/* Object store. */
4621class ObjectStore : public JSON::ObjectBase {
4622public:
4623 enum {
4624 NoFieldsSet = 0,
4625 NameSet = 1 << 0,
4626 KeyPathSet = 1 << 1,
4627 AutoIncrementSet = 1 << 2,
4628 IndexesSet = 1 << 3,
4629 AllFieldsSet = (NameSet | KeyPathSet | AutoIncrementSet | IndexesSet)
4630 };
4631
4632 template<int STATE>
4633 class Builder {
4634 private:
4635 RefPtr<JSON::Object> m_result;
4636
4637 template<int STEP> Builder<STATE | STEP>& castState()
4638 {
4639 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4640 }
4641
4642 Builder(Ref</*ObjectStore*/JSON::Object>&& object)
4643 : m_result(WTFMove(object))
4644 {
4645 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4646 }
4647 friend class ObjectStore;
4648 public:
4649
4650 Builder<STATE | NameSet>& setName(const String& value)
4651 {
4652 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4653 m_result->setString("name"_s, value);
4654 return castState<NameSet>();
4655 }
4656
4657 Builder<STATE | KeyPathSet>& setKeyPath(RefPtr<Inspector::Protocol::IndexedDB::KeyPath> value)
4658 {
4659 COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
4660 m_result->setObject("keyPath"_s, value);
4661 return castState<KeyPathSet>();
4662 }
4663
4664 Builder<STATE | AutoIncrementSet>& setAutoIncrement(bool value)
4665 {
4666 COMPILE_ASSERT(!(STATE & AutoIncrementSet), property_autoIncrement_already_set);
4667 m_result->setBoolean("autoIncrement"_s, value);
4668 return castState<AutoIncrementSet>();
4669 }
4670
4671 Builder<STATE | IndexesSet>& setIndexes(RefPtr<JSON::ArrayOf<Inspector::Protocol::IndexedDB::ObjectStoreIndex>> value)
4672 {
4673 COMPILE_ASSERT(!(STATE & IndexesSet), property_indexes_already_set);
4674 m_result->setArray("indexes"_s, value);
4675 return castState<IndexesSet>();
4676 }
4677
4678 Ref<ObjectStore> release()
4679 {
4680 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4681 COMPILE_ASSERT(sizeof(ObjectStore) == sizeof(JSON::Object), cannot_cast);
4682
4683 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4684 auto result = WTFMove(*reinterpret_cast<Ref<ObjectStore>*>(&jsonResult));
4685 return result;
4686 }
4687 };
4688
4689 /*
4690 * Synthetic constructor:
4691 * Ref<ObjectStore> result = ObjectStore::create()
4692 * .setName(...)
4693 * .setKeyPath(...)
4694 * .setAutoIncrement(...)
4695 * .setIndexes(...)
4696 * .release();
4697 */
4698 static Builder<NoFieldsSet> create()
4699 {
4700 return Builder<NoFieldsSet>(JSON::Object::create());
4701 }
4702};
4703
4704/* Object store index. */
4705class ObjectStoreIndex : public JSON::ObjectBase {
4706public:
4707 enum {
4708 NoFieldsSet = 0,
4709 NameSet = 1 << 0,
4710 KeyPathSet = 1 << 1,
4711 UniqueSet = 1 << 2,
4712 MultiEntrySet = 1 << 3,
4713 AllFieldsSet = (NameSet | KeyPathSet | UniqueSet | MultiEntrySet)
4714 };
4715
4716 template<int STATE>
4717 class Builder {
4718 private:
4719 RefPtr<JSON::Object> m_result;
4720
4721 template<int STEP> Builder<STATE | STEP>& castState()
4722 {
4723 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4724 }
4725
4726 Builder(Ref</*ObjectStoreIndex*/JSON::Object>&& object)
4727 : m_result(WTFMove(object))
4728 {
4729 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4730 }
4731 friend class ObjectStoreIndex;
4732 public:
4733
4734 Builder<STATE | NameSet>& setName(const String& value)
4735 {
4736 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
4737 m_result->setString("name"_s, value);
4738 return castState<NameSet>();
4739 }
4740
4741 Builder<STATE | KeyPathSet>& setKeyPath(RefPtr<Inspector::Protocol::IndexedDB::KeyPath> value)
4742 {
4743 COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set);
4744 m_result->setObject("keyPath"_s, value);
4745 return castState<KeyPathSet>();
4746 }
4747
4748 Builder<STATE | UniqueSet>& setUnique(bool value)
4749 {
4750 COMPILE_ASSERT(!(STATE & UniqueSet), property_unique_already_set);
4751 m_result->setBoolean("unique"_s, value);
4752 return castState<UniqueSet>();
4753 }
4754
4755 Builder<STATE | MultiEntrySet>& setMultiEntry(bool value)
4756 {
4757 COMPILE_ASSERT(!(STATE & MultiEntrySet), property_multiEntry_already_set);
4758 m_result->setBoolean("multiEntry"_s, value);
4759 return castState<MultiEntrySet>();
4760 }
4761
4762 Ref<ObjectStoreIndex> release()
4763 {
4764 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4765 COMPILE_ASSERT(sizeof(ObjectStoreIndex) == sizeof(JSON::Object), cannot_cast);
4766
4767 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4768 auto result = WTFMove(*reinterpret_cast<Ref<ObjectStoreIndex>*>(&jsonResult));
4769 return result;
4770 }
4771 };
4772
4773 /*
4774 * Synthetic constructor:
4775 * Ref<ObjectStoreIndex> result = ObjectStoreIndex::create()
4776 * .setName(...)
4777 * .setKeyPath(...)
4778 * .setUnique(...)
4779 * .setMultiEntry(...)
4780 * .release();
4781 */
4782 static Builder<NoFieldsSet> create()
4783 {
4784 return Builder<NoFieldsSet>(JSON::Object::create());
4785 }
4786};
4787
4788/* Key. */
4789class Key : public JSON::ObjectBase {
4790public:
4791 // Named after property name 'type' while generating Key.
4792 enum class Type {
4793 Number = 106,
4794 String = 107,
4795 Date = 82,
4796 Array = 108,
4797 }; // enum class Type
4798 enum {
4799 NoFieldsSet = 0,
4800 TypeSet = 1 << 0,
4801 AllFieldsSet = (TypeSet)
4802 };
4803
4804 template<int STATE>
4805 class Builder {
4806 private:
4807 RefPtr<JSON::Object> m_result;
4808
4809 template<int STEP> Builder<STATE | STEP>& castState()
4810 {
4811 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4812 }
4813
4814 Builder(Ref</*Key*/JSON::Object>&& object)
4815 : m_result(WTFMove(object))
4816 {
4817 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4818 }
4819 friend class Key;
4820 public:
4821
4822 Builder<STATE | TypeSet>& setType(Type value)
4823 {
4824 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
4825 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
4826 return castState<TypeSet>();
4827 }
4828
4829 Ref<Key> release()
4830 {
4831 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4832 COMPILE_ASSERT(sizeof(Key) == sizeof(JSON::Object), cannot_cast);
4833
4834 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4835 auto result = WTFMove(*reinterpret_cast<Ref<Key>*>(&jsonResult));
4836 return result;
4837 }
4838 };
4839
4840 /*
4841 * Synthetic constructor:
4842 * Ref<Key> result = Key::create()
4843 * .setType(...)
4844 * .release();
4845 */
4846 static Builder<NoFieldsSet> create()
4847 {
4848 return Builder<NoFieldsSet>(JSON::Object::create());
4849 }
4850
4851 void setNumber(double value)
4852 {
4853 JSON::ObjectBase::setDouble("number"_s, value);
4854 }
4855
4856 void setString(const String& value)
4857 {
4858 JSON::ObjectBase::setString("string"_s, value);
4859 }
4860
4861 void setDate(double value)
4862 {
4863 JSON::ObjectBase::setDouble("date"_s, value);
4864 }
4865
4866 void setArray(RefPtr<JSON::ArrayOf<Inspector::Protocol::IndexedDB::Key>> value)
4867 {
4868 JSON::ObjectBase::setArray("array"_s, WTFMove(value));
4869 }
4870};
4871
4872/* Key range. */
4873class KeyRange : public JSON::ObjectBase {
4874public:
4875 enum {
4876 NoFieldsSet = 0,
4877 LowerOpenSet = 1 << 0,
4878 UpperOpenSet = 1 << 1,
4879 AllFieldsSet = (LowerOpenSet | UpperOpenSet)
4880 };
4881
4882 template<int STATE>
4883 class Builder {
4884 private:
4885 RefPtr<JSON::Object> m_result;
4886
4887 template<int STEP> Builder<STATE | STEP>& castState()
4888 {
4889 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4890 }
4891
4892 Builder(Ref</*KeyRange*/JSON::Object>&& object)
4893 : m_result(WTFMove(object))
4894 {
4895 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4896 }
4897 friend class KeyRange;
4898 public:
4899
4900 Builder<STATE | LowerOpenSet>& setLowerOpen(bool value)
4901 {
4902 COMPILE_ASSERT(!(STATE & LowerOpenSet), property_lowerOpen_already_set);
4903 m_result->setBoolean("lowerOpen"_s, value);
4904 return castState<LowerOpenSet>();
4905 }
4906
4907 Builder<STATE | UpperOpenSet>& setUpperOpen(bool value)
4908 {
4909 COMPILE_ASSERT(!(STATE & UpperOpenSet), property_upperOpen_already_set);
4910 m_result->setBoolean("upperOpen"_s, value);
4911 return castState<UpperOpenSet>();
4912 }
4913
4914 Ref<KeyRange> release()
4915 {
4916 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
4917 COMPILE_ASSERT(sizeof(KeyRange) == sizeof(JSON::Object), cannot_cast);
4918
4919 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
4920 auto result = WTFMove(*reinterpret_cast<Ref<KeyRange>*>(&jsonResult));
4921 return result;
4922 }
4923 };
4924
4925 /*
4926 * Synthetic constructor:
4927 * Ref<KeyRange> result = KeyRange::create()
4928 * .setLowerOpen(...)
4929 * .setUpperOpen(...)
4930 * .release();
4931 */
4932 static Builder<NoFieldsSet> create()
4933 {
4934 return Builder<NoFieldsSet>(JSON::Object::create());
4935 }
4936
4937 void setLower(RefPtr<Inspector::Protocol::IndexedDB::Key> value)
4938 {
4939 JSON::ObjectBase::setObject("lower"_s, WTFMove(value));
4940 }
4941
4942 void setUpper(RefPtr<Inspector::Protocol::IndexedDB::Key> value)
4943 {
4944 JSON::ObjectBase::setObject("upper"_s, WTFMove(value));
4945 }
4946};
4947
4948/* Data entry. */
4949class DataEntry : public JSON::ObjectBase {
4950public:
4951 enum {
4952 NoFieldsSet = 0,
4953 KeySet = 1 << 0,
4954 PrimaryKeySet = 1 << 1,
4955 ValueSet = 1 << 2,
4956 AllFieldsSet = (KeySet | PrimaryKeySet | ValueSet)
4957 };
4958
4959 template<int STATE>
4960 class Builder {
4961 private:
4962 RefPtr<JSON::Object> m_result;
4963
4964 template<int STEP> Builder<STATE | STEP>& castState()
4965 {
4966 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
4967 }
4968
4969 Builder(Ref</*DataEntry*/JSON::Object>&& object)
4970 : m_result(WTFMove(object))
4971 {
4972 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
4973 }
4974 friend class DataEntry;
4975 public:
4976
4977 Builder<STATE | KeySet>& setKey(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4978 {
4979 COMPILE_ASSERT(!(STATE & KeySet), property_key_already_set);
4980 m_result->setObject("key"_s, value);
4981 return castState<KeySet>();
4982 }
4983
4984 Builder<STATE | PrimaryKeySet>& setPrimaryKey(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4985 {
4986 COMPILE_ASSERT(!(STATE & PrimaryKeySet), property_primaryKey_already_set);
4987 m_result->setObject("primaryKey"_s, value);
4988 return castState<PrimaryKeySet>();
4989 }
4990
4991 Builder<STATE | ValueSet>& setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
4992 {
4993 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
4994 m_result->setObject("value"_s, value);
4995 return castState<ValueSet>();
4996 }
4997
4998 Ref<DataEntry> release()
4999 {
5000 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5001 COMPILE_ASSERT(sizeof(DataEntry) == sizeof(JSON::Object), cannot_cast);
5002
5003 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5004 auto result = WTFMove(*reinterpret_cast<Ref<DataEntry>*>(&jsonResult));
5005 return result;
5006 }
5007 };
5008
5009 /*
5010 * Synthetic constructor:
5011 * Ref<DataEntry> result = DataEntry::create()
5012 * .setKey(...)
5013 * .setPrimaryKey(...)
5014 * .setValue(...)
5015 * .release();
5016 */
5017 static Builder<NoFieldsSet> create()
5018 {
5019 return Builder<NoFieldsSet>(JSON::Object::create());
5020 }
5021};
5022
5023/* Key path. */
5024class KeyPath : public JSON::ObjectBase {
5025public:
5026 // Named after property name 'type' while generating KeyPath.
5027 enum class Type {
5028 Null = 109,
5029 String = 107,
5030 Array = 108,
5031 }; // enum class Type
5032 enum {
5033 NoFieldsSet = 0,
5034 TypeSet = 1 << 0,
5035 AllFieldsSet = (TypeSet)
5036 };
5037
5038 template<int STATE>
5039 class Builder {
5040 private:
5041 RefPtr<JSON::Object> m_result;
5042
5043 template<int STEP> Builder<STATE | STEP>& castState()
5044 {
5045 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5046 }
5047
5048 Builder(Ref</*KeyPath*/JSON::Object>&& object)
5049 : m_result(WTFMove(object))
5050 {
5051 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5052 }
5053 friend class KeyPath;
5054 public:
5055
5056 Builder<STATE | TypeSet>& setType(Type value)
5057 {
5058 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
5059 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
5060 return castState<TypeSet>();
5061 }
5062
5063 Ref<KeyPath> release()
5064 {
5065 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5066 COMPILE_ASSERT(sizeof(KeyPath) == sizeof(JSON::Object), cannot_cast);
5067
5068 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5069 auto result = WTFMove(*reinterpret_cast<Ref<KeyPath>*>(&jsonResult));
5070 return result;
5071 }
5072 };
5073
5074 /*
5075 * Synthetic constructor:
5076 * Ref<KeyPath> result = KeyPath::create()
5077 * .setType(...)
5078 * .release();
5079 */
5080 static Builder<NoFieldsSet> create()
5081 {
5082 return Builder<NoFieldsSet>(JSON::Object::create());
5083 }
5084
5085 void setString(const String& value)
5086 {
5087 JSON::ObjectBase::setString("string"_s, value);
5088 }
5089
5090 void setArray(RefPtr<JSON::ArrayOf<String>> value)
5091 {
5092 JSON::ObjectBase::setArray("array"_s, WTFMove(value));
5093 }
5094};
5095
5096} // IndexedDB
5097#endif // ENABLE(INDEXED_DATABASE)
5098
5099namespace LayerTree {
5100/* A rectangle. */
5101class IntRect : public JSON::ObjectBase {
5102public:
5103 enum {
5104 NoFieldsSet = 0,
5105 XSet = 1 << 0,
5106 YSet = 1 << 1,
5107 WidthSet = 1 << 2,
5108 HeightSet = 1 << 3,
5109 AllFieldsSet = (XSet | YSet | WidthSet | HeightSet)
5110 };
5111
5112 template<int STATE>
5113 class Builder {
5114 private:
5115 RefPtr<JSON::Object> m_result;
5116
5117 template<int STEP> Builder<STATE | STEP>& castState()
5118 {
5119 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5120 }
5121
5122 Builder(Ref</*IntRect*/JSON::Object>&& object)
5123 : m_result(WTFMove(object))
5124 {
5125 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5126 }
5127 friend class IntRect;
5128 public:
5129
5130 Builder<STATE | XSet>& setX(int value)
5131 {
5132 COMPILE_ASSERT(!(STATE & XSet), property_x_already_set);
5133 m_result->setInteger("x"_s, value);
5134 return castState<XSet>();
5135 }
5136
5137 Builder<STATE | YSet>& setY(int value)
5138 {
5139 COMPILE_ASSERT(!(STATE & YSet), property_y_already_set);
5140 m_result->setInteger("y"_s, value);
5141 return castState<YSet>();
5142 }
5143
5144 Builder<STATE | WidthSet>& setWidth(int value)
5145 {
5146 COMPILE_ASSERT(!(STATE & WidthSet), property_width_already_set);
5147 m_result->setInteger("width"_s, value);
5148 return castState<WidthSet>();
5149 }
5150
5151 Builder<STATE | HeightSet>& setHeight(int value)
5152 {
5153 COMPILE_ASSERT(!(STATE & HeightSet), property_height_already_set);
5154 m_result->setInteger("height"_s, value);
5155 return castState<HeightSet>();
5156 }
5157
5158 Ref<IntRect> release()
5159 {
5160 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5161 COMPILE_ASSERT(sizeof(IntRect) == sizeof(JSON::Object), cannot_cast);
5162
5163 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5164 auto result = WTFMove(*reinterpret_cast<Ref<IntRect>*>(&jsonResult));
5165 return result;
5166 }
5167 };
5168
5169 /*
5170 * Synthetic constructor:
5171 * Ref<IntRect> result = IntRect::create()
5172 * .setX(...)
5173 * .setY(...)
5174 * .setWidth(...)
5175 * .setHeight(...)
5176 * .release();
5177 */
5178 static Builder<NoFieldsSet> create()
5179 {
5180 return Builder<NoFieldsSet>(JSON::Object::create());
5181 }
5182};
5183
5184/* Information about a compositing layer. */
5185class Layer : public JSON::ObjectBase {
5186public:
5187 enum {
5188 NoFieldsSet = 0,
5189 LayerIdSet = 1 << 0,
5190 NodeIdSet = 1 << 1,
5191 BoundsSet = 1 << 2,
5192 PaintCountSet = 1 << 3,
5193 MemorySet = 1 << 4,
5194 CompositedBoundsSet = 1 << 5,
5195 AllFieldsSet = (LayerIdSet | NodeIdSet | BoundsSet | PaintCountSet | MemorySet | CompositedBoundsSet)
5196 };
5197
5198 template<int STATE>
5199 class Builder {
5200 private:
5201 RefPtr<JSON::Object> m_result;
5202
5203 template<int STEP> Builder<STATE | STEP>& castState()
5204 {
5205 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5206 }
5207
5208 Builder(Ref</*Layer*/JSON::Object>&& object)
5209 : m_result(WTFMove(object))
5210 {
5211 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5212 }
5213 friend class Layer;
5214 public:
5215
5216 Builder<STATE | LayerIdSet>& setLayerId(const String& value)
5217 {
5218 COMPILE_ASSERT(!(STATE & LayerIdSet), property_layerId_already_set);
5219 m_result->setString("layerId"_s, value);
5220 return castState<LayerIdSet>();
5221 }
5222
5223 Builder<STATE | NodeIdSet>& setNodeId(int value)
5224 {
5225 COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set);
5226 m_result->setInteger("nodeId"_s, value);
5227 return castState<NodeIdSet>();
5228 }
5229
5230 Builder<STATE | BoundsSet>& setBounds(RefPtr<Inspector::Protocol::LayerTree::IntRect> value)
5231 {
5232 COMPILE_ASSERT(!(STATE & BoundsSet), property_bounds_already_set);
5233 m_result->setObject("bounds"_s, value);
5234 return castState<BoundsSet>();
5235 }
5236
5237 Builder<STATE | PaintCountSet>& setPaintCount(int value)
5238 {
5239 COMPILE_ASSERT(!(STATE & PaintCountSet), property_paintCount_already_set);
5240 m_result->setInteger("paintCount"_s, value);
5241 return castState<PaintCountSet>();
5242 }
5243
5244 Builder<STATE | MemorySet>& setMemory(int value)
5245 {
5246 COMPILE_ASSERT(!(STATE & MemorySet), property_memory_already_set);
5247 m_result->setInteger("memory"_s, value);
5248 return castState<MemorySet>();
5249 }
5250
5251 Builder<STATE | CompositedBoundsSet>& setCompositedBounds(RefPtr<Inspector::Protocol::LayerTree::IntRect> value)
5252 {
5253 COMPILE_ASSERT(!(STATE & CompositedBoundsSet), property_compositedBounds_already_set);
5254 m_result->setObject("compositedBounds"_s, value);
5255 return castState<CompositedBoundsSet>();
5256 }
5257
5258 Ref<Layer> release()
5259 {
5260 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5261 COMPILE_ASSERT(sizeof(Layer) == sizeof(JSON::Object), cannot_cast);
5262
5263 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5264 auto result = WTFMove(*reinterpret_cast<Ref<Layer>*>(&jsonResult));
5265 return result;
5266 }
5267 };
5268
5269 /*
5270 * Synthetic constructor:
5271 * Ref<Layer> result = Layer::create()
5272 * .setLayerId(...)
5273 * .setNodeId(...)
5274 * .setBounds(...)
5275 * .setPaintCount(...)
5276 * .setMemory(...)
5277 * .setCompositedBounds(...)
5278 * .release();
5279 */
5280 static Builder<NoFieldsSet> create()
5281 {
5282 return Builder<NoFieldsSet>(JSON::Object::create());
5283 }
5284
5285 void setIsInShadowTree(bool value)
5286 {
5287 JSON::ObjectBase::setBoolean("isInShadowTree"_s, value);
5288 }
5289
5290 void setIsReflection(bool value)
5291 {
5292 JSON::ObjectBase::setBoolean("isReflection"_s, value);
5293 }
5294
5295 void setIsGeneratedContent(bool value)
5296 {
5297 JSON::ObjectBase::setBoolean("isGeneratedContent"_s, value);
5298 }
5299
5300 void setIsAnonymous(bool value)
5301 {
5302 JSON::ObjectBase::setBoolean("isAnonymous"_s, value);
5303 }
5304
5305 void setPseudoElementId(const String& value)
5306 {
5307 JSON::ObjectBase::setString("pseudoElementId"_s, value);
5308 }
5309
5310 void setPseudoElement(const String& value)
5311 {
5312 JSON::ObjectBase::setString("pseudoElement"_s, value);
5313 }
5314};
5315
5316/* An object containing the reasons why the layer was composited as properties. */
5317class CompositingReasons : public JSON::ObjectBase {
5318public:
5319 enum {
5320 NoFieldsSet = 0,
5321 AllFieldsSet = 0
5322 };
5323
5324 template<int STATE>
5325 class Builder {
5326 private:
5327 RefPtr<JSON::Object> m_result;
5328
5329 template<int STEP> Builder<STATE | STEP>& castState()
5330 {
5331 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5332 }
5333
5334 Builder(Ref</*CompositingReasons*/JSON::Object>&& object)
5335 : m_result(WTFMove(object))
5336 {
5337 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5338 }
5339 friend class CompositingReasons;
5340 public:
5341
5342 Ref<CompositingReasons> release()
5343 {
5344 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5345 COMPILE_ASSERT(sizeof(CompositingReasons) == sizeof(JSON::Object), cannot_cast);
5346
5347 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5348 auto result = WTFMove(*reinterpret_cast<Ref<CompositingReasons>*>(&jsonResult));
5349 return result;
5350 }
5351 };
5352
5353 /*
5354 * Synthetic constructor:
5355 * Ref<CompositingReasons> result = CompositingReasons::create()
5356 * .release();
5357 */
5358 static Builder<NoFieldsSet> create()
5359 {
5360 return Builder<NoFieldsSet>(JSON::Object::create());
5361 }
5362
5363 void setTransform3D(bool value)
5364 {
5365 JSON::ObjectBase::setBoolean("transform3D"_s, value);
5366 }
5367
5368 void setVideo(bool value)
5369 {
5370 JSON::ObjectBase::setBoolean("video"_s, value);
5371 }
5372
5373 void setCanvas(bool value)
5374 {
5375 JSON::ObjectBase::setBoolean("canvas"_s, value);
5376 }
5377
5378 void setPlugin(bool value)
5379 {
5380 JSON::ObjectBase::setBoolean("plugin"_s, value);
5381 }
5382
5383 void setIFrame(bool value)
5384 {
5385 JSON::ObjectBase::setBoolean("iFrame"_s, value);
5386 }
5387
5388 void setBackfaceVisibilityHidden(bool value)
5389 {
5390 JSON::ObjectBase::setBoolean("backfaceVisibilityHidden"_s, value);
5391 }
5392
5393 void setClipsCompositingDescendants(bool value)
5394 {
5395 JSON::ObjectBase::setBoolean("clipsCompositingDescendants"_s, value);
5396 }
5397
5398 void setAnimation(bool value)
5399 {
5400 JSON::ObjectBase::setBoolean("animation"_s, value);
5401 }
5402
5403 void setFilters(bool value)
5404 {
5405 JSON::ObjectBase::setBoolean("filters"_s, value);
5406 }
5407
5408 void setPositionFixed(bool value)
5409 {
5410 JSON::ObjectBase::setBoolean("positionFixed"_s, value);
5411 }
5412
5413 void setPositionSticky(bool value)
5414 {
5415 JSON::ObjectBase::setBoolean("positionSticky"_s, value);
5416 }
5417
5418 void setOverflowScrollingTouch(bool value)
5419 {
5420 JSON::ObjectBase::setBoolean("overflowScrollingTouch"_s, value);
5421 }
5422
5423 void setStacking(bool value)
5424 {
5425 JSON::ObjectBase::setBoolean("stacking"_s, value);
5426 }
5427
5428 void setOverlap(bool value)
5429 {
5430 JSON::ObjectBase::setBoolean("overlap"_s, value);
5431 }
5432
5433 void setNegativeZIndexChildren(bool value)
5434 {
5435 JSON::ObjectBase::setBoolean("negativeZIndexChildren"_s, value);
5436 }
5437
5438 void setTransformWithCompositedDescendants(bool value)
5439 {
5440 JSON::ObjectBase::setBoolean("transformWithCompositedDescendants"_s, value);
5441 }
5442
5443 void setOpacityWithCompositedDescendants(bool value)
5444 {
5445 JSON::ObjectBase::setBoolean("opacityWithCompositedDescendants"_s, value);
5446 }
5447
5448 void setMaskWithCompositedDescendants(bool value)
5449 {
5450 JSON::ObjectBase::setBoolean("maskWithCompositedDescendants"_s, value);
5451 }
5452
5453 void setReflectionWithCompositedDescendants(bool value)
5454 {
5455 JSON::ObjectBase::setBoolean("reflectionWithCompositedDescendants"_s, value);
5456 }
5457
5458 void setFilterWithCompositedDescendants(bool value)
5459 {
5460 JSON::ObjectBase::setBoolean("filterWithCompositedDescendants"_s, value);
5461 }
5462
5463 void setBlendingWithCompositedDescendants(bool value)
5464 {
5465 JSON::ObjectBase::setBoolean("blendingWithCompositedDescendants"_s, value);
5466 }
5467
5468 void setIsolatesCompositedBlendingDescendants(bool value)
5469 {
5470 JSON::ObjectBase::setBoolean("isolatesCompositedBlendingDescendants"_s, value);
5471 }
5472
5473 void setPerspective(bool value)
5474 {
5475 JSON::ObjectBase::setBoolean("perspective"_s, value);
5476 }
5477
5478 void setPreserve3D(bool value)
5479 {
5480 JSON::ObjectBase::setBoolean("preserve3D"_s, value);
5481 }
5482
5483 void setWillChange(bool value)
5484 {
5485 JSON::ObjectBase::setBoolean("willChange"_s, value);
5486 }
5487
5488 void setRoot(bool value)
5489 {
5490 JSON::ObjectBase::setBoolean("root"_s, value);
5491 }
5492
5493 void setBlending(bool value)
5494 {
5495 JSON::ObjectBase::setBoolean("blending"_s, value);
5496 }
5497};
5498
5499} // LayerTree
5500
5501namespace Network {
5502/* Timing information for the request. */
5503class ResourceTiming : public JSON::ObjectBase {
5504public:
5505 enum {
5506 NoFieldsSet = 0,
5507 StartTimeSet = 1 << 0,
5508 RedirectStartSet = 1 << 1,
5509 RedirectEndSet = 1 << 2,
5510 FetchStartSet = 1 << 3,
5511 DomainLookupStartSet = 1 << 4,
5512 DomainLookupEndSet = 1 << 5,
5513 ConnectStartSet = 1 << 6,
5514 ConnectEndSet = 1 << 7,
5515 SecureConnectionStartSet = 1 << 8,
5516 RequestStartSet = 1 << 9,
5517 ResponseStartSet = 1 << 10,
5518 ResponseEndSet = 1 << 11,
5519 AllFieldsSet = (StartTimeSet | RedirectStartSet | RedirectEndSet | FetchStartSet | DomainLookupStartSet | DomainLookupEndSet | ConnectStartSet | ConnectEndSet | SecureConnectionStartSet | RequestStartSet | ResponseStartSet | ResponseEndSet)
5520 };
5521
5522 template<int STATE>
5523 class Builder {
5524 private:
5525 RefPtr<JSON::Object> m_result;
5526
5527 template<int STEP> Builder<STATE | STEP>& castState()
5528 {
5529 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5530 }
5531
5532 Builder(Ref</*ResourceTiming*/JSON::Object>&& object)
5533 : m_result(WTFMove(object))
5534 {
5535 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5536 }
5537 friend class ResourceTiming;
5538 public:
5539
5540 Builder<STATE | StartTimeSet>& setStartTime(double value)
5541 {
5542 COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
5543 m_result->setDouble("startTime"_s, value);
5544 return castState<StartTimeSet>();
5545 }
5546
5547 Builder<STATE | RedirectStartSet>& setRedirectStart(double value)
5548 {
5549 COMPILE_ASSERT(!(STATE & RedirectStartSet), property_redirectStart_already_set);
5550 m_result->setDouble("redirectStart"_s, value);
5551 return castState<RedirectStartSet>();
5552 }
5553
5554 Builder<STATE | RedirectEndSet>& setRedirectEnd(double value)
5555 {
5556 COMPILE_ASSERT(!(STATE & RedirectEndSet), property_redirectEnd_already_set);
5557 m_result->setDouble("redirectEnd"_s, value);
5558 return castState<RedirectEndSet>();
5559 }
5560
5561 Builder<STATE | FetchStartSet>& setFetchStart(double value)
5562 {
5563 COMPILE_ASSERT(!(STATE & FetchStartSet), property_fetchStart_already_set);
5564 m_result->setDouble("fetchStart"_s, value);
5565 return castState<FetchStartSet>();
5566 }
5567
5568 Builder<STATE | DomainLookupStartSet>& setDomainLookupStart(double value)
5569 {
5570 COMPILE_ASSERT(!(STATE & DomainLookupStartSet), property_domainLookupStart_already_set);
5571 m_result->setDouble("domainLookupStart"_s, value);
5572 return castState<DomainLookupStartSet>();
5573 }
5574
5575 Builder<STATE | DomainLookupEndSet>& setDomainLookupEnd(double value)
5576 {
5577 COMPILE_ASSERT(!(STATE & DomainLookupEndSet), property_domainLookupEnd_already_set);
5578 m_result->setDouble("domainLookupEnd"_s, value);
5579 return castState<DomainLookupEndSet>();
5580 }
5581
5582 Builder<STATE | ConnectStartSet>& setConnectStart(double value)
5583 {
5584 COMPILE_ASSERT(!(STATE & ConnectStartSet), property_connectStart_already_set);
5585 m_result->setDouble("connectStart"_s, value);
5586 return castState<ConnectStartSet>();
5587 }
5588
5589 Builder<STATE | ConnectEndSet>& setConnectEnd(double value)
5590 {
5591 COMPILE_ASSERT(!(STATE & ConnectEndSet), property_connectEnd_already_set);
5592 m_result->setDouble("connectEnd"_s, value);
5593 return castState<ConnectEndSet>();
5594 }
5595
5596 Builder<STATE | SecureConnectionStartSet>& setSecureConnectionStart(double value)
5597 {
5598 COMPILE_ASSERT(!(STATE & SecureConnectionStartSet), property_secureConnectionStart_already_set);
5599 m_result->setDouble("secureConnectionStart"_s, value);
5600 return castState<SecureConnectionStartSet>();
5601 }
5602
5603 Builder<STATE | RequestStartSet>& setRequestStart(double value)
5604 {
5605 COMPILE_ASSERT(!(STATE & RequestStartSet), property_requestStart_already_set);
5606 m_result->setDouble("requestStart"_s, value);
5607 return castState<RequestStartSet>();
5608 }
5609
5610 Builder<STATE | ResponseStartSet>& setResponseStart(double value)
5611 {
5612 COMPILE_ASSERT(!(STATE & ResponseStartSet), property_responseStart_already_set);
5613 m_result->setDouble("responseStart"_s, value);
5614 return castState<ResponseStartSet>();
5615 }
5616
5617 Builder<STATE | ResponseEndSet>& setResponseEnd(double value)
5618 {
5619 COMPILE_ASSERT(!(STATE & ResponseEndSet), property_responseEnd_already_set);
5620 m_result->setDouble("responseEnd"_s, value);
5621 return castState<ResponseEndSet>();
5622 }
5623
5624 Ref<ResourceTiming> release()
5625 {
5626 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5627 COMPILE_ASSERT(sizeof(ResourceTiming) == sizeof(JSON::Object), cannot_cast);
5628
5629 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5630 auto result = WTFMove(*reinterpret_cast<Ref<ResourceTiming>*>(&jsonResult));
5631 return result;
5632 }
5633 };
5634
5635 /*
5636 * Synthetic constructor:
5637 * Ref<ResourceTiming> result = ResourceTiming::create()
5638 * .setStartTime(...)
5639 * .setRedirectStart(...)
5640 * .setRedirectEnd(...)
5641 * .setFetchStart(...)
5642 * .setDomainLookupStart(...)
5643 * .setDomainLookupEnd(...)
5644 * .setConnectStart(...)
5645 * .setConnectEnd(...)
5646 * .setSecureConnectionStart(...)
5647 * .setRequestStart(...)
5648 * .setResponseStart(...)
5649 * .setResponseEnd(...)
5650 * .release();
5651 */
5652 static Builder<NoFieldsSet> create()
5653 {
5654 return Builder<NoFieldsSet>(JSON::Object::create());
5655 }
5656};
5657
5658/* HTTP request data. */
5659class Request : public JSON::ObjectBase {
5660public:
5661 enum {
5662 NoFieldsSet = 0,
5663 UrlSet = 1 << 0,
5664 MethodSet = 1 << 1,
5665 HeadersSet = 1 << 2,
5666 AllFieldsSet = (UrlSet | MethodSet | HeadersSet)
5667 };
5668
5669 template<int STATE>
5670 class Builder {
5671 private:
5672 RefPtr<JSON::Object> m_result;
5673
5674 template<int STEP> Builder<STATE | STEP>& castState()
5675 {
5676 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5677 }
5678
5679 Builder(Ref</*Request*/JSON::Object>&& object)
5680 : m_result(WTFMove(object))
5681 {
5682 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5683 }
5684 friend class Request;
5685 public:
5686
5687 Builder<STATE | UrlSet>& setUrl(const String& value)
5688 {
5689 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
5690 m_result->setString("url"_s, value);
5691 return castState<UrlSet>();
5692 }
5693
5694 Builder<STATE | MethodSet>& setMethod(const String& value)
5695 {
5696 COMPILE_ASSERT(!(STATE & MethodSet), property_method_already_set);
5697 m_result->setString("method"_s, value);
5698 return castState<MethodSet>();
5699 }
5700
5701 Builder<STATE | HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
5702 {
5703 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
5704 m_result->setObject("headers"_s, value);
5705 return castState<HeadersSet>();
5706 }
5707
5708 Ref<Request> release()
5709 {
5710 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5711 COMPILE_ASSERT(sizeof(Request) == sizeof(JSON::Object), cannot_cast);
5712
5713 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5714 auto result = WTFMove(*reinterpret_cast<Ref<Request>*>(&jsonResult));
5715 return result;
5716 }
5717 };
5718
5719 /*
5720 * Synthetic constructor:
5721 * Ref<Request> result = Request::create()
5722 * .setUrl(...)
5723 * .setMethod(...)
5724 * .setHeaders(...)
5725 * .release();
5726 */
5727 static Builder<NoFieldsSet> create()
5728 {
5729 return Builder<NoFieldsSet>(JSON::Object::create());
5730 }
5731
5732 void setPostData(const String& value)
5733 {
5734 JSON::ObjectBase::setString("postData"_s, value);
5735 }
5736};
5737
5738/* HTTP response data. */
5739class Response : public JSON::Object {
5740public:
5741 // Named after property name 'source' while generating Response.
5742 enum class Source {
5743 Unknown = 110,
5744 Network = 34,
5745 MemoryCache = 111,
5746 DiskCache = 112,
5747 ServiceWorker = 113,
5748 }; // enum class Source
5749 enum {
5750 NoFieldsSet = 0,
5751 UrlSet = 1 << 0,
5752 StatusSet = 1 << 1,
5753 StatusTextSet = 1 << 2,
5754 HeadersSet = 1 << 3,
5755 MimeTypeSet = 1 << 4,
5756 SourceSet = 1 << 5,
5757 AllFieldsSet = (UrlSet | StatusSet | StatusTextSet | HeadersSet | MimeTypeSet | SourceSet)
5758 };
5759
5760 template<int STATE>
5761 class Builder {
5762 private:
5763 RefPtr<JSON::Object> m_result;
5764
5765 template<int STEP> Builder<STATE | STEP>& castState()
5766 {
5767 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5768 }
5769
5770 Builder(Ref</*Response*/JSON::Object>&& object)
5771 : m_result(WTFMove(object))
5772 {
5773 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5774 }
5775 friend class Response;
5776 public:
5777
5778 Builder<STATE | UrlSet>& setUrl(const String& value)
5779 {
5780 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
5781 m_result->setString("url"_s, value);
5782 return castState<UrlSet>();
5783 }
5784
5785 Builder<STATE | StatusSet>& setStatus(int value)
5786 {
5787 COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
5788 m_result->setInteger("status"_s, value);
5789 return castState<StatusSet>();
5790 }
5791
5792 Builder<STATE | StatusTextSet>& setStatusText(const String& value)
5793 {
5794 COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
5795 m_result->setString("statusText"_s, value);
5796 return castState<StatusTextSet>();
5797 }
5798
5799 Builder<STATE | HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
5800 {
5801 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
5802 m_result->setObject("headers"_s, value);
5803 return castState<HeadersSet>();
5804 }
5805
5806 Builder<STATE | MimeTypeSet>& setMimeType(const String& value)
5807 {
5808 COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
5809 m_result->setString("mimeType"_s, value);
5810 return castState<MimeTypeSet>();
5811 }
5812
5813 Builder<STATE | SourceSet>& setSource(Source value)
5814 {
5815 COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set);
5816 m_result->setString("source"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
5817 return castState<SourceSet>();
5818 }
5819
5820 Ref<Response> release()
5821 {
5822 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5823 COMPILE_ASSERT(sizeof(Response) == sizeof(JSON::Object), cannot_cast);
5824
5825 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5826 auto result = WTFMove(*reinterpret_cast<Ref<Response>*>(&jsonResult));
5827 return result;
5828 }
5829 };
5830
5831 /*
5832 * Synthetic constructor:
5833 * Ref<Response> result = Response::create()
5834 * .setUrl(...)
5835 * .setStatus(...)
5836 * .setStatusText(...)
5837 * .setHeaders(...)
5838 * .setMimeType(...)
5839 * .setSource(...)
5840 * .release();
5841 */
5842 static Builder<NoFieldsSet> create()
5843 {
5844 return Builder<NoFieldsSet>(JSON::Object::create());
5845 }
5846
5847 void setRequestHeaders(RefPtr<JSON::Object> value)
5848 {
5849 JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(value));
5850 }
5851
5852 void setTiming(RefPtr<Inspector::Protocol::Network::ResourceTiming> value)
5853 {
5854 JSON::ObjectBase::setObject("timing"_s, WTFMove(value));
5855 }
5856
5857 void setSecurity(RefPtr<Inspector::Protocol::Security::Security> value)
5858 {
5859 JSON::ObjectBase::setObject("security"_s, WTFMove(value));
5860 }
5861
5862 // Property names for type generated as open.
5863 JS_EXPORT_PRIVATE static const char* MimeType;
5864};
5865
5866/* Network load metrics. */
5867class Metrics : public JSON::ObjectBase {
5868public:
5869 // Named after property name 'priority' while generating Metrics.
5870 enum class Priority {
5871 Low = 114,
5872 Medium = 115,
5873 High = 116,
5874 }; // enum class Priority
5875 enum {
5876 NoFieldsSet = 0,
5877 AllFieldsSet = 0
5878 };
5879
5880 template<int STATE>
5881 class Builder {
5882 private:
5883 RefPtr<JSON::Object> m_result;
5884
5885 template<int STEP> Builder<STATE | STEP>& castState()
5886 {
5887 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5888 }
5889
5890 Builder(Ref</*Metrics*/JSON::Object>&& object)
5891 : m_result(WTFMove(object))
5892 {
5893 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5894 }
5895 friend class Metrics;
5896 public:
5897
5898 Ref<Metrics> release()
5899 {
5900 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
5901 COMPILE_ASSERT(sizeof(Metrics) == sizeof(JSON::Object), cannot_cast);
5902
5903 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
5904 auto result = WTFMove(*reinterpret_cast<Ref<Metrics>*>(&jsonResult));
5905 return result;
5906 }
5907 };
5908
5909 /*
5910 * Synthetic constructor:
5911 * Ref<Metrics> result = Metrics::create()
5912 * .release();
5913 */
5914 static Builder<NoFieldsSet> create()
5915 {
5916 return Builder<NoFieldsSet>(JSON::Object::create());
5917 }
5918
5919 void setProtocol(const String& value)
5920 {
5921 JSON::ObjectBase::setString("protocol"_s, value);
5922 }
5923
5924 void setPriority(Priority value)
5925 {
5926 JSON::ObjectBase::setString("priority"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
5927 }
5928
5929 void setConnectionIdentifier(const String& value)
5930 {
5931 JSON::ObjectBase::setString("connectionIdentifier"_s, value);
5932 }
5933
5934 void setRemoteAddress(const String& value)
5935 {
5936 JSON::ObjectBase::setString("remoteAddress"_s, value);
5937 }
5938
5939 void setRequestHeaders(RefPtr<JSON::Object> value)
5940 {
5941 JSON::ObjectBase::setObject("requestHeaders"_s, WTFMove(value));
5942 }
5943
5944 void setRequestHeaderBytesSent(double value)
5945 {
5946 JSON::ObjectBase::setDouble("requestHeaderBytesSent"_s, value);
5947 }
5948
5949 void setRequestBodyBytesSent(double value)
5950 {
5951 JSON::ObjectBase::setDouble("requestBodyBytesSent"_s, value);
5952 }
5953
5954 void setResponseHeaderBytesReceived(double value)
5955 {
5956 JSON::ObjectBase::setDouble("responseHeaderBytesReceived"_s, value);
5957 }
5958
5959 void setResponseBodyBytesReceived(double value)
5960 {
5961 JSON::ObjectBase::setDouble("responseBodyBytesReceived"_s, value);
5962 }
5963
5964 void setResponseBodyDecodedSize(double value)
5965 {
5966 JSON::ObjectBase::setDouble("responseBodyDecodedSize"_s, value);
5967 }
5968
5969 void setSecurityConnection(RefPtr<Inspector::Protocol::Security::Connection> value)
5970 {
5971 JSON::ObjectBase::setObject("securityConnection"_s, WTFMove(value));
5972 }
5973};
5974
5975/* WebSocket request data. */
5976class WebSocketRequest : public JSON::ObjectBase {
5977public:
5978 enum {
5979 NoFieldsSet = 0,
5980 HeadersSet = 1 << 0,
5981 AllFieldsSet = (HeadersSet)
5982 };
5983
5984 template<int STATE>
5985 class Builder {
5986 private:
5987 RefPtr<JSON::Object> m_result;
5988
5989 template<int STEP> Builder<STATE | STEP>& castState()
5990 {
5991 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
5992 }
5993
5994 Builder(Ref</*WebSocketRequest*/JSON::Object>&& object)
5995 : m_result(WTFMove(object))
5996 {
5997 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
5998 }
5999 friend class WebSocketRequest;
6000 public:
6001
6002 Builder<STATE | HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
6003 {
6004 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6005 m_result->setObject("headers"_s, value);
6006 return castState<HeadersSet>();
6007 }
6008
6009 Ref<WebSocketRequest> release()
6010 {
6011 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6012 COMPILE_ASSERT(sizeof(WebSocketRequest) == sizeof(JSON::Object), cannot_cast);
6013
6014 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6015 auto result = WTFMove(*reinterpret_cast<Ref<WebSocketRequest>*>(&jsonResult));
6016 return result;
6017 }
6018 };
6019
6020 /*
6021 * Synthetic constructor:
6022 * Ref<WebSocketRequest> result = WebSocketRequest::create()
6023 * .setHeaders(...)
6024 * .release();
6025 */
6026 static Builder<NoFieldsSet> create()
6027 {
6028 return Builder<NoFieldsSet>(JSON::Object::create());
6029 }
6030};
6031
6032/* WebSocket response data. */
6033class WebSocketResponse : public JSON::ObjectBase {
6034public:
6035 enum {
6036 NoFieldsSet = 0,
6037 StatusSet = 1 << 0,
6038 StatusTextSet = 1 << 1,
6039 HeadersSet = 1 << 2,
6040 AllFieldsSet = (StatusSet | StatusTextSet | HeadersSet)
6041 };
6042
6043 template<int STATE>
6044 class Builder {
6045 private:
6046 RefPtr<JSON::Object> m_result;
6047
6048 template<int STEP> Builder<STATE | STEP>& castState()
6049 {
6050 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6051 }
6052
6053 Builder(Ref</*WebSocketResponse*/JSON::Object>&& object)
6054 : m_result(WTFMove(object))
6055 {
6056 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6057 }
6058 friend class WebSocketResponse;
6059 public:
6060
6061 Builder<STATE | StatusSet>& setStatus(int value)
6062 {
6063 COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set);
6064 m_result->setInteger("status"_s, value);
6065 return castState<StatusSet>();
6066 }
6067
6068 Builder<STATE | StatusTextSet>& setStatusText(const String& value)
6069 {
6070 COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set);
6071 m_result->setString("statusText"_s, value);
6072 return castState<StatusTextSet>();
6073 }
6074
6075 Builder<STATE | HeadersSet>& setHeaders(RefPtr<JSON::Object> value)
6076 {
6077 COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set);
6078 m_result->setObject("headers"_s, value);
6079 return castState<HeadersSet>();
6080 }
6081
6082 Ref<WebSocketResponse> release()
6083 {
6084 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6085 COMPILE_ASSERT(sizeof(WebSocketResponse) == sizeof(JSON::Object), cannot_cast);
6086
6087 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6088 auto result = WTFMove(*reinterpret_cast<Ref<WebSocketResponse>*>(&jsonResult));
6089 return result;
6090 }
6091 };
6092
6093 /*
6094 * Synthetic constructor:
6095 * Ref<WebSocketResponse> result = WebSocketResponse::create()
6096 * .setStatus(...)
6097 * .setStatusText(...)
6098 * .setHeaders(...)
6099 * .release();
6100 */
6101 static Builder<NoFieldsSet> create()
6102 {
6103 return Builder<NoFieldsSet>(JSON::Object::create());
6104 }
6105};
6106
6107/* WebSocket frame data. */
6108class WebSocketFrame : public JSON::ObjectBase {
6109public:
6110 enum {
6111 NoFieldsSet = 0,
6112 OpcodeSet = 1 << 0,
6113 MaskSet = 1 << 1,
6114 PayloadDataSet = 1 << 2,
6115 PayloadLengthSet = 1 << 3,
6116 AllFieldsSet = (OpcodeSet | MaskSet | PayloadDataSet | PayloadLengthSet)
6117 };
6118
6119 template<int STATE>
6120 class Builder {
6121 private:
6122 RefPtr<JSON::Object> m_result;
6123
6124 template<int STEP> Builder<STATE | STEP>& castState()
6125 {
6126 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6127 }
6128
6129 Builder(Ref</*WebSocketFrame*/JSON::Object>&& object)
6130 : m_result(WTFMove(object))
6131 {
6132 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6133 }
6134 friend class WebSocketFrame;
6135 public:
6136
6137 Builder<STATE | OpcodeSet>& setOpcode(double value)
6138 {
6139 COMPILE_ASSERT(!(STATE & OpcodeSet), property_opcode_already_set);
6140 m_result->setDouble("opcode"_s, value);
6141 return castState<OpcodeSet>();
6142 }
6143
6144 Builder<STATE | MaskSet>& setMask(bool value)
6145 {
6146 COMPILE_ASSERT(!(STATE & MaskSet), property_mask_already_set);
6147 m_result->setBoolean("mask"_s, value);
6148 return castState<MaskSet>();
6149 }
6150
6151 Builder<STATE | PayloadDataSet>& setPayloadData(const String& value)
6152 {
6153 COMPILE_ASSERT(!(STATE & PayloadDataSet), property_payloadData_already_set);
6154 m_result->setString("payloadData"_s, value);
6155 return castState<PayloadDataSet>();
6156 }
6157
6158 Builder<STATE | PayloadLengthSet>& setPayloadLength(double value)
6159 {
6160 COMPILE_ASSERT(!(STATE & PayloadLengthSet), property_payloadLength_already_set);
6161 m_result->setDouble("payloadLength"_s, value);
6162 return castState<PayloadLengthSet>();
6163 }
6164
6165 Ref<WebSocketFrame> release()
6166 {
6167 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6168 COMPILE_ASSERT(sizeof(WebSocketFrame) == sizeof(JSON::Object), cannot_cast);
6169
6170 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6171 auto result = WTFMove(*reinterpret_cast<Ref<WebSocketFrame>*>(&jsonResult));
6172 return result;
6173 }
6174 };
6175
6176 /*
6177 * Synthetic constructor:
6178 * Ref<WebSocketFrame> result = WebSocketFrame::create()
6179 * .setOpcode(...)
6180 * .setMask(...)
6181 * .setPayloadData(...)
6182 * .setPayloadLength(...)
6183 * .release();
6184 */
6185 static Builder<NoFieldsSet> create()
6186 {
6187 return Builder<NoFieldsSet>(JSON::Object::create());
6188 }
6189};
6190
6191/* Information about the cached resource. */
6192class CachedResource : public JSON::ObjectBase {
6193public:
6194 enum {
6195 NoFieldsSet = 0,
6196 UrlSet = 1 << 0,
6197 TypeSet = 1 << 1,
6198 BodySizeSet = 1 << 2,
6199 AllFieldsSet = (UrlSet | TypeSet | BodySizeSet)
6200 };
6201
6202 template<int STATE>
6203 class Builder {
6204 private:
6205 RefPtr<JSON::Object> m_result;
6206
6207 template<int STEP> Builder<STATE | STEP>& castState()
6208 {
6209 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6210 }
6211
6212 Builder(Ref</*CachedResource*/JSON::Object>&& object)
6213 : m_result(WTFMove(object))
6214 {
6215 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6216 }
6217 friend class CachedResource;
6218 public:
6219
6220 Builder<STATE | UrlSet>& setUrl(const String& value)
6221 {
6222 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6223 m_result->setString("url"_s, value);
6224 return castState<UrlSet>();
6225 }
6226
6227 Builder<STATE | TypeSet>& setType(Inspector::Protocol::Page::ResourceType value)
6228 {
6229 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6230 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6231 return castState<TypeSet>();
6232 }
6233
6234 Builder<STATE | BodySizeSet>& setBodySize(double value)
6235 {
6236 COMPILE_ASSERT(!(STATE & BodySizeSet), property_bodySize_already_set);
6237 m_result->setDouble("bodySize"_s, value);
6238 return castState<BodySizeSet>();
6239 }
6240
6241 Ref<CachedResource> release()
6242 {
6243 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6244 COMPILE_ASSERT(sizeof(CachedResource) == sizeof(JSON::Object), cannot_cast);
6245
6246 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6247 auto result = WTFMove(*reinterpret_cast<Ref<CachedResource>*>(&jsonResult));
6248 return result;
6249 }
6250 };
6251
6252 /*
6253 * Synthetic constructor:
6254 * Ref<CachedResource> result = CachedResource::create()
6255 * .setUrl(...)
6256 * .setType(...)
6257 * .setBodySize(...)
6258 * .release();
6259 */
6260 static Builder<NoFieldsSet> create()
6261 {
6262 return Builder<NoFieldsSet>(JSON::Object::create());
6263 }
6264
6265 void setResponse(RefPtr<Inspector::Protocol::Network::Response> value)
6266 {
6267 JSON::ObjectBase::setObject("response"_s, WTFMove(value));
6268 }
6269
6270 void setSourceMapURL(const String& value)
6271 {
6272 JSON::ObjectBase::setString("sourceMapURL"_s, value);
6273 }
6274};
6275
6276/* Information about the request initiator. */
6277class Initiator : public JSON::ObjectBase {
6278public:
6279 // Named after property name 'type' while generating Initiator.
6280 enum class Type {
6281 Parser = 128,
6282 Script = 129,
6283 Other = 45,
6284 }; // enum class Type
6285 enum {
6286 NoFieldsSet = 0,
6287 TypeSet = 1 << 0,
6288 AllFieldsSet = (TypeSet)
6289 };
6290
6291 template<int STATE>
6292 class Builder {
6293 private:
6294 RefPtr<JSON::Object> m_result;
6295
6296 template<int STEP> Builder<STATE | STEP>& castState()
6297 {
6298 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6299 }
6300
6301 Builder(Ref</*Initiator*/JSON::Object>&& object)
6302 : m_result(WTFMove(object))
6303 {
6304 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6305 }
6306 friend class Initiator;
6307 public:
6308
6309 Builder<STATE | TypeSet>& setType(Type value)
6310 {
6311 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6312 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6313 return castState<TypeSet>();
6314 }
6315
6316 Ref<Initiator> release()
6317 {
6318 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6319 COMPILE_ASSERT(sizeof(Initiator) == sizeof(JSON::Object), cannot_cast);
6320
6321 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6322 auto result = WTFMove(*reinterpret_cast<Ref<Initiator>*>(&jsonResult));
6323 return result;
6324 }
6325 };
6326
6327 /*
6328 * Synthetic constructor:
6329 * Ref<Initiator> result = Initiator::create()
6330 * .setType(...)
6331 * .release();
6332 */
6333 static Builder<NoFieldsSet> create()
6334 {
6335 return Builder<NoFieldsSet>(JSON::Object::create());
6336 }
6337
6338 void setStackTrace(RefPtr<JSON::ArrayOf<Inspector::Protocol::Console::CallFrame>> value)
6339 {
6340 JSON::ObjectBase::setArray("stackTrace"_s, WTFMove(value));
6341 }
6342
6343 void setUrl(const String& value)
6344 {
6345 JSON::ObjectBase::setString("url"_s, value);
6346 }
6347
6348 void setLineNumber(double value)
6349 {
6350 JSON::ObjectBase::setDouble("lineNumber"_s, value);
6351 }
6352
6353 void setNodeId(int value)
6354 {
6355 JSON::ObjectBase::setInteger("nodeId"_s, value);
6356 }
6357};
6358
6359} // Network
6360
6361namespace Page {
6362/* List of settings able to be overridden by WebInspector. Keep this in sync with FOR_EACH_INSPECTOR_OVERRIDE_SETTING. */
6363enum class Setting {
6364 AuthorAndUserStylesEnabled = 130,
6365 ICECandidateFilteringEnabled = 131,
6366 ImagesEnabled = 132,
6367 MediaCaptureRequiresSecureConnection = 133,
6368 MockCaptureDevicesEnabled = 134,
6369 NeedsSiteSpecificQuirks = 135,
6370 ScriptEnabled = 136,
6371 WebSecurityEnabled = 137,
6372}; // enum class Setting
6373/* Resource type as it was perceived by the rendering engine. */
6374enum class ResourceType {
6375 Document = 117,
6376 Stylesheet = 118,
6377 Image = 119,
6378 Font = 120,
6379 Script = 121,
6380 XHR = 122,
6381 Fetch = 123,
6382 Ping = 124,
6383 Beacon = 125,
6384 WebSocket = 126,
6385 Other = 127,
6386}; // enum class ResourceType
6387/* Coordinate system used by supplied coordinates. */
6388enum class CoordinateSystem {
6389 Viewport = 138,
6390 Page = 139,
6391}; // enum class CoordinateSystem
6392/* Same-Site policy of a cookie. */
6393enum class CookieSameSitePolicy {
6394 None = 140,
6395 Lax = 141,
6396 Strict = 142,
6397}; // enum class CookieSameSitePolicy
6398/* Page appearance name. */
6399enum class Appearance {
6400 Light = 143,
6401 Dark = 144,
6402}; // enum class Appearance
6403/* Information about the Frame on the page. */
6404class Frame : public JSON::ObjectBase {
6405public:
6406 enum {
6407 NoFieldsSet = 0,
6408 IdSet = 1 << 0,
6409 LoaderIdSet = 1 << 1,
6410 UrlSet = 1 << 2,
6411 SecurityOriginSet = 1 << 3,
6412 MimeTypeSet = 1 << 4,
6413 AllFieldsSet = (IdSet | LoaderIdSet | UrlSet | SecurityOriginSet | MimeTypeSet)
6414 };
6415
6416 template<int STATE>
6417 class Builder {
6418 private:
6419 RefPtr<JSON::Object> m_result;
6420
6421 template<int STEP> Builder<STATE | STEP>& castState()
6422 {
6423 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6424 }
6425
6426 Builder(Ref</*Frame*/JSON::Object>&& object)
6427 : m_result(WTFMove(object))
6428 {
6429 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6430 }
6431 friend class Frame;
6432 public:
6433
6434 Builder<STATE | IdSet>& setId(const String& value)
6435 {
6436 COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
6437 m_result->setString("id"_s, value);
6438 return castState<IdSet>();
6439 }
6440
6441 Builder<STATE | LoaderIdSet>& setLoaderId(const String& value)
6442 {
6443 COMPILE_ASSERT(!(STATE & LoaderIdSet), property_loaderId_already_set);
6444 m_result->setString("loaderId"_s, value);
6445 return castState<LoaderIdSet>();
6446 }
6447
6448 Builder<STATE | UrlSet>& setUrl(const String& value)
6449 {
6450 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6451 m_result->setString("url"_s, value);
6452 return castState<UrlSet>();
6453 }
6454
6455 Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& value)
6456 {
6457 COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set);
6458 m_result->setString("securityOrigin"_s, value);
6459 return castState<SecurityOriginSet>();
6460 }
6461
6462 Builder<STATE | MimeTypeSet>& setMimeType(const String& value)
6463 {
6464 COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6465 m_result->setString("mimeType"_s, value);
6466 return castState<MimeTypeSet>();
6467 }
6468
6469 Ref<Frame> release()
6470 {
6471 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6472 COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
6473
6474 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6475 auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
6476 return result;
6477 }
6478 };
6479
6480 /*
6481 * Synthetic constructor:
6482 * Ref<Frame> result = Frame::create()
6483 * .setId(...)
6484 * .setLoaderId(...)
6485 * .setUrl(...)
6486 * .setSecurityOrigin(...)
6487 * .setMimeType(...)
6488 * .release();
6489 */
6490 static Builder<NoFieldsSet> create()
6491 {
6492 return Builder<NoFieldsSet>(JSON::Object::create());
6493 }
6494
6495 void setParentId(const String& value)
6496 {
6497 JSON::ObjectBase::setString("parentId"_s, value);
6498 }
6499
6500 void setName(const String& value)
6501 {
6502 JSON::ObjectBase::setString("name"_s, value);
6503 }
6504};
6505
6506class FrameResource : public JSON::ObjectBase {
6507public:
6508 enum {
6509 NoFieldsSet = 0,
6510 UrlSet = 1 << 0,
6511 TypeSet = 1 << 1,
6512 MimeTypeSet = 1 << 2,
6513 AllFieldsSet = (UrlSet | TypeSet | MimeTypeSet)
6514 };
6515
6516 template<int STATE>
6517 class Builder {
6518 private:
6519 RefPtr<JSON::Object> m_result;
6520
6521 template<int STEP> Builder<STATE | STEP>& castState()
6522 {
6523 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6524 }
6525
6526 Builder(Ref</*FrameResource*/JSON::Object>&& object)
6527 : m_result(WTFMove(object))
6528 {
6529 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6530 }
6531 friend class FrameResource;
6532 public:
6533
6534 Builder<STATE | UrlSet>& setUrl(const String& value)
6535 {
6536 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6537 m_result->setString("url"_s, value);
6538 return castState<UrlSet>();
6539 }
6540
6541 Builder<STATE | TypeSet>& setType(Inspector::Protocol::Page::ResourceType value)
6542 {
6543 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
6544 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6545 return castState<TypeSet>();
6546 }
6547
6548 Builder<STATE | MimeTypeSet>& setMimeType(const String& value)
6549 {
6550 COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set);
6551 m_result->setString("mimeType"_s, value);
6552 return castState<MimeTypeSet>();
6553 }
6554
6555 Ref<FrameResource> release()
6556 {
6557 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6558 COMPILE_ASSERT(sizeof(FrameResource) == sizeof(JSON::Object), cannot_cast);
6559
6560 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6561 auto result = WTFMove(*reinterpret_cast<Ref<FrameResource>*>(&jsonResult));
6562 return result;
6563 }
6564 };
6565
6566 /*
6567 * Synthetic constructor:
6568 * Ref<FrameResource> result = FrameResource::create()
6569 * .setUrl(...)
6570 * .setType(...)
6571 * .setMimeType(...)
6572 * .release();
6573 */
6574 static Builder<NoFieldsSet> create()
6575 {
6576 return Builder<NoFieldsSet>(JSON::Object::create());
6577 }
6578
6579 void setFailed(bool value)
6580 {
6581 JSON::ObjectBase::setBoolean("failed"_s, value);
6582 }
6583
6584 void setCanceled(bool value)
6585 {
6586 JSON::ObjectBase::setBoolean("canceled"_s, value);
6587 }
6588
6589 void setSourceMapURL(const String& value)
6590 {
6591 JSON::ObjectBase::setString("sourceMapURL"_s, value);
6592 }
6593
6594 void setTargetId(const String& value)
6595 {
6596 JSON::ObjectBase::setString("targetId"_s, value);
6597 }
6598};
6599
6600/* Information about the Frame hierarchy along with their cached resources. */
6601class FrameResourceTree : public JSON::ObjectBase {
6602public:
6603 enum {
6604 NoFieldsSet = 0,
6605 FrameSet = 1 << 0,
6606 ResourcesSet = 1 << 1,
6607 AllFieldsSet = (FrameSet | ResourcesSet)
6608 };
6609
6610 template<int STATE>
6611 class Builder {
6612 private:
6613 RefPtr<JSON::Object> m_result;
6614
6615 template<int STEP> Builder<STATE | STEP>& castState()
6616 {
6617 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6618 }
6619
6620 Builder(Ref</*FrameResourceTree*/JSON::Object>&& object)
6621 : m_result(WTFMove(object))
6622 {
6623 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6624 }
6625 friend class FrameResourceTree;
6626 public:
6627
6628 Builder<STATE | FrameSet>& setFrame(RefPtr<Inspector::Protocol::Page::Frame> value)
6629 {
6630 COMPILE_ASSERT(!(STATE & FrameSet), property_frame_already_set);
6631 m_result->setObject("frame"_s, value);
6632 return castState<FrameSet>();
6633 }
6634
6635 Builder<STATE | ResourcesSet>& setResources(RefPtr<JSON::ArrayOf<Inspector::Protocol::Page::FrameResource>> value)
6636 {
6637 COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set);
6638 m_result->setArray("resources"_s, value);
6639 return castState<ResourcesSet>();
6640 }
6641
6642 Ref<FrameResourceTree> release()
6643 {
6644 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6645 COMPILE_ASSERT(sizeof(FrameResourceTree) == sizeof(JSON::Object), cannot_cast);
6646
6647 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6648 auto result = WTFMove(*reinterpret_cast<Ref<FrameResourceTree>*>(&jsonResult));
6649 return result;
6650 }
6651 };
6652
6653 /*
6654 * Synthetic constructor:
6655 * Ref<FrameResourceTree> result = FrameResourceTree::create()
6656 * .setFrame(...)
6657 * .setResources(...)
6658 * .release();
6659 */
6660 static Builder<NoFieldsSet> create()
6661 {
6662 return Builder<NoFieldsSet>(JSON::Object::create());
6663 }
6664
6665 void setChildFrames(RefPtr<JSON::ArrayOf<Inspector::Protocol::Page::FrameResourceTree>> value)
6666 {
6667 JSON::ObjectBase::setArray("childFrames"_s, WTFMove(value));
6668 }
6669};
6670
6671/* Search result for resource. */
6672class SearchResult : public JSON::ObjectBase {
6673public:
6674 enum {
6675 NoFieldsSet = 0,
6676 UrlSet = 1 << 0,
6677 FrameIdSet = 1 << 1,
6678 MatchesCountSet = 1 << 2,
6679 AllFieldsSet = (UrlSet | FrameIdSet | MatchesCountSet)
6680 };
6681
6682 template<int STATE>
6683 class Builder {
6684 private:
6685 RefPtr<JSON::Object> m_result;
6686
6687 template<int STEP> Builder<STATE | STEP>& castState()
6688 {
6689 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6690 }
6691
6692 Builder(Ref</*SearchResult*/JSON::Object>&& object)
6693 : m_result(WTFMove(object))
6694 {
6695 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6696 }
6697 friend class SearchResult;
6698 public:
6699
6700 Builder<STATE | UrlSet>& setUrl(const String& value)
6701 {
6702 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
6703 m_result->setString("url"_s, value);
6704 return castState<UrlSet>();
6705 }
6706
6707 Builder<STATE | FrameIdSet>& setFrameId(const String& value)
6708 {
6709 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
6710 m_result->setString("frameId"_s, value);
6711 return castState<FrameIdSet>();
6712 }
6713
6714 Builder<STATE | MatchesCountSet>& setMatchesCount(double value)
6715 {
6716 COMPILE_ASSERT(!(STATE & MatchesCountSet), property_matchesCount_already_set);
6717 m_result->setDouble("matchesCount"_s, value);
6718 return castState<MatchesCountSet>();
6719 }
6720
6721 Ref<SearchResult> release()
6722 {
6723 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6724 COMPILE_ASSERT(sizeof(SearchResult) == sizeof(JSON::Object), cannot_cast);
6725
6726 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6727 auto result = WTFMove(*reinterpret_cast<Ref<SearchResult>*>(&jsonResult));
6728 return result;
6729 }
6730 };
6731
6732 /*
6733 * Synthetic constructor:
6734 * Ref<SearchResult> result = SearchResult::create()
6735 * .setUrl(...)
6736 * .setFrameId(...)
6737 * .setMatchesCount(...)
6738 * .release();
6739 */
6740 static Builder<NoFieldsSet> create()
6741 {
6742 return Builder<NoFieldsSet>(JSON::Object::create());
6743 }
6744
6745 void setRequestId(const String& value)
6746 {
6747 JSON::ObjectBase::setString("requestId"_s, value);
6748 }
6749};
6750
6751/* Cookie object */
6752class Cookie : public JSON::ObjectBase {
6753public:
6754 enum {
6755 NoFieldsSet = 0,
6756 NameSet = 1 << 0,
6757 ValueSet = 1 << 1,
6758 DomainSet = 1 << 2,
6759 PathSet = 1 << 3,
6760 ExpiresSet = 1 << 4,
6761 SizeSet = 1 << 5,
6762 HttpOnlySet = 1 << 6,
6763 SecureSet = 1 << 7,
6764 SessionSet = 1 << 8,
6765 SameSiteSet = 1 << 9,
6766 AllFieldsSet = (NameSet | ValueSet | DomainSet | PathSet | ExpiresSet | SizeSet | HttpOnlySet | SecureSet | SessionSet | SameSiteSet)
6767 };
6768
6769 template<int STATE>
6770 class Builder {
6771 private:
6772 RefPtr<JSON::Object> m_result;
6773
6774 template<int STEP> Builder<STATE | STEP>& castState()
6775 {
6776 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6777 }
6778
6779 Builder(Ref</*Cookie*/JSON::Object>&& object)
6780 : m_result(WTFMove(object))
6781 {
6782 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6783 }
6784 friend class Cookie;
6785 public:
6786
6787 Builder<STATE | NameSet>& setName(const String& value)
6788 {
6789 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
6790 m_result->setString("name"_s, value);
6791 return castState<NameSet>();
6792 }
6793
6794 Builder<STATE | ValueSet>& setValue(const String& value)
6795 {
6796 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
6797 m_result->setString("value"_s, value);
6798 return castState<ValueSet>();
6799 }
6800
6801 Builder<STATE | DomainSet>& setDomain(const String& value)
6802 {
6803 COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set);
6804 m_result->setString("domain"_s, value);
6805 return castState<DomainSet>();
6806 }
6807
6808 Builder<STATE | PathSet>& setPath(const String& value)
6809 {
6810 COMPILE_ASSERT(!(STATE & PathSet), property_path_already_set);
6811 m_result->setString("path"_s, value);
6812 return castState<PathSet>();
6813 }
6814
6815 Builder<STATE | ExpiresSet>& setExpires(double value)
6816 {
6817 COMPILE_ASSERT(!(STATE & ExpiresSet), property_expires_already_set);
6818 m_result->setDouble("expires"_s, value);
6819 return castState<ExpiresSet>();
6820 }
6821
6822 Builder<STATE | SizeSet>& setSize(int value)
6823 {
6824 COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set);
6825 m_result->setInteger("size"_s, value);
6826 return castState<SizeSet>();
6827 }
6828
6829 Builder<STATE | HttpOnlySet>& setHttpOnly(bool value)
6830 {
6831 COMPILE_ASSERT(!(STATE & HttpOnlySet), property_httpOnly_already_set);
6832 m_result->setBoolean("httpOnly"_s, value);
6833 return castState<HttpOnlySet>();
6834 }
6835
6836 Builder<STATE | SecureSet>& setSecure(bool value)
6837 {
6838 COMPILE_ASSERT(!(STATE & SecureSet), property_secure_already_set);
6839 m_result->setBoolean("secure"_s, value);
6840 return castState<SecureSet>();
6841 }
6842
6843 Builder<STATE | SessionSet>& setSession(bool value)
6844 {
6845 COMPILE_ASSERT(!(STATE & SessionSet), property_session_already_set);
6846 m_result->setBoolean("session"_s, value);
6847 return castState<SessionSet>();
6848 }
6849
6850 Builder<STATE | SameSiteSet>& setSameSite(Inspector::Protocol::Page::CookieSameSitePolicy value)
6851 {
6852 COMPILE_ASSERT(!(STATE & SameSiteSet), property_sameSite_already_set);
6853 m_result->setString("sameSite"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
6854 return castState<SameSiteSet>();
6855 }
6856
6857 Ref<Cookie> release()
6858 {
6859 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6860 COMPILE_ASSERT(sizeof(Cookie) == sizeof(JSON::Object), cannot_cast);
6861
6862 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6863 auto result = WTFMove(*reinterpret_cast<Ref<Cookie>*>(&jsonResult));
6864 return result;
6865 }
6866 };
6867
6868 /*
6869 * Synthetic constructor:
6870 * Ref<Cookie> result = Cookie::create()
6871 * .setName(...)
6872 * .setValue(...)
6873 * .setDomain(...)
6874 * .setPath(...)
6875 * .setExpires(...)
6876 * .setSize(...)
6877 * .setHttpOnly(...)
6878 * .setSecure(...)
6879 * .setSession(...)
6880 * .setSameSite(...)
6881 * .release();
6882 */
6883 static Builder<NoFieldsSet> create()
6884 {
6885 return Builder<NoFieldsSet>(JSON::Object::create());
6886 }
6887};
6888
6889} // Page
6890
6891namespace Recording {
6892/* The type of the recording. */
6893enum class Type {
6894 Canvas2D = 25,
6895 CanvasBitmapRenderer = 145,
6896 CanvasWebGL = 146,
6897 CanvasWebGL2 = 147,
6898}; // enum class Type
6899/* */
6900enum class Initiator {
6901 Frontend = 148,
6902 Console = 149,
6903 AutoCapture = 150,
6904}; // enum class Initiator
6905/* Information about the initial state of the recorded object. */
6906class InitialState : public JSON::ObjectBase {
6907public:
6908 enum {
6909 NoFieldsSet = 0,
6910 AllFieldsSet = 0
6911 };
6912
6913 template<int STATE>
6914 class Builder {
6915 private:
6916 RefPtr<JSON::Object> m_result;
6917
6918 template<int STEP> Builder<STATE | STEP>& castState()
6919 {
6920 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6921 }
6922
6923 Builder(Ref</*InitialState*/JSON::Object>&& object)
6924 : m_result(WTFMove(object))
6925 {
6926 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6927 }
6928 friend class InitialState;
6929 public:
6930
6931 Ref<InitialState> release()
6932 {
6933 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
6934 COMPILE_ASSERT(sizeof(InitialState) == sizeof(JSON::Object), cannot_cast);
6935
6936 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
6937 auto result = WTFMove(*reinterpret_cast<Ref<InitialState>*>(&jsonResult));
6938 return result;
6939 }
6940 };
6941
6942 /*
6943 * Synthetic constructor:
6944 * Ref<InitialState> result = InitialState::create()
6945 * .release();
6946 */
6947 static Builder<NoFieldsSet> create()
6948 {
6949 return Builder<NoFieldsSet>(JSON::Object::create());
6950 }
6951
6952 void setAttributes(RefPtr<JSON::Object> value)
6953 {
6954 JSON::ObjectBase::setObject("attributes"_s, WTFMove(value));
6955 }
6956
6957 void setStates(RefPtr<JSON::ArrayOf<JSON::Object>> value)
6958 {
6959 JSON::ObjectBase::setArray("states"_s, WTFMove(value));
6960 }
6961
6962 void setParameters(RefPtr<JSON::ArrayOf<JSON::Value>> value)
6963 {
6964 JSON::ObjectBase::setArray("parameters"_s, WTFMove(value));
6965 }
6966
6967 void setContent(const String& value)
6968 {
6969 JSON::ObjectBase::setString("content"_s, value);
6970 }
6971};
6972
6973/* Container object for a single frame of the recording. */
6974class Frame : public JSON::ObjectBase {
6975public:
6976 enum {
6977 NoFieldsSet = 0,
6978 ActionsSet = 1 << 0,
6979 AllFieldsSet = (ActionsSet)
6980 };
6981
6982 template<int STATE>
6983 class Builder {
6984 private:
6985 RefPtr<JSON::Object> m_result;
6986
6987 template<int STEP> Builder<STATE | STEP>& castState()
6988 {
6989 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
6990 }
6991
6992 Builder(Ref</*Frame*/JSON::Object>&& object)
6993 : m_result(WTFMove(object))
6994 {
6995 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
6996 }
6997 friend class Frame;
6998 public:
6999
7000 Builder<STATE | ActionsSet>& setActions(RefPtr<JSON::ArrayOf<JSON::Value>> value)
7001 {
7002 COMPILE_ASSERT(!(STATE & ActionsSet), property_actions_already_set);
7003 m_result->setArray("actions"_s, value);
7004 return castState<ActionsSet>();
7005 }
7006
7007 Ref<Frame> release()
7008 {
7009 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7010 COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast);
7011
7012 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7013 auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult));
7014 return result;
7015 }
7016 };
7017
7018 /*
7019 * Synthetic constructor:
7020 * Ref<Frame> result = Frame::create()
7021 * .setActions(...)
7022 * .release();
7023 */
7024 static Builder<NoFieldsSet> create()
7025 {
7026 return Builder<NoFieldsSet>(JSON::Object::create());
7027 }
7028
7029 void setDuration(double value)
7030 {
7031 JSON::ObjectBase::setDouble("duration"_s, value);
7032 }
7033
7034 void setIncomplete(bool value)
7035 {
7036 JSON::ObjectBase::setBoolean("incomplete"_s, value);
7037 }
7038};
7039
7040class Recording : public JSON::ObjectBase {
7041public:
7042 enum {
7043 NoFieldsSet = 0,
7044 VersionSet = 1 << 0,
7045 TypeSet = 1 << 1,
7046 InitialStateSet = 1 << 2,
7047 DataSet = 1 << 3,
7048 AllFieldsSet = (VersionSet | TypeSet | InitialStateSet | DataSet)
7049 };
7050
7051 template<int STATE>
7052 class Builder {
7053 private:
7054 RefPtr<JSON::Object> m_result;
7055
7056 template<int STEP> Builder<STATE | STEP>& castState()
7057 {
7058 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7059 }
7060
7061 Builder(Ref</*Recording*/JSON::Object>&& object)
7062 : m_result(WTFMove(object))
7063 {
7064 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7065 }
7066 friend class Recording;
7067 public:
7068
7069 Builder<STATE | VersionSet>& setVersion(int value)
7070 {
7071 COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set);
7072 m_result->setInteger("version"_s, value);
7073 return castState<VersionSet>();
7074 }
7075
7076 Builder<STATE | TypeSet>& setType(Inspector::Protocol::Recording::Type value)
7077 {
7078 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7079 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7080 return castState<TypeSet>();
7081 }
7082
7083 Builder<STATE | InitialStateSet>& setInitialState(RefPtr<Inspector::Protocol::Recording::InitialState> value)
7084 {
7085 COMPILE_ASSERT(!(STATE & InitialStateSet), property_initialState_already_set);
7086 m_result->setObject("initialState"_s, value);
7087 return castState<InitialStateSet>();
7088 }
7089
7090 Builder<STATE | DataSet>& setData(RefPtr<JSON::ArrayOf<JSON::Value>> value)
7091 {
7092 COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
7093 m_result->setArray("data"_s, value);
7094 return castState<DataSet>();
7095 }
7096
7097 Ref<Recording> release()
7098 {
7099 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7100 COMPILE_ASSERT(sizeof(Recording) == sizeof(JSON::Object), cannot_cast);
7101
7102 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7103 auto result = WTFMove(*reinterpret_cast<Ref<Recording>*>(&jsonResult));
7104 return result;
7105 }
7106 };
7107
7108 /*
7109 * Synthetic constructor:
7110 * Ref<Recording> result = Recording::create()
7111 * .setVersion(...)
7112 * .setType(...)
7113 * .setInitialState(...)
7114 * .setData(...)
7115 * .release();
7116 */
7117 static Builder<NoFieldsSet> create()
7118 {
7119 return Builder<NoFieldsSet>(JSON::Object::create());
7120 }
7121
7122 void setName(const String& value)
7123 {
7124 JSON::ObjectBase::setString("name"_s, value);
7125 }
7126};
7127
7128} // Recording
7129
7130namespace Runtime {
7131/* Mirror object referencing original JavaScript object. */
7132class RemoteObject : public JSON::ObjectBase {
7133public:
7134 // Named after property name 'type' while generating RemoteObject.
7135 enum class Type {
7136 Object = 151,
7137 Function = 152,
7138 Undefined = 153,
7139 String = 107,
7140 Number = 106,
7141 Boolean = 154,
7142 Symbol = 155,
7143 }; // enum class Type
7144 // Named after property name 'subtype' while generating RemoteObject.
7145 enum class Subtype {
7146 Array = 108,
7147 Null = 109,
7148 Node = 156,
7149 Regexp = 157,
7150 Date = 82,
7151 Error = 52,
7152 Map = 158,
7153 Set = 159,
7154 Weakmap = 160,
7155 Weakset = 161,
7156 Iterator = 162,
7157 Class = 163,
7158 Proxy = 164,
7159 }; // enum class Subtype
7160 enum {
7161 NoFieldsSet = 0,
7162 TypeSet = 1 << 0,
7163 AllFieldsSet = (TypeSet)
7164 };
7165
7166 template<int STATE>
7167 class Builder {
7168 private:
7169 RefPtr<JSON::Object> m_result;
7170
7171 template<int STEP> Builder<STATE | STEP>& castState()
7172 {
7173 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7174 }
7175
7176 Builder(Ref</*RemoteObject*/JSON::Object>&& object)
7177 : m_result(WTFMove(object))
7178 {
7179 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7180 }
7181 friend class RemoteObject;
7182 public:
7183
7184 Builder<STATE | TypeSet>& setType(Type value)
7185 {
7186 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7187 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7188 return castState<TypeSet>();
7189 }
7190
7191 Ref<RemoteObject> release()
7192 {
7193 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7194 COMPILE_ASSERT(sizeof(RemoteObject) == sizeof(JSON::Object), cannot_cast);
7195
7196 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7197 auto result = WTFMove(*reinterpret_cast<Ref<RemoteObject>*>(&jsonResult));
7198 return result;
7199 }
7200 };
7201
7202 /*
7203 * Synthetic constructor:
7204 * Ref<RemoteObject> result = RemoteObject::create()
7205 * .setType(...)
7206 * .release();
7207 */
7208 static Builder<NoFieldsSet> create()
7209 {
7210 return Builder<NoFieldsSet>(JSON::Object::create());
7211 }
7212
7213 void setSubtype(Subtype value)
7214 {
7215 JSON::ObjectBase::setString("subtype"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7216 }
7217
7218 void setClassName(const String& value)
7219 {
7220 JSON::ObjectBase::setString("className"_s, value);
7221 }
7222
7223 void setValue(RefPtr<JSON::Value> value)
7224 {
7225 JSON::ObjectBase::setValue("value"_s, WTFMove(value));
7226 }
7227
7228 void setDescription(const String& value)
7229 {
7230 JSON::ObjectBase::setString("description"_s, value);
7231 }
7232
7233 void setObjectId(const String& value)
7234 {
7235 JSON::ObjectBase::setString("objectId"_s, value);
7236 }
7237
7238 void setSize(int value)
7239 {
7240 JSON::ObjectBase::setInteger("size"_s, value);
7241 }
7242
7243 void setClassPrototype(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7244 {
7245 JSON::ObjectBase::setObject("classPrototype"_s, WTFMove(value));
7246 }
7247
7248 void setPreview(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7249 {
7250 JSON::ObjectBase::setObject("preview"_s, WTFMove(value));
7251 }
7252};
7253
7254/* Object containing abbreviated remote object value. */
7255class ObjectPreview : public JSON::ObjectBase {
7256public:
7257 // Named after property name 'type' while generating ObjectPreview.
7258 enum class Type {
7259 Object = 151,
7260 Function = 152,
7261 Undefined = 153,
7262 String = 107,
7263 Number = 106,
7264 Boolean = 154,
7265 Symbol = 155,
7266 }; // enum class Type
7267 // Named after property name 'subtype' while generating ObjectPreview.
7268 enum class Subtype {
7269 Array = 108,
7270 Null = 109,
7271 Node = 156,
7272 Regexp = 157,
7273 Date = 82,
7274 Error = 52,
7275 Map = 158,
7276 Set = 159,
7277 Weakmap = 160,
7278 Weakset = 161,
7279 Iterator = 162,
7280 Class = 163,
7281 Proxy = 164,
7282 }; // enum class Subtype
7283 enum {
7284 NoFieldsSet = 0,
7285 TypeSet = 1 << 0,
7286 LosslessSet = 1 << 1,
7287 AllFieldsSet = (TypeSet | LosslessSet)
7288 };
7289
7290 template<int STATE>
7291 class Builder {
7292 private:
7293 RefPtr<JSON::Object> m_result;
7294
7295 template<int STEP> Builder<STATE | STEP>& castState()
7296 {
7297 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7298 }
7299
7300 Builder(Ref</*ObjectPreview*/JSON::Object>&& object)
7301 : m_result(WTFMove(object))
7302 {
7303 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7304 }
7305 friend class ObjectPreview;
7306 public:
7307
7308 Builder<STATE | TypeSet>& setType(Type value)
7309 {
7310 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7311 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7312 return castState<TypeSet>();
7313 }
7314
7315 Builder<STATE | LosslessSet>& setLossless(bool value)
7316 {
7317 COMPILE_ASSERT(!(STATE & LosslessSet), property_lossless_already_set);
7318 m_result->setBoolean("lossless"_s, value);
7319 return castState<LosslessSet>();
7320 }
7321
7322 Ref<ObjectPreview> release()
7323 {
7324 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7325 COMPILE_ASSERT(sizeof(ObjectPreview) == sizeof(JSON::Object), cannot_cast);
7326
7327 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7328 auto result = WTFMove(*reinterpret_cast<Ref<ObjectPreview>*>(&jsonResult));
7329 return result;
7330 }
7331 };
7332
7333 /*
7334 * Synthetic constructor:
7335 * Ref<ObjectPreview> result = ObjectPreview::create()
7336 * .setType(...)
7337 * .setLossless(...)
7338 * .release();
7339 */
7340 static Builder<NoFieldsSet> create()
7341 {
7342 return Builder<NoFieldsSet>(JSON::Object::create());
7343 }
7344
7345 void setSubtype(Subtype value)
7346 {
7347 JSON::ObjectBase::setString("subtype"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7348 }
7349
7350 void setDescription(const String& value)
7351 {
7352 JSON::ObjectBase::setString("description"_s, value);
7353 }
7354
7355 void setOverflow(bool value)
7356 {
7357 JSON::ObjectBase::setBoolean("overflow"_s, value);
7358 }
7359
7360 void setProperties(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::PropertyPreview>> value)
7361 {
7362 JSON::ObjectBase::setArray("properties"_s, WTFMove(value));
7363 }
7364
7365 void setEntries(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::EntryPreview>> value)
7366 {
7367 JSON::ObjectBase::setArray("entries"_s, WTFMove(value));
7368 }
7369
7370 void setSize(int value)
7371 {
7372 JSON::ObjectBase::setInteger("size"_s, value);
7373 }
7374};
7375
7376class PropertyPreview : public JSON::ObjectBase {
7377public:
7378 // Named after property name 'type' while generating PropertyPreview.
7379 enum class Type {
7380 Object = 151,
7381 Function = 152,
7382 Undefined = 153,
7383 String = 107,
7384 Number = 106,
7385 Boolean = 154,
7386 Symbol = 155,
7387 Accessor = 165,
7388 }; // enum class Type
7389 // Named after property name 'subtype' while generating PropertyPreview.
7390 enum class Subtype {
7391 Array = 108,
7392 Null = 109,
7393 Node = 156,
7394 Regexp = 157,
7395 Date = 82,
7396 Error = 52,
7397 Map = 158,
7398 Set = 159,
7399 Weakmap = 160,
7400 Weakset = 161,
7401 Iterator = 162,
7402 Class = 163,
7403 Proxy = 164,
7404 }; // enum class Subtype
7405 enum {
7406 NoFieldsSet = 0,
7407 NameSet = 1 << 0,
7408 TypeSet = 1 << 1,
7409 AllFieldsSet = (NameSet | TypeSet)
7410 };
7411
7412 template<int STATE>
7413 class Builder {
7414 private:
7415 RefPtr<JSON::Object> m_result;
7416
7417 template<int STEP> Builder<STATE | STEP>& castState()
7418 {
7419 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7420 }
7421
7422 Builder(Ref</*PropertyPreview*/JSON::Object>&& object)
7423 : m_result(WTFMove(object))
7424 {
7425 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7426 }
7427 friend class PropertyPreview;
7428 public:
7429
7430 Builder<STATE | NameSet>& setName(const String& value)
7431 {
7432 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7433 m_result->setString("name"_s, value);
7434 return castState<NameSet>();
7435 }
7436
7437 Builder<STATE | TypeSet>& setType(Type value)
7438 {
7439 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
7440 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7441 return castState<TypeSet>();
7442 }
7443
7444 Ref<PropertyPreview> release()
7445 {
7446 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7447 COMPILE_ASSERT(sizeof(PropertyPreview) == sizeof(JSON::Object), cannot_cast);
7448
7449 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7450 auto result = WTFMove(*reinterpret_cast<Ref<PropertyPreview>*>(&jsonResult));
7451 return result;
7452 }
7453 };
7454
7455 /*
7456 * Synthetic constructor:
7457 * Ref<PropertyPreview> result = PropertyPreview::create()
7458 * .setName(...)
7459 * .setType(...)
7460 * .release();
7461 */
7462 static Builder<NoFieldsSet> create()
7463 {
7464 return Builder<NoFieldsSet>(JSON::Object::create());
7465 }
7466
7467 void setSubtype(Subtype value)
7468 {
7469 JSON::ObjectBase::setString("subtype"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
7470 }
7471
7472 void setValue(const String& value)
7473 {
7474 JSON::ObjectBase::setString("value"_s, value);
7475 }
7476
7477 void setValuePreview(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7478 {
7479 JSON::ObjectBase::setObject("valuePreview"_s, WTFMove(value));
7480 }
7481
7482 void setInternal(bool value)
7483 {
7484 JSON::ObjectBase::setBoolean("internal"_s, value);
7485 }
7486};
7487
7488class EntryPreview : public JSON::ObjectBase {
7489public:
7490 enum {
7491 NoFieldsSet = 0,
7492 ValueSet = 1 << 0,
7493 AllFieldsSet = (ValueSet)
7494 };
7495
7496 template<int STATE>
7497 class Builder {
7498 private:
7499 RefPtr<JSON::Object> m_result;
7500
7501 template<int STEP> Builder<STATE | STEP>& castState()
7502 {
7503 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7504 }
7505
7506 Builder(Ref</*EntryPreview*/JSON::Object>&& object)
7507 : m_result(WTFMove(object))
7508 {
7509 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7510 }
7511 friend class EntryPreview;
7512 public:
7513
7514 Builder<STATE | ValueSet>& setValue(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7515 {
7516 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
7517 m_result->setObject("value"_s, value);
7518 return castState<ValueSet>();
7519 }
7520
7521 Ref<EntryPreview> release()
7522 {
7523 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7524 COMPILE_ASSERT(sizeof(EntryPreview) == sizeof(JSON::Object), cannot_cast);
7525
7526 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7527 auto result = WTFMove(*reinterpret_cast<Ref<EntryPreview>*>(&jsonResult));
7528 return result;
7529 }
7530 };
7531
7532 /*
7533 * Synthetic constructor:
7534 * Ref<EntryPreview> result = EntryPreview::create()
7535 * .setValue(...)
7536 * .release();
7537 */
7538 static Builder<NoFieldsSet> create()
7539 {
7540 return Builder<NoFieldsSet>(JSON::Object::create());
7541 }
7542
7543 void setKey(RefPtr<Inspector::Protocol::Runtime::ObjectPreview> value)
7544 {
7545 JSON::ObjectBase::setObject("key"_s, WTFMove(value));
7546 }
7547};
7548
7549class CollectionEntry : public JSON::ObjectBase {
7550public:
7551 enum {
7552 NoFieldsSet = 0,
7553 ValueSet = 1 << 0,
7554 AllFieldsSet = (ValueSet)
7555 };
7556
7557 template<int STATE>
7558 class Builder {
7559 private:
7560 RefPtr<JSON::Object> m_result;
7561
7562 template<int STEP> Builder<STATE | STEP>& castState()
7563 {
7564 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7565 }
7566
7567 Builder(Ref</*CollectionEntry*/JSON::Object>&& object)
7568 : m_result(WTFMove(object))
7569 {
7570 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7571 }
7572 friend class CollectionEntry;
7573 public:
7574
7575 Builder<STATE | ValueSet>& setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7576 {
7577 COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set);
7578 m_result->setObject("value"_s, value);
7579 return castState<ValueSet>();
7580 }
7581
7582 Ref<CollectionEntry> release()
7583 {
7584 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7585 COMPILE_ASSERT(sizeof(CollectionEntry) == sizeof(JSON::Object), cannot_cast);
7586
7587 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7588 auto result = WTFMove(*reinterpret_cast<Ref<CollectionEntry>*>(&jsonResult));
7589 return result;
7590 }
7591 };
7592
7593 /*
7594 * Synthetic constructor:
7595 * Ref<CollectionEntry> result = CollectionEntry::create()
7596 * .setValue(...)
7597 * .release();
7598 */
7599 static Builder<NoFieldsSet> create()
7600 {
7601 return Builder<NoFieldsSet>(JSON::Object::create());
7602 }
7603
7604 void setKey(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7605 {
7606 JSON::ObjectBase::setObject("key"_s, WTFMove(value));
7607 }
7608};
7609
7610/* Object property descriptor. */
7611class PropertyDescriptor : public JSON::ObjectBase {
7612public:
7613 enum {
7614 NoFieldsSet = 0,
7615 NameSet = 1 << 0,
7616 ConfigurableSet = 1 << 1,
7617 EnumerableSet = 1 << 2,
7618 AllFieldsSet = (NameSet | ConfigurableSet | EnumerableSet)
7619 };
7620
7621 template<int STATE>
7622 class Builder {
7623 private:
7624 RefPtr<JSON::Object> m_result;
7625
7626 template<int STEP> Builder<STATE | STEP>& castState()
7627 {
7628 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7629 }
7630
7631 Builder(Ref</*PropertyDescriptor*/JSON::Object>&& object)
7632 : m_result(WTFMove(object))
7633 {
7634 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7635 }
7636 friend class PropertyDescriptor;
7637 public:
7638
7639 Builder<STATE | NameSet>& setName(const String& value)
7640 {
7641 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7642 m_result->setString("name"_s, value);
7643 return castState<NameSet>();
7644 }
7645
7646 Builder<STATE | ConfigurableSet>& setConfigurable(bool value)
7647 {
7648 COMPILE_ASSERT(!(STATE & ConfigurableSet), property_configurable_already_set);
7649 m_result->setBoolean("configurable"_s, value);
7650 return castState<ConfigurableSet>();
7651 }
7652
7653 Builder<STATE | EnumerableSet>& setEnumerable(bool value)
7654 {
7655 COMPILE_ASSERT(!(STATE & EnumerableSet), property_enumerable_already_set);
7656 m_result->setBoolean("enumerable"_s, value);
7657 return castState<EnumerableSet>();
7658 }
7659
7660 Ref<PropertyDescriptor> release()
7661 {
7662 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7663 COMPILE_ASSERT(sizeof(PropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
7664
7665 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7666 auto result = WTFMove(*reinterpret_cast<Ref<PropertyDescriptor>*>(&jsonResult));
7667 return result;
7668 }
7669 };
7670
7671 /*
7672 * Synthetic constructor:
7673 * Ref<PropertyDescriptor> result = PropertyDescriptor::create()
7674 * .setName(...)
7675 * .setConfigurable(...)
7676 * .setEnumerable(...)
7677 * .release();
7678 */
7679 static Builder<NoFieldsSet> create()
7680 {
7681 return Builder<NoFieldsSet>(JSON::Object::create());
7682 }
7683
7684 void setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7685 {
7686 JSON::ObjectBase::setObject("value"_s, WTFMove(value));
7687 }
7688
7689 void setWritable(bool value)
7690 {
7691 JSON::ObjectBase::setBoolean("writable"_s, value);
7692 }
7693
7694 void setGet(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7695 {
7696 JSON::ObjectBase::setObject("get"_s, WTFMove(value));
7697 }
7698
7699 void setSet(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7700 {
7701 JSON::ObjectBase::setObject("set"_s, WTFMove(value));
7702 }
7703
7704 void setWasThrown(bool value)
7705 {
7706 JSON::ObjectBase::setBoolean("wasThrown"_s, value);
7707 }
7708
7709 void setIsOwn(bool value)
7710 {
7711 JSON::ObjectBase::setBoolean("isOwn"_s, value);
7712 }
7713
7714 void setSymbol(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7715 {
7716 JSON::ObjectBase::setObject("symbol"_s, WTFMove(value));
7717 }
7718
7719 void setNativeGetter(bool value)
7720 {
7721 JSON::ObjectBase::setBoolean("nativeGetter"_s, value);
7722 }
7723};
7724
7725/* Object internal property descriptor. This property isn't normally visible in JavaScript code. */
7726class InternalPropertyDescriptor : public JSON::ObjectBase {
7727public:
7728 enum {
7729 NoFieldsSet = 0,
7730 NameSet = 1 << 0,
7731 AllFieldsSet = (NameSet)
7732 };
7733
7734 template<int STATE>
7735 class Builder {
7736 private:
7737 RefPtr<JSON::Object> m_result;
7738
7739 template<int STEP> Builder<STATE | STEP>& castState()
7740 {
7741 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7742 }
7743
7744 Builder(Ref</*InternalPropertyDescriptor*/JSON::Object>&& object)
7745 : m_result(WTFMove(object))
7746 {
7747 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7748 }
7749 friend class InternalPropertyDescriptor;
7750 public:
7751
7752 Builder<STATE | NameSet>& setName(const String& value)
7753 {
7754 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7755 m_result->setString("name"_s, value);
7756 return castState<NameSet>();
7757 }
7758
7759 Ref<InternalPropertyDescriptor> release()
7760 {
7761 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7762 COMPILE_ASSERT(sizeof(InternalPropertyDescriptor) == sizeof(JSON::Object), cannot_cast);
7763
7764 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7765 auto result = WTFMove(*reinterpret_cast<Ref<InternalPropertyDescriptor>*>(&jsonResult));
7766 return result;
7767 }
7768 };
7769
7770 /*
7771 * Synthetic constructor:
7772 * Ref<InternalPropertyDescriptor> result = InternalPropertyDescriptor::create()
7773 * .setName(...)
7774 * .release();
7775 */
7776 static Builder<NoFieldsSet> create()
7777 {
7778 return Builder<NoFieldsSet>(JSON::Object::create());
7779 }
7780
7781 void setValue(RefPtr<Inspector::Protocol::Runtime::RemoteObject> value)
7782 {
7783 JSON::ObjectBase::setObject("value"_s, WTFMove(value));
7784 }
7785};
7786
7787/* Represents function call argument. Either remote object id <code>objectId</code> or primitive <code>value</code> or neither of (for undefined) them should be specified. */
7788class CallArgument : public JSON::ObjectBase {
7789public:
7790 enum {
7791 NoFieldsSet = 0,
7792 AllFieldsSet = 0
7793 };
7794
7795 template<int STATE>
7796 class Builder {
7797 private:
7798 RefPtr<JSON::Object> m_result;
7799
7800 template<int STEP> Builder<STATE | STEP>& castState()
7801 {
7802 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7803 }
7804
7805 Builder(Ref</*CallArgument*/JSON::Object>&& object)
7806 : m_result(WTFMove(object))
7807 {
7808 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7809 }
7810 friend class CallArgument;
7811 public:
7812
7813 Ref<CallArgument> release()
7814 {
7815 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7816 COMPILE_ASSERT(sizeof(CallArgument) == sizeof(JSON::Object), cannot_cast);
7817
7818 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7819 auto result = WTFMove(*reinterpret_cast<Ref<CallArgument>*>(&jsonResult));
7820 return result;
7821 }
7822 };
7823
7824 /*
7825 * Synthetic constructor:
7826 * Ref<CallArgument> result = CallArgument::create()
7827 * .release();
7828 */
7829 static Builder<NoFieldsSet> create()
7830 {
7831 return Builder<NoFieldsSet>(JSON::Object::create());
7832 }
7833
7834 void setValue(RefPtr<JSON::Value> value)
7835 {
7836 JSON::ObjectBase::setValue("value"_s, WTFMove(value));
7837 }
7838
7839 void setObjectId(const String& value)
7840 {
7841 JSON::ObjectBase::setString("objectId"_s, value);
7842 }
7843};
7844
7845/* Description of an isolated world. */
7846class ExecutionContextDescription : public JSON::ObjectBase {
7847public:
7848 enum {
7849 NoFieldsSet = 0,
7850 IdSet = 1 << 0,
7851 IsPageContextSet = 1 << 1,
7852 NameSet = 1 << 2,
7853 FrameIdSet = 1 << 3,
7854 AllFieldsSet = (IdSet | IsPageContextSet | NameSet | FrameIdSet)
7855 };
7856
7857 template<int STATE>
7858 class Builder {
7859 private:
7860 RefPtr<JSON::Object> m_result;
7861
7862 template<int STEP> Builder<STATE | STEP>& castState()
7863 {
7864 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7865 }
7866
7867 Builder(Ref</*ExecutionContextDescription*/JSON::Object>&& object)
7868 : m_result(WTFMove(object))
7869 {
7870 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7871 }
7872 friend class ExecutionContextDescription;
7873 public:
7874
7875 Builder<STATE | IdSet>& setId(int value)
7876 {
7877 COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set);
7878 m_result->setInteger("id"_s, value);
7879 return castState<IdSet>();
7880 }
7881
7882 Builder<STATE | IsPageContextSet>& setIsPageContext(bool value)
7883 {
7884 COMPILE_ASSERT(!(STATE & IsPageContextSet), property_isPageContext_already_set);
7885 m_result->setBoolean("isPageContext"_s, value);
7886 return castState<IsPageContextSet>();
7887 }
7888
7889 Builder<STATE | NameSet>& setName(const String& value)
7890 {
7891 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
7892 m_result->setString("name"_s, value);
7893 return castState<NameSet>();
7894 }
7895
7896 Builder<STATE | FrameIdSet>& setFrameId(const String& value)
7897 {
7898 COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set);
7899 m_result->setString("frameId"_s, value);
7900 return castState<FrameIdSet>();
7901 }
7902
7903 Ref<ExecutionContextDescription> release()
7904 {
7905 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7906 COMPILE_ASSERT(sizeof(ExecutionContextDescription) == sizeof(JSON::Object), cannot_cast);
7907
7908 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7909 auto result = WTFMove(*reinterpret_cast<Ref<ExecutionContextDescription>*>(&jsonResult));
7910 return result;
7911 }
7912 };
7913
7914 /*
7915 * Synthetic constructor:
7916 * Ref<ExecutionContextDescription> result = ExecutionContextDescription::create()
7917 * .setId(...)
7918 * .setIsPageContext(...)
7919 * .setName(...)
7920 * .setFrameId(...)
7921 * .release();
7922 */
7923 static Builder<NoFieldsSet> create()
7924 {
7925 return Builder<NoFieldsSet>(JSON::Object::create());
7926 }
7927};
7928
7929/* Syntax error type: "none" for no error, "irrecoverable" for unrecoverable errors, "unterminated-literal" for when there is an unterminated literal, "recoverable" for when the expression is unfinished but valid so far. */
7930enum class SyntaxErrorType {
7931 None = 166,
7932 Irrecoverable = 167,
7933 UnterminatedLiteral = 168,
7934 Recoverable = 169,
7935}; // enum class SyntaxErrorType
7936/* Range of an error in source code. */
7937class ErrorRange : public JSON::ObjectBase {
7938public:
7939 enum {
7940 NoFieldsSet = 0,
7941 StartOffsetSet = 1 << 0,
7942 EndOffsetSet = 1 << 1,
7943 AllFieldsSet = (StartOffsetSet | EndOffsetSet)
7944 };
7945
7946 template<int STATE>
7947 class Builder {
7948 private:
7949 RefPtr<JSON::Object> m_result;
7950
7951 template<int STEP> Builder<STATE | STEP>& castState()
7952 {
7953 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
7954 }
7955
7956 Builder(Ref</*ErrorRange*/JSON::Object>&& object)
7957 : m_result(WTFMove(object))
7958 {
7959 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
7960 }
7961 friend class ErrorRange;
7962 public:
7963
7964 Builder<STATE | StartOffsetSet>& setStartOffset(int value)
7965 {
7966 COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
7967 m_result->setInteger("startOffset"_s, value);
7968 return castState<StartOffsetSet>();
7969 }
7970
7971 Builder<STATE | EndOffsetSet>& setEndOffset(int value)
7972 {
7973 COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
7974 m_result->setInteger("endOffset"_s, value);
7975 return castState<EndOffsetSet>();
7976 }
7977
7978 Ref<ErrorRange> release()
7979 {
7980 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
7981 COMPILE_ASSERT(sizeof(ErrorRange) == sizeof(JSON::Object), cannot_cast);
7982
7983 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
7984 auto result = WTFMove(*reinterpret_cast<Ref<ErrorRange>*>(&jsonResult));
7985 return result;
7986 }
7987 };
7988
7989 /*
7990 * Synthetic constructor:
7991 * Ref<ErrorRange> result = ErrorRange::create()
7992 * .setStartOffset(...)
7993 * .setEndOffset(...)
7994 * .release();
7995 */
7996 static Builder<NoFieldsSet> create()
7997 {
7998 return Builder<NoFieldsSet>(JSON::Object::create());
7999 }
8000};
8001
8002class StructureDescription : public JSON::ObjectBase {
8003public:
8004 enum {
8005 NoFieldsSet = 0,
8006 AllFieldsSet = 0
8007 };
8008
8009 template<int STATE>
8010 class Builder {
8011 private:
8012 RefPtr<JSON::Object> m_result;
8013
8014 template<int STEP> Builder<STATE | STEP>& castState()
8015 {
8016 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8017 }
8018
8019 Builder(Ref</*StructureDescription*/JSON::Object>&& object)
8020 : m_result(WTFMove(object))
8021 {
8022 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8023 }
8024 friend class StructureDescription;
8025 public:
8026
8027 Ref<StructureDescription> release()
8028 {
8029 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8030 COMPILE_ASSERT(sizeof(StructureDescription) == sizeof(JSON::Object), cannot_cast);
8031
8032 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8033 auto result = WTFMove(*reinterpret_cast<Ref<StructureDescription>*>(&jsonResult));
8034 return result;
8035 }
8036 };
8037
8038 /*
8039 * Synthetic constructor:
8040 * Ref<StructureDescription> result = StructureDescription::create()
8041 * .release();
8042 */
8043 static Builder<NoFieldsSet> create()
8044 {
8045 return Builder<NoFieldsSet>(JSON::Object::create());
8046 }
8047
8048 void setFields(RefPtr<JSON::ArrayOf<String>> value)
8049 {
8050 JSON::ObjectBase::setArray("fields"_s, WTFMove(value));
8051 }
8052
8053 void setOptionalFields(RefPtr<JSON::ArrayOf<String>> value)
8054 {
8055 JSON::ObjectBase::setArray("optionalFields"_s, WTFMove(value));
8056 }
8057
8058 void setConstructorName(const String& value)
8059 {
8060 JSON::ObjectBase::setString("constructorName"_s, value);
8061 }
8062
8063 void setPrototypeStructure(RefPtr<Inspector::Protocol::Runtime::StructureDescription> value)
8064 {
8065 JSON::ObjectBase::setObject("prototypeStructure"_s, WTFMove(value));
8066 }
8067
8068 void setIsImprecise(bool value)
8069 {
8070 JSON::ObjectBase::setBoolean("isImprecise"_s, value);
8071 }
8072};
8073
8074class TypeSet : public JSON::ObjectBase {
8075public:
8076 enum {
8077 NoFieldsSet = 0,
8078 IsFunctionSet = 1 << 0,
8079 IsUndefinedSet = 1 << 1,
8080 IsNullSet = 1 << 2,
8081 IsBooleanSet = 1 << 3,
8082 IsIntegerSet = 1 << 4,
8083 IsNumberSet = 1 << 5,
8084 IsStringSet = 1 << 6,
8085 IsObjectSet = 1 << 7,
8086 IsSymbolSet = 1 << 8,
8087 AllFieldsSet = (IsFunctionSet | IsUndefinedSet | IsNullSet | IsBooleanSet | IsIntegerSet | IsNumberSet | IsStringSet | IsObjectSet | IsSymbolSet)
8088 };
8089
8090 template<int STATE>
8091 class Builder {
8092 private:
8093 RefPtr<JSON::Object> m_result;
8094
8095 template<int STEP> Builder<STATE | STEP>& castState()
8096 {
8097 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8098 }
8099
8100 Builder(Ref</*TypeSet*/JSON::Object>&& object)
8101 : m_result(WTFMove(object))
8102 {
8103 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8104 }
8105 friend class TypeSet;
8106 public:
8107
8108 Builder<STATE | IsFunctionSet>& setIsFunction(bool value)
8109 {
8110 COMPILE_ASSERT(!(STATE & IsFunctionSet), property_isFunction_already_set);
8111 m_result->setBoolean("isFunction"_s, value);
8112 return castState<IsFunctionSet>();
8113 }
8114
8115 Builder<STATE | IsUndefinedSet>& setIsUndefined(bool value)
8116 {
8117 COMPILE_ASSERT(!(STATE & IsUndefinedSet), property_isUndefined_already_set);
8118 m_result->setBoolean("isUndefined"_s, value);
8119 return castState<IsUndefinedSet>();
8120 }
8121
8122 Builder<STATE | IsNullSet>& setIsNull(bool value)
8123 {
8124 COMPILE_ASSERT(!(STATE & IsNullSet), property_isNull_already_set);
8125 m_result->setBoolean("isNull"_s, value);
8126 return castState<IsNullSet>();
8127 }
8128
8129 Builder<STATE | IsBooleanSet>& setIsBoolean(bool value)
8130 {
8131 COMPILE_ASSERT(!(STATE & IsBooleanSet), property_isBoolean_already_set);
8132 m_result->setBoolean("isBoolean"_s, value);
8133 return castState<IsBooleanSet>();
8134 }
8135
8136 Builder<STATE | IsIntegerSet>& setIsInteger(bool value)
8137 {
8138 COMPILE_ASSERT(!(STATE & IsIntegerSet), property_isInteger_already_set);
8139 m_result->setBoolean("isInteger"_s, value);
8140 return castState<IsIntegerSet>();
8141 }
8142
8143 Builder<STATE | IsNumberSet>& setIsNumber(bool value)
8144 {
8145 COMPILE_ASSERT(!(STATE & IsNumberSet), property_isNumber_already_set);
8146 m_result->setBoolean("isNumber"_s, value);
8147 return castState<IsNumberSet>();
8148 }
8149
8150 Builder<STATE | IsStringSet>& setIsString(bool value)
8151 {
8152 COMPILE_ASSERT(!(STATE & IsStringSet), property_isString_already_set);
8153 m_result->setBoolean("isString"_s, value);
8154 return castState<IsStringSet>();
8155 }
8156
8157 Builder<STATE | IsObjectSet>& setIsObject(bool value)
8158 {
8159 COMPILE_ASSERT(!(STATE & IsObjectSet), property_isObject_already_set);
8160 m_result->setBoolean("isObject"_s, value);
8161 return castState<IsObjectSet>();
8162 }
8163
8164 Builder<STATE | IsSymbolSet>& setIsSymbol(bool value)
8165 {
8166 COMPILE_ASSERT(!(STATE & IsSymbolSet), property_isSymbol_already_set);
8167 m_result->setBoolean("isSymbol"_s, value);
8168 return castState<IsSymbolSet>();
8169 }
8170
8171 Ref<TypeSet> release()
8172 {
8173 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8174 COMPILE_ASSERT(sizeof(TypeSet) == sizeof(JSON::Object), cannot_cast);
8175
8176 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8177 auto result = WTFMove(*reinterpret_cast<Ref<TypeSet>*>(&jsonResult));
8178 return result;
8179 }
8180 };
8181
8182 /*
8183 * Synthetic constructor:
8184 * Ref<TypeSet> result = TypeSet::create()
8185 * .setIsFunction(...)
8186 * .setIsUndefined(...)
8187 * .setIsNull(...)
8188 * .setIsBoolean(...)
8189 * .setIsInteger(...)
8190 * .setIsNumber(...)
8191 * .setIsString(...)
8192 * .setIsObject(...)
8193 * .setIsSymbol(...)
8194 * .release();
8195 */
8196 static Builder<NoFieldsSet> create()
8197 {
8198 return Builder<NoFieldsSet>(JSON::Object::create());
8199 }
8200};
8201
8202/* Container for type information that has been gathered. */
8203class TypeDescription : public JSON::ObjectBase {
8204public:
8205 enum {
8206 NoFieldsSet = 0,
8207 IsValidSet = 1 << 0,
8208 AllFieldsSet = (IsValidSet)
8209 };
8210
8211 template<int STATE>
8212 class Builder {
8213 private:
8214 RefPtr<JSON::Object> m_result;
8215
8216 template<int STEP> Builder<STATE | STEP>& castState()
8217 {
8218 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8219 }
8220
8221 Builder(Ref</*TypeDescription*/JSON::Object>&& object)
8222 : m_result(WTFMove(object))
8223 {
8224 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8225 }
8226 friend class TypeDescription;
8227 public:
8228
8229 Builder<STATE | IsValidSet>& setIsValid(bool value)
8230 {
8231 COMPILE_ASSERT(!(STATE & IsValidSet), property_isValid_already_set);
8232 m_result->setBoolean("isValid"_s, value);
8233 return castState<IsValidSet>();
8234 }
8235
8236 Ref<TypeDescription> release()
8237 {
8238 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8239 COMPILE_ASSERT(sizeof(TypeDescription) == sizeof(JSON::Object), cannot_cast);
8240
8241 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8242 auto result = WTFMove(*reinterpret_cast<Ref<TypeDescription>*>(&jsonResult));
8243 return result;
8244 }
8245 };
8246
8247 /*
8248 * Synthetic constructor:
8249 * Ref<TypeDescription> result = TypeDescription::create()
8250 * .setIsValid(...)
8251 * .release();
8252 */
8253 static Builder<NoFieldsSet> create()
8254 {
8255 return Builder<NoFieldsSet>(JSON::Object::create());
8256 }
8257
8258 void setLeastCommonAncestor(const String& value)
8259 {
8260 JSON::ObjectBase::setString("leastCommonAncestor"_s, value);
8261 }
8262
8263 void setTypeSet(RefPtr<Inspector::Protocol::Runtime::TypeSet> value)
8264 {
8265 JSON::ObjectBase::setObject("typeSet"_s, WTFMove(value));
8266 }
8267
8268 void setStructures(RefPtr<JSON::ArrayOf<Inspector::Protocol::Runtime::StructureDescription>> value)
8269 {
8270 JSON::ObjectBase::setArray("structures"_s, WTFMove(value));
8271 }
8272
8273 void setIsTruncated(bool value)
8274 {
8275 JSON::ObjectBase::setBoolean("isTruncated"_s, value);
8276 }
8277};
8278
8279/* Describes the location of an expression we want type information for. */
8280class TypeLocation : public JSON::ObjectBase {
8281public:
8282 enum {
8283 NoFieldsSet = 0,
8284 TypeInformationDescriptorSet = 1 << 0,
8285 SourceIDSet = 1 << 1,
8286 DivotSet = 1 << 2,
8287 AllFieldsSet = (TypeInformationDescriptorSet | SourceIDSet | DivotSet)
8288 };
8289
8290 template<int STATE>
8291 class Builder {
8292 private:
8293 RefPtr<JSON::Object> m_result;
8294
8295 template<int STEP> Builder<STATE | STEP>& castState()
8296 {
8297 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8298 }
8299
8300 Builder(Ref</*TypeLocation*/JSON::Object>&& object)
8301 : m_result(WTFMove(object))
8302 {
8303 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8304 }
8305 friend class TypeLocation;
8306 public:
8307
8308 Builder<STATE | TypeInformationDescriptorSet>& setTypeInformationDescriptor(int value)
8309 {
8310 COMPILE_ASSERT(!(STATE & TypeInformationDescriptorSet), property_typeInformationDescriptor_already_set);
8311 m_result->setInteger("typeInformationDescriptor"_s, value);
8312 return castState<TypeInformationDescriptorSet>();
8313 }
8314
8315 Builder<STATE | SourceIDSet>& setSourceID(const String& value)
8316 {
8317 COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
8318 m_result->setString("sourceID"_s, value);
8319 return castState<SourceIDSet>();
8320 }
8321
8322 Builder<STATE | DivotSet>& setDivot(int value)
8323 {
8324 COMPILE_ASSERT(!(STATE & DivotSet), property_divot_already_set);
8325 m_result->setInteger("divot"_s, value);
8326 return castState<DivotSet>();
8327 }
8328
8329 Ref<TypeLocation> release()
8330 {
8331 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8332 COMPILE_ASSERT(sizeof(TypeLocation) == sizeof(JSON::Object), cannot_cast);
8333
8334 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8335 auto result = WTFMove(*reinterpret_cast<Ref<TypeLocation>*>(&jsonResult));
8336 return result;
8337 }
8338 };
8339
8340 /*
8341 * Synthetic constructor:
8342 * Ref<TypeLocation> result = TypeLocation::create()
8343 * .setTypeInformationDescriptor(...)
8344 * .setSourceID(...)
8345 * .setDivot(...)
8346 * .release();
8347 */
8348 static Builder<NoFieldsSet> create()
8349 {
8350 return Builder<NoFieldsSet>(JSON::Object::create());
8351 }
8352};
8353
8354/* From Wikipedia: a basic block is a portion of the code within a program with only one entry point and only one exit point. This type gives the location of a basic block and if that basic block has executed. */
8355class BasicBlock : public JSON::ObjectBase {
8356public:
8357 enum {
8358 NoFieldsSet = 0,
8359 StartOffsetSet = 1 << 0,
8360 EndOffsetSet = 1 << 1,
8361 HasExecutedSet = 1 << 2,
8362 ExecutionCountSet = 1 << 3,
8363 AllFieldsSet = (StartOffsetSet | EndOffsetSet | HasExecutedSet | ExecutionCountSet)
8364 };
8365
8366 template<int STATE>
8367 class Builder {
8368 private:
8369 RefPtr<JSON::Object> m_result;
8370
8371 template<int STEP> Builder<STATE | STEP>& castState()
8372 {
8373 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8374 }
8375
8376 Builder(Ref</*BasicBlock*/JSON::Object>&& object)
8377 : m_result(WTFMove(object))
8378 {
8379 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8380 }
8381 friend class BasicBlock;
8382 public:
8383
8384 Builder<STATE | StartOffsetSet>& setStartOffset(int value)
8385 {
8386 COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set);
8387 m_result->setInteger("startOffset"_s, value);
8388 return castState<StartOffsetSet>();
8389 }
8390
8391 Builder<STATE | EndOffsetSet>& setEndOffset(int value)
8392 {
8393 COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set);
8394 m_result->setInteger("endOffset"_s, value);
8395 return castState<EndOffsetSet>();
8396 }
8397
8398 Builder<STATE | HasExecutedSet>& setHasExecuted(bool value)
8399 {
8400 COMPILE_ASSERT(!(STATE & HasExecutedSet), property_hasExecuted_already_set);
8401 m_result->setBoolean("hasExecuted"_s, value);
8402 return castState<HasExecutedSet>();
8403 }
8404
8405 Builder<STATE | ExecutionCountSet>& setExecutionCount(int value)
8406 {
8407 COMPILE_ASSERT(!(STATE & ExecutionCountSet), property_executionCount_already_set);
8408 m_result->setInteger("executionCount"_s, value);
8409 return castState<ExecutionCountSet>();
8410 }
8411
8412 Ref<BasicBlock> release()
8413 {
8414 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8415 COMPILE_ASSERT(sizeof(BasicBlock) == sizeof(JSON::Object), cannot_cast);
8416
8417 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8418 auto result = WTFMove(*reinterpret_cast<Ref<BasicBlock>*>(&jsonResult));
8419 return result;
8420 }
8421 };
8422
8423 /*
8424 * Synthetic constructor:
8425 * Ref<BasicBlock> result = BasicBlock::create()
8426 * .setStartOffset(...)
8427 * .setEndOffset(...)
8428 * .setHasExecuted(...)
8429 * .setExecutionCount(...)
8430 * .release();
8431 */
8432 static Builder<NoFieldsSet> create()
8433 {
8434 return Builder<NoFieldsSet>(JSON::Object::create());
8435 }
8436};
8437
8438} // Runtime
8439
8440namespace ScriptProfiler {
8441/* */
8442enum class EventType {
8443 API = 170,
8444 Microtask = 171,
8445 Other = 127,
8446}; // enum class EventType
8447class Event : public JSON::ObjectBase {
8448public:
8449 enum {
8450 NoFieldsSet = 0,
8451 StartTimeSet = 1 << 0,
8452 EndTimeSet = 1 << 1,
8453 TypeSet = 1 << 2,
8454 AllFieldsSet = (StartTimeSet | EndTimeSet | TypeSet)
8455 };
8456
8457 template<int STATE>
8458 class Builder {
8459 private:
8460 RefPtr<JSON::Object> m_result;
8461
8462 template<int STEP> Builder<STATE | STEP>& castState()
8463 {
8464 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8465 }
8466
8467 Builder(Ref</*Event*/JSON::Object>&& object)
8468 : m_result(WTFMove(object))
8469 {
8470 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8471 }
8472 friend class Event;
8473 public:
8474
8475 Builder<STATE | StartTimeSet>& setStartTime(double value)
8476 {
8477 COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set);
8478 m_result->setDouble("startTime"_s, value);
8479 return castState<StartTimeSet>();
8480 }
8481
8482 Builder<STATE | EndTimeSet>& setEndTime(double value)
8483 {
8484 COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set);
8485 m_result->setDouble("endTime"_s, value);
8486 return castState<EndTimeSet>();
8487 }
8488
8489 Builder<STATE | TypeSet>& setType(Inspector::Protocol::ScriptProfiler::EventType value)
8490 {
8491 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
8492 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
8493 return castState<TypeSet>();
8494 }
8495
8496 Ref<Event> release()
8497 {
8498 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8499 COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast);
8500
8501 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8502 auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult));
8503 return result;
8504 }
8505 };
8506
8507 /*
8508 * Synthetic constructor:
8509 * Ref<Event> result = Event::create()
8510 * .setStartTime(...)
8511 * .setEndTime(...)
8512 * .setType(...)
8513 * .release();
8514 */
8515 static Builder<NoFieldsSet> create()
8516 {
8517 return Builder<NoFieldsSet>(JSON::Object::create());
8518 }
8519};
8520
8521class ExpressionLocation : public JSON::ObjectBase {
8522public:
8523 enum {
8524 NoFieldsSet = 0,
8525 LineSet = 1 << 0,
8526 ColumnSet = 1 << 1,
8527 AllFieldsSet = (LineSet | ColumnSet)
8528 };
8529
8530 template<int STATE>
8531 class Builder {
8532 private:
8533 RefPtr<JSON::Object> m_result;
8534
8535 template<int STEP> Builder<STATE | STEP>& castState()
8536 {
8537 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8538 }
8539
8540 Builder(Ref</*ExpressionLocation*/JSON::Object>&& object)
8541 : m_result(WTFMove(object))
8542 {
8543 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8544 }
8545 friend class ExpressionLocation;
8546 public:
8547
8548 Builder<STATE | LineSet>& setLine(int value)
8549 {
8550 COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
8551 m_result->setInteger("line"_s, value);
8552 return castState<LineSet>();
8553 }
8554
8555 Builder<STATE | ColumnSet>& setColumn(int value)
8556 {
8557 COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
8558 m_result->setInteger("column"_s, value);
8559 return castState<ColumnSet>();
8560 }
8561
8562 Ref<ExpressionLocation> release()
8563 {
8564 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8565 COMPILE_ASSERT(sizeof(ExpressionLocation) == sizeof(JSON::Object), cannot_cast);
8566
8567 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8568 auto result = WTFMove(*reinterpret_cast<Ref<ExpressionLocation>*>(&jsonResult));
8569 return result;
8570 }
8571 };
8572
8573 /*
8574 * Synthetic constructor:
8575 * Ref<ExpressionLocation> result = ExpressionLocation::create()
8576 * .setLine(...)
8577 * .setColumn(...)
8578 * .release();
8579 */
8580 static Builder<NoFieldsSet> create()
8581 {
8582 return Builder<NoFieldsSet>(JSON::Object::create());
8583 }
8584};
8585
8586class StackFrame : public JSON::ObjectBase {
8587public:
8588 enum {
8589 NoFieldsSet = 0,
8590 SourceIDSet = 1 << 0,
8591 NameSet = 1 << 1,
8592 LineSet = 1 << 2,
8593 ColumnSet = 1 << 3,
8594 UrlSet = 1 << 4,
8595 AllFieldsSet = (SourceIDSet | NameSet | LineSet | ColumnSet | UrlSet)
8596 };
8597
8598 template<int STATE>
8599 class Builder {
8600 private:
8601 RefPtr<JSON::Object> m_result;
8602
8603 template<int STEP> Builder<STATE | STEP>& castState()
8604 {
8605 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8606 }
8607
8608 Builder(Ref</*StackFrame*/JSON::Object>&& object)
8609 : m_result(WTFMove(object))
8610 {
8611 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8612 }
8613 friend class StackFrame;
8614 public:
8615
8616 Builder<STATE | SourceIDSet>& setSourceID(const String& value)
8617 {
8618 COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set);
8619 m_result->setString("sourceID"_s, value);
8620 return castState<SourceIDSet>();
8621 }
8622
8623 Builder<STATE | NameSet>& setName(const String& value)
8624 {
8625 COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set);
8626 m_result->setString("name"_s, value);
8627 return castState<NameSet>();
8628 }
8629
8630 Builder<STATE | LineSet>& setLine(int value)
8631 {
8632 COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set);
8633 m_result->setInteger("line"_s, value);
8634 return castState<LineSet>();
8635 }
8636
8637 Builder<STATE | ColumnSet>& setColumn(int value)
8638 {
8639 COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set);
8640 m_result->setInteger("column"_s, value);
8641 return castState<ColumnSet>();
8642 }
8643
8644 Builder<STATE | UrlSet>& setUrl(const String& value)
8645 {
8646 COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set);
8647 m_result->setString("url"_s, value);
8648 return castState<UrlSet>();
8649 }
8650
8651 Ref<StackFrame> release()
8652 {
8653 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8654 COMPILE_ASSERT(sizeof(StackFrame) == sizeof(JSON::Object), cannot_cast);
8655
8656 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8657 auto result = WTFMove(*reinterpret_cast<Ref<StackFrame>*>(&jsonResult));
8658 return result;
8659 }
8660 };
8661
8662 /*
8663 * Synthetic constructor:
8664 * Ref<StackFrame> result = StackFrame::create()
8665 * .setSourceID(...)
8666 * .setName(...)
8667 * .setLine(...)
8668 * .setColumn(...)
8669 * .setUrl(...)
8670 * .release();
8671 */
8672 static Builder<NoFieldsSet> create()
8673 {
8674 return Builder<NoFieldsSet>(JSON::Object::create());
8675 }
8676
8677 void setExpressionLocation(RefPtr<Inspector::Protocol::ScriptProfiler::ExpressionLocation> value)
8678 {
8679 JSON::ObjectBase::setObject("expressionLocation"_s, WTFMove(value));
8680 }
8681};
8682
8683class StackTrace : public JSON::ObjectBase {
8684public:
8685 enum {
8686 NoFieldsSet = 0,
8687 TimestampSet = 1 << 0,
8688 StackFramesSet = 1 << 1,
8689 AllFieldsSet = (TimestampSet | StackFramesSet)
8690 };
8691
8692 template<int STATE>
8693 class Builder {
8694 private:
8695 RefPtr<JSON::Object> m_result;
8696
8697 template<int STEP> Builder<STATE | STEP>& castState()
8698 {
8699 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8700 }
8701
8702 Builder(Ref</*StackTrace*/JSON::Object>&& object)
8703 : m_result(WTFMove(object))
8704 {
8705 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8706 }
8707 friend class StackTrace;
8708 public:
8709
8710 Builder<STATE | TimestampSet>& setTimestamp(double value)
8711 {
8712 COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set);
8713 m_result->setDouble("timestamp"_s, value);
8714 return castState<TimestampSet>();
8715 }
8716
8717 Builder<STATE | StackFramesSet>& setStackFrames(RefPtr<JSON::ArrayOf<Inspector::Protocol::ScriptProfiler::StackFrame>> value)
8718 {
8719 COMPILE_ASSERT(!(STATE & StackFramesSet), property_stackFrames_already_set);
8720 m_result->setArray("stackFrames"_s, value);
8721 return castState<StackFramesSet>();
8722 }
8723
8724 Ref<StackTrace> release()
8725 {
8726 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8727 COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast);
8728
8729 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8730 auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult));
8731 return result;
8732 }
8733 };
8734
8735 /*
8736 * Synthetic constructor:
8737 * Ref<StackTrace> result = StackTrace::create()
8738 * .setTimestamp(...)
8739 * .setStackFrames(...)
8740 * .release();
8741 */
8742 static Builder<NoFieldsSet> create()
8743 {
8744 return Builder<NoFieldsSet>(JSON::Object::create());
8745 }
8746};
8747
8748class Samples : public JSON::ObjectBase {
8749public:
8750 enum {
8751 NoFieldsSet = 0,
8752 StackTracesSet = 1 << 0,
8753 AllFieldsSet = (StackTracesSet)
8754 };
8755
8756 template<int STATE>
8757 class Builder {
8758 private:
8759 RefPtr<JSON::Object> m_result;
8760
8761 template<int STEP> Builder<STATE | STEP>& castState()
8762 {
8763 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8764 }
8765
8766 Builder(Ref</*Samples*/JSON::Object>&& object)
8767 : m_result(WTFMove(object))
8768 {
8769 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8770 }
8771 friend class Samples;
8772 public:
8773
8774 Builder<STATE | StackTracesSet>& setStackTraces(RefPtr<JSON::ArrayOf<Inspector::Protocol::ScriptProfiler::StackTrace>> value)
8775 {
8776 COMPILE_ASSERT(!(STATE & StackTracesSet), property_stackTraces_already_set);
8777 m_result->setArray("stackTraces"_s, value);
8778 return castState<StackTracesSet>();
8779 }
8780
8781 Ref<Samples> release()
8782 {
8783 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8784 COMPILE_ASSERT(sizeof(Samples) == sizeof(JSON::Object), cannot_cast);
8785
8786 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8787 auto result = WTFMove(*reinterpret_cast<Ref<Samples>*>(&jsonResult));
8788 return result;
8789 }
8790 };
8791
8792 /*
8793 * Synthetic constructor:
8794 * Ref<Samples> result = Samples::create()
8795 * .setStackTraces(...)
8796 * .release();
8797 */
8798 static Builder<NoFieldsSet> create()
8799 {
8800 return Builder<NoFieldsSet>(JSON::Object::create());
8801 }
8802};
8803
8804} // ScriptProfiler
8805
8806namespace Security {
8807/* Information about a SSL connection to display in the frontend. */
8808class Connection : public JSON::ObjectBase {
8809public:
8810 enum {
8811 NoFieldsSet = 0,
8812 AllFieldsSet = 0
8813 };
8814
8815 template<int STATE>
8816 class Builder {
8817 private:
8818 RefPtr<JSON::Object> m_result;
8819
8820 template<int STEP> Builder<STATE | STEP>& castState()
8821 {
8822 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8823 }
8824
8825 Builder(Ref</*Connection*/JSON::Object>&& object)
8826 : m_result(WTFMove(object))
8827 {
8828 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8829 }
8830 friend class Connection;
8831 public:
8832
8833 Ref<Connection> release()
8834 {
8835 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8836 COMPILE_ASSERT(sizeof(Connection) == sizeof(JSON::Object), cannot_cast);
8837
8838 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8839 auto result = WTFMove(*reinterpret_cast<Ref<Connection>*>(&jsonResult));
8840 return result;
8841 }
8842 };
8843
8844 /*
8845 * Synthetic constructor:
8846 * Ref<Connection> result = Connection::create()
8847 * .release();
8848 */
8849 static Builder<NoFieldsSet> create()
8850 {
8851 return Builder<NoFieldsSet>(JSON::Object::create());
8852 }
8853
8854 void setProtocol(const String& value)
8855 {
8856 JSON::ObjectBase::setString("protocol"_s, value);
8857 }
8858
8859 void setCipher(const String& value)
8860 {
8861 JSON::ObjectBase::setString("cipher"_s, value);
8862 }
8863};
8864
8865/* Information about a SSL certificate to display in the frontend. */
8866class Certificate : public JSON::ObjectBase {
8867public:
8868 enum {
8869 NoFieldsSet = 0,
8870 AllFieldsSet = 0
8871 };
8872
8873 template<int STATE>
8874 class Builder {
8875 private:
8876 RefPtr<JSON::Object> m_result;
8877
8878 template<int STEP> Builder<STATE | STEP>& castState()
8879 {
8880 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8881 }
8882
8883 Builder(Ref</*Certificate*/JSON::Object>&& object)
8884 : m_result(WTFMove(object))
8885 {
8886 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8887 }
8888 friend class Certificate;
8889 public:
8890
8891 Ref<Certificate> release()
8892 {
8893 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8894 COMPILE_ASSERT(sizeof(Certificate) == sizeof(JSON::Object), cannot_cast);
8895
8896 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8897 auto result = WTFMove(*reinterpret_cast<Ref<Certificate>*>(&jsonResult));
8898 return result;
8899 }
8900 };
8901
8902 /*
8903 * Synthetic constructor:
8904 * Ref<Certificate> result = Certificate::create()
8905 * .release();
8906 */
8907 static Builder<NoFieldsSet> create()
8908 {
8909 return Builder<NoFieldsSet>(JSON::Object::create());
8910 }
8911
8912 void setSubject(const String& value)
8913 {
8914 JSON::ObjectBase::setString("subject"_s, value);
8915 }
8916
8917 void setValidFrom(double value)
8918 {
8919 JSON::ObjectBase::setDouble("validFrom"_s, value);
8920 }
8921
8922 void setValidUntil(double value)
8923 {
8924 JSON::ObjectBase::setDouble("validUntil"_s, value);
8925 }
8926
8927 void setDnsNames(RefPtr<JSON::ArrayOf<String>> value)
8928 {
8929 JSON::ObjectBase::setArray("dnsNames"_s, WTFMove(value));
8930 }
8931
8932 void setIpAddresses(RefPtr<JSON::ArrayOf<String>> value)
8933 {
8934 JSON::ObjectBase::setArray("ipAddresses"_s, WTFMove(value));
8935 }
8936};
8937
8938/* Security information for a given Network.Response. */
8939class Security : public JSON::ObjectBase {
8940public:
8941 enum {
8942 NoFieldsSet = 0,
8943 AllFieldsSet = 0
8944 };
8945
8946 template<int STATE>
8947 class Builder {
8948 private:
8949 RefPtr<JSON::Object> m_result;
8950
8951 template<int STEP> Builder<STATE | STEP>& castState()
8952 {
8953 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
8954 }
8955
8956 Builder(Ref</*Security*/JSON::Object>&& object)
8957 : m_result(WTFMove(object))
8958 {
8959 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
8960 }
8961 friend class Security;
8962 public:
8963
8964 Ref<Security> release()
8965 {
8966 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
8967 COMPILE_ASSERT(sizeof(Security) == sizeof(JSON::Object), cannot_cast);
8968
8969 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
8970 auto result = WTFMove(*reinterpret_cast<Ref<Security>*>(&jsonResult));
8971 return result;
8972 }
8973 };
8974
8975 /*
8976 * Synthetic constructor:
8977 * Ref<Security> result = Security::create()
8978 * .release();
8979 */
8980 static Builder<NoFieldsSet> create()
8981 {
8982 return Builder<NoFieldsSet>(JSON::Object::create());
8983 }
8984
8985 void setConnection(RefPtr<Inspector::Protocol::Security::Connection> value)
8986 {
8987 JSON::ObjectBase::setObject("connection"_s, WTFMove(value));
8988 }
8989
8990 void setCertificate(RefPtr<Inspector::Protocol::Security::Certificate> value)
8991 {
8992 JSON::ObjectBase::setObject("certificate"_s, WTFMove(value));
8993 }
8994};
8995
8996} // Security
8997
8998namespace Target {
8999/* Description of a target. */
9000class TargetInfo : public JSON::ObjectBase {
9001public:
9002 // Named after property name 'type' while generating TargetInfo.
9003 enum class Type {
9004 JavaScript = 33,
9005 Page = 79,
9006 Worker = 172,
9007 ServiceWorker = 173,
9008 }; // enum class Type
9009 enum {
9010 NoFieldsSet = 0,
9011 TargetIdSet = 1 << 0,
9012 TypeSet = 1 << 1,
9013 AllFieldsSet = (TargetIdSet | TypeSet)
9014 };
9015
9016 template<int STATE>
9017 class Builder {
9018 private:
9019 RefPtr<JSON::Object> m_result;
9020
9021 template<int STEP> Builder<STATE | STEP>& castState()
9022 {
9023 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9024 }
9025
9026 Builder(Ref</*TargetInfo*/JSON::Object>&& object)
9027 : m_result(WTFMove(object))
9028 {
9029 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9030 }
9031 friend class TargetInfo;
9032 public:
9033
9034 Builder<STATE | TargetIdSet>& setTargetId(const String& value)
9035 {
9036 COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set);
9037 m_result->setString("targetId"_s, value);
9038 return castState<TargetIdSet>();
9039 }
9040
9041 Builder<STATE | TypeSet>& setType(Type value)
9042 {
9043 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9044 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
9045 return castState<TypeSet>();
9046 }
9047
9048 Ref<TargetInfo> release()
9049 {
9050 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9051 COMPILE_ASSERT(sizeof(TargetInfo) == sizeof(JSON::Object), cannot_cast);
9052
9053 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9054 auto result = WTFMove(*reinterpret_cast<Ref<TargetInfo>*>(&jsonResult));
9055 return result;
9056 }
9057 };
9058
9059 /*
9060 * Synthetic constructor:
9061 * Ref<TargetInfo> result = TargetInfo::create()
9062 * .setTargetId(...)
9063 * .setType(...)
9064 * .release();
9065 */
9066 static Builder<NoFieldsSet> create()
9067 {
9068 return Builder<NoFieldsSet>(JSON::Object::create());
9069 }
9070};
9071
9072} // Target
9073
9074namespace Timeline {
9075/* Timeline record type. */
9076enum class EventType {
9077 EventDispatch = 174,
9078 ScheduleStyleRecalculation = 175,
9079 RecalculateStyles = 176,
9080 InvalidateLayout = 177,
9081 Layout = 178,
9082 Paint = 179,
9083 Composite = 180,
9084 RenderingFrame = 181,
9085 TimerInstall = 182,
9086 TimerRemove = 183,
9087 TimerFire = 184,
9088 EvaluateScript = 185,
9089 TimeStamp = 186,
9090 Time = 187,
9091 TimeEnd = 188,
9092 FunctionCall = 189,
9093 ProbeSample = 190,
9094 ConsoleProfile = 191,
9095 RequestAnimationFrame = 192,
9096 CancelAnimationFrame = 193,
9097 FireAnimationFrame = 194,
9098 ObserverCallback = 195,
9099}; // enum class EventType
9100/* Instrument types. */
9101enum class Instrument {
9102 ScriptProfiler = 196,
9103 Timeline = 197,
9104 CPU = 198,
9105 Memory = 199,
9106 Heap = 200,
9107}; // enum class Instrument
9108/* Timeline record contains information about the recorded activity. */
9109class TimelineEvent : public JSON::Object {
9110public:
9111 enum {
9112 NoFieldsSet = 0,
9113 TypeSet = 1 << 0,
9114 DataSet = 1 << 1,
9115 AllFieldsSet = (TypeSet | DataSet)
9116 };
9117
9118 template<int STATE>
9119 class Builder {
9120 private:
9121 RefPtr<JSON::Object> m_result;
9122
9123 template<int STEP> Builder<STATE | STEP>& castState()
9124 {
9125 return *reinterpret_cast<Builder<STATE | STEP>*>(this);
9126 }
9127
9128 Builder(Ref</*TimelineEvent*/JSON::Object>&& object)
9129 : m_result(WTFMove(object))
9130 {
9131 COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state);
9132 }
9133 friend class TimelineEvent;
9134 public:
9135
9136 Builder<STATE | TypeSet>& setType(Inspector::Protocol::Timeline::EventType value)
9137 {
9138 COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set);
9139 m_result->setString("type"_s, Inspector::Protocol::InspectorHelpers::getEnumConstantValue(value));
9140 return castState<TypeSet>();
9141 }
9142
9143 Builder<STATE | DataSet>& setData(RefPtr<JSON::Object> value)
9144 {
9145 COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set);
9146 m_result->setObject("data"_s, value);
9147 return castState<DataSet>();
9148 }
9149
9150 Ref<TimelineEvent> release()
9151 {
9152 COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready);
9153 COMPILE_ASSERT(sizeof(TimelineEvent) == sizeof(JSON::Object), cannot_cast);
9154
9155 Ref<JSON::Object> jsonResult = m_result.releaseNonNull();
9156 auto result = WTFMove(*reinterpret_cast<Ref<TimelineEvent>*>(&jsonResult));
9157 return result;
9158 }
9159 };
9160
9161 /*
9162 * Synthetic constructor:
9163 * Ref<TimelineEvent> result = TimelineEvent::create()
9164 * .setType(...)
9165 * .setData(...)
9166 * .release();
9167 */
9168 static Builder<NoFieldsSet> create()
9169 {
9170 return Builder<NoFieldsSet>(JSON::Object::create());
9171 }
9172
9173 void setChildren(RefPtr<JSON::ArrayOf<Inspector::Protocol::Timeline::TimelineEvent>> value)
9174 {
9175 JSON::ObjectBase::setArray("children"_s, WTFMove(value));
9176 }
9177
9178 // Property names for type generated as open.
9179 JS_EXPORT_PRIVATE static const char* Type;
9180 JS_EXPORT_PRIVATE static const char* Data;
9181 JS_EXPORT_PRIVATE static const char* Children;
9182};
9183
9184} // Timeline
9185
9186template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::Location> {
9187static void assertValueHasExpectedType(JSON::Value*);
9188};
9189template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::FunctionDetails> {
9190static RefPtr<Inspector::Protocol::Debugger::FunctionDetails> runtimeCast(RefPtr<JSON::Value>&& value);
9191static void assertValueHasExpectedType(JSON::Value*);
9192};
9193template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::CallFrame> {
9194static RefPtr<Inspector::Protocol::Debugger::CallFrame> runtimeCast(RefPtr<JSON::Value>&& value);
9195static void assertValueHasExpectedType(JSON::Value*);
9196};
9197template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::Scope::Type> {
9198static void assertValueHasExpectedType(JSON::Value*);
9199};
9200template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Debugger::Scope> {
9201static void assertValueHasExpectedType(JSON::Value*);
9202};
9203template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::RemoteObject::Type> {
9204static void assertValueHasExpectedType(JSON::Value*);
9205};
9206template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::RemoteObject::Subtype> {
9207static void assertValueHasExpectedType(JSON::Value*);
9208};
9209template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::RemoteObject> {
9210static RefPtr<Inspector::Protocol::Runtime::RemoteObject> runtimeCast(RefPtr<JSON::Value>&& value);
9211static void assertValueHasExpectedType(JSON::Value*);
9212};
9213template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::ObjectPreview::Type> {
9214static void assertValueHasExpectedType(JSON::Value*);
9215};
9216template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::ObjectPreview::Subtype> {
9217static void assertValueHasExpectedType(JSON::Value*);
9218};
9219template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::ObjectPreview> {
9220static RefPtr<Inspector::Protocol::Runtime::ObjectPreview> runtimeCast(RefPtr<JSON::Value>&& value);
9221static void assertValueHasExpectedType(JSON::Value*);
9222};
9223template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyPreview::Type> {
9224static void assertValueHasExpectedType(JSON::Value*);
9225};
9226template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyPreview::Subtype> {
9227static void assertValueHasExpectedType(JSON::Value*);
9228};
9229template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyPreview> {
9230static void assertValueHasExpectedType(JSON::Value*);
9231};
9232template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::EntryPreview> {
9233static void assertValueHasExpectedType(JSON::Value*);
9234};
9235template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::CollectionEntry> {
9236static RefPtr<Inspector::Protocol::Runtime::CollectionEntry> runtimeCast(RefPtr<JSON::Value>&& value);
9237static void assertValueHasExpectedType(JSON::Value*);
9238};
9239template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::PropertyDescriptor> {
9240static RefPtr<Inspector::Protocol::Runtime::PropertyDescriptor> runtimeCast(RefPtr<JSON::Value>&& value);
9241static void assertValueHasExpectedType(JSON::Value*);
9242};
9243template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Runtime::InternalPropertyDescriptor> {
9244static RefPtr<Inspector::Protocol::Runtime::InternalPropertyDescriptor> runtimeCast(RefPtr<JSON::Value>&& value);
9245static void assertValueHasExpectedType(JSON::Value*);
9246};
9247template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Timeline::EventType> {
9248static void assertValueHasExpectedType(JSON::Value*);
9249};
9250template<> struct JS_EXPORT_PRIVATE BindingTraits<Inspector::Protocol::Timeline::TimelineEvent> {
9251static RefPtr<Inspector::Protocol::Timeline::TimelineEvent> runtimeCast(RefPtr<JSON::Value>&& value);
9252static void assertValueHasExpectedType(JSON::Value*);
9253};
9254
9255namespace InspectorHelpers {
9256
9257template<typename ProtocolEnumType>
9258Optional<ProtocolEnumType> parseEnumValueFromString(const String&);
9259
9260// Enums in the 'CSS' Domain
9261template<>
9262JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::StyleSheetOrigin> parseEnumValueFromString<Inspector::Protocol::CSS::StyleSheetOrigin>(const String&);
9263template<>
9264JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::PseudoId> parseEnumValueFromString<Inspector::Protocol::CSS::PseudoId>(const String&);
9265template<>
9266JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::CSSPropertyStatus> parseEnumValueFromString<Inspector::Protocol::CSS::CSSPropertyStatus>(const String&);
9267template<>
9268JS_EXPORT_PRIVATE Optional<Inspector::Protocol::CSS::CSSMedia::Source> parseEnumValueFromString<Inspector::Protocol::CSS::CSSMedia::Source>(const String&);
9269
9270// Enums in the 'Canvas' Domain
9271template<>
9272JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Canvas::ContextType> parseEnumValueFromString<Inspector::Protocol::Canvas::ContextType>(const String&);
9273template<>
9274JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Canvas::ShaderType> parseEnumValueFromString<Inspector::Protocol::Canvas::ShaderType>(const String&);
9275
9276// Enums in the 'Console' Domain
9277template<>
9278JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ChannelSource> parseEnumValueFromString<Inspector::Protocol::Console::ChannelSource>(const String&);
9279template<>
9280JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ChannelLevel> parseEnumValueFromString<Inspector::Protocol::Console::ChannelLevel>(const String&);
9281template<>
9282JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ConsoleMessage::Level> parseEnumValueFromString<Inspector::Protocol::Console::ConsoleMessage::Level>(const String&);
9283template<>
9284JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Console::ConsoleMessage::Type> parseEnumValueFromString<Inspector::Protocol::Console::ConsoleMessage::Type>(const String&);
9285
9286// Enums in the 'DOM' Domain
9287template<>
9288JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::PseudoType> parseEnumValueFromString<Inspector::Protocol::DOM::PseudoType>(const String&);
9289template<>
9290JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::ShadowRootType> parseEnumValueFromString<Inspector::Protocol::DOM::ShadowRootType>(const String&);
9291template<>
9292JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::CustomElementState> parseEnumValueFromString<Inspector::Protocol::DOM::CustomElementState>(const String&);
9293template<>
9294JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::LiveRegionRelevant> parseEnumValueFromString<Inspector::Protocol::DOM::LiveRegionRelevant>(const String&);
9295template<>
9296JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::Checked> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::Checked>(const String&);
9297template<>
9298JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::Current> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::Current>(const String&);
9299template<>
9300JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::Invalid> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::Invalid>(const String&);
9301template<>
9302JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOM::AccessibilityProperties::LiveRegionStatus> parseEnumValueFromString<Inspector::Protocol::DOM::AccessibilityProperties::LiveRegionStatus>(const String&);
9303
9304// Enums in the 'DOMDebugger' Domain
9305template<>
9306JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOMDebugger::DOMBreakpointType> parseEnumValueFromString<Inspector::Protocol::DOMDebugger::DOMBreakpointType>(const String&);
9307template<>
9308JS_EXPORT_PRIVATE Optional<Inspector::Protocol::DOMDebugger::EventBreakpointType> parseEnumValueFromString<Inspector::Protocol::DOMDebugger::EventBreakpointType>(const String&);
9309
9310// Enums in the 'Debugger' Domain
9311template<>
9312JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Debugger::BreakpointAction::Type> parseEnumValueFromString<Inspector::Protocol::Debugger::BreakpointAction::Type>(const String&);
9313template<>
9314JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Debugger::Scope::Type> parseEnumValueFromString<Inspector::Protocol::Debugger::Scope::Type>(const String&);
9315
9316// Enums in the 'Heap' Domain
9317template<>
9318JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Heap::GarbageCollection::Type> parseEnumValueFromString<Inspector::Protocol::Heap::GarbageCollection::Type>(const String&);
9319
9320#if ENABLE(INDEXED_DATABASE)
9321// Enums in the 'IndexedDB' Domain
9322template<>
9323JS_EXPORT_PRIVATE Optional<Inspector::Protocol::IndexedDB::Key::Type> parseEnumValueFromString<Inspector::Protocol::IndexedDB::Key::Type>(const String&);
9324template<>
9325JS_EXPORT_PRIVATE Optional<Inspector::Protocol::IndexedDB::KeyPath::Type> parseEnumValueFromString<Inspector::Protocol::IndexedDB::KeyPath::Type>(const String&);
9326#endif // ENABLE(INDEXED_DATABASE)
9327
9328// Enums in the 'Network' Domain
9329template<>
9330JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Network::Response::Source> parseEnumValueFromString<Inspector::Protocol::Network::Response::Source>(const String&);
9331template<>
9332JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Network::Metrics::Priority> parseEnumValueFromString<Inspector::Protocol::Network::Metrics::Priority>(const String&);
9333template<>
9334JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Network::Initiator::Type> parseEnumValueFromString<Inspector::Protocol::Network::Initiator::Type>(const String&);
9335
9336// Enums in the 'Page' Domain
9337template<>
9338JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::Setting> parseEnumValueFromString<Inspector::Protocol::Page::Setting>(const String&);
9339template<>
9340JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::ResourceType> parseEnumValueFromString<Inspector::Protocol::Page::ResourceType>(const String&);
9341template<>
9342JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::CoordinateSystem> parseEnumValueFromString<Inspector::Protocol::Page::CoordinateSystem>(const String&);
9343template<>
9344JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::CookieSameSitePolicy> parseEnumValueFromString<Inspector::Protocol::Page::CookieSameSitePolicy>(const String&);
9345template<>
9346JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Page::Appearance> parseEnumValueFromString<Inspector::Protocol::Page::Appearance>(const String&);
9347
9348// Enums in the 'Recording' Domain
9349template<>
9350JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Recording::Type> parseEnumValueFromString<Inspector::Protocol::Recording::Type>(const String&);
9351template<>
9352JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Recording::Initiator> parseEnumValueFromString<Inspector::Protocol::Recording::Initiator>(const String&);
9353
9354// Enums in the 'Runtime' Domain
9355template<>
9356JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::SyntaxErrorType> parseEnumValueFromString<Inspector::Protocol::Runtime::SyntaxErrorType>(const String&);
9357template<>
9358JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::RemoteObject::Type> parseEnumValueFromString<Inspector::Protocol::Runtime::RemoteObject::Type>(const String&);
9359template<>
9360JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::RemoteObject::Subtype> parseEnumValueFromString<Inspector::Protocol::Runtime::RemoteObject::Subtype>(const String&);
9361template<>
9362JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::ObjectPreview::Type> parseEnumValueFromString<Inspector::Protocol::Runtime::ObjectPreview::Type>(const String&);
9363template<>
9364JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::ObjectPreview::Subtype> parseEnumValueFromString<Inspector::Protocol::Runtime::ObjectPreview::Subtype>(const String&);
9365template<>
9366JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::PropertyPreview::Type> parseEnumValueFromString<Inspector::Protocol::Runtime::PropertyPreview::Type>(const String&);
9367template<>
9368JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Runtime::PropertyPreview::Subtype> parseEnumValueFromString<Inspector::Protocol::Runtime::PropertyPreview::Subtype>(const String&);
9369
9370// Enums in the 'ScriptProfiler' Domain
9371template<>
9372JS_EXPORT_PRIVATE Optional<Inspector::Protocol::ScriptProfiler::EventType> parseEnumValueFromString<Inspector::Protocol::ScriptProfiler::EventType>(const String&);
9373
9374// Enums in the 'Target' Domain
9375template<>
9376JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Target::TargetInfo::Type> parseEnumValueFromString<Inspector::Protocol::Target::TargetInfo::Type>(const String&);
9377
9378// Enums in the 'Timeline' Domain
9379template<>
9380JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Timeline::EventType> parseEnumValueFromString<Inspector::Protocol::Timeline::EventType>(const String&);
9381template<>
9382JS_EXPORT_PRIVATE Optional<Inspector::Protocol::Timeline::Instrument> parseEnumValueFromString<Inspector::Protocol::Timeline::Instrument>(const String&);
9383
9384} // namespace InspectorHelpers
9385
9386} // namespace Protocol
9387
9388} // namespace Inspector
9389
9390namespace WTF {
9391
9392template<typename T> struct DefaultHash;
9393
9394// Hash declarations in the 'CSS' Domain
9395template<>
9396struct DefaultHash<Inspector::Protocol::CSS::StyleSheetOrigin> {
9397 typedef IntHash<Inspector::Protocol::CSS::StyleSheetOrigin> Hash;
9398};
9399template<>
9400struct DefaultHash<Inspector::Protocol::CSS::PseudoId> {
9401 typedef IntHash<Inspector::Protocol::CSS::PseudoId> Hash;
9402};
9403template<>
9404struct DefaultHash<Inspector::Protocol::CSS::CSSPropertyStatus> {
9405 typedef IntHash<Inspector::Protocol::CSS::CSSPropertyStatus> Hash;
9406};
9407
9408// Hash declarations in the 'Canvas' Domain
9409template<>
9410struct DefaultHash<Inspector::Protocol::Canvas::ContextType> {
9411 typedef IntHash<Inspector::Protocol::Canvas::ContextType> Hash;
9412};
9413template<>
9414struct DefaultHash<Inspector::Protocol::Canvas::ShaderType> {
9415 typedef IntHash<Inspector::Protocol::Canvas::ShaderType> Hash;
9416};
9417
9418// Hash declarations in the 'Console' Domain
9419template<>
9420struct DefaultHash<Inspector::Protocol::Console::ChannelSource> {
9421 typedef IntHash<Inspector::Protocol::Console::ChannelSource> Hash;
9422};
9423template<>
9424struct DefaultHash<Inspector::Protocol::Console::ChannelLevel> {
9425 typedef IntHash<Inspector::Protocol::Console::ChannelLevel> Hash;
9426};
9427
9428// Hash declarations in the 'DOM' Domain
9429template<>
9430struct DefaultHash<Inspector::Protocol::DOM::PseudoType> {
9431 typedef IntHash<Inspector::Protocol::DOM::PseudoType> Hash;
9432};
9433template<>
9434struct DefaultHash<Inspector::Protocol::DOM::ShadowRootType> {
9435 typedef IntHash<Inspector::Protocol::DOM::ShadowRootType> Hash;
9436};
9437template<>
9438struct DefaultHash<Inspector::Protocol::DOM::CustomElementState> {
9439 typedef IntHash<Inspector::Protocol::DOM::CustomElementState> Hash;
9440};
9441template<>
9442struct DefaultHash<Inspector::Protocol::DOM::LiveRegionRelevant> {
9443 typedef IntHash<Inspector::Protocol::DOM::LiveRegionRelevant> Hash;
9444};
9445
9446// Hash declarations in the 'DOMDebugger' Domain
9447template<>
9448struct DefaultHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> {
9449 typedef IntHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> Hash;
9450};
9451template<>
9452struct DefaultHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> {
9453 typedef IntHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> Hash;
9454};
9455
9456// Hash declarations in the 'Page' Domain
9457template<>
9458struct DefaultHash<Inspector::Protocol::Page::Setting> {
9459 typedef IntHash<Inspector::Protocol::Page::Setting> Hash;
9460};
9461template<>
9462struct DefaultHash<Inspector::Protocol::Page::ResourceType> {
9463 typedef IntHash<Inspector::Protocol::Page::ResourceType> Hash;
9464};
9465template<>
9466struct DefaultHash<Inspector::Protocol::Page::CoordinateSystem> {
9467 typedef IntHash<Inspector::Protocol::Page::CoordinateSystem> Hash;
9468};
9469template<>
9470struct DefaultHash<Inspector::Protocol::Page::CookieSameSitePolicy> {
9471 typedef IntHash<Inspector::Protocol::Page::CookieSameSitePolicy> Hash;
9472};
9473template<>
9474struct DefaultHash<Inspector::Protocol::Page::Appearance> {
9475 typedef IntHash<Inspector::Protocol::Page::Appearance> Hash;
9476};
9477
9478// Hash declarations in the 'Recording' Domain
9479template<>
9480struct DefaultHash<Inspector::Protocol::Recording::Type> {
9481 typedef IntHash<Inspector::Protocol::Recording::Type> Hash;
9482};
9483template<>
9484struct DefaultHash<Inspector::Protocol::Recording::Initiator> {
9485 typedef IntHash<Inspector::Protocol::Recording::Initiator> Hash;
9486};
9487
9488// Hash declarations in the 'Runtime' Domain
9489template<>
9490struct DefaultHash<Inspector::Protocol::Runtime::SyntaxErrorType> {
9491 typedef IntHash<Inspector::Protocol::Runtime::SyntaxErrorType> Hash;
9492};
9493
9494// Hash declarations in the 'ScriptProfiler' Domain
9495template<>
9496struct DefaultHash<Inspector::Protocol::ScriptProfiler::EventType> {
9497 typedef IntHash<Inspector::Protocol::ScriptProfiler::EventType> Hash;
9498};
9499
9500// Hash declarations in the 'Timeline' Domain
9501template<>
9502struct DefaultHash<Inspector::Protocol::Timeline::EventType> {
9503 typedef IntHash<Inspector::Protocol::Timeline::EventType> Hash;
9504};
9505template<>
9506struct DefaultHash<Inspector::Protocol::Timeline::Instrument> {
9507 typedef IntHash<Inspector::Protocol::Timeline::Instrument> Hash;
9508};
9509
9510} // namespace WTF
9511