Enum PropName

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<PropName>
    public enum PropName
extends java.lang.Enum<PropName>
    Enumerates the JSON property names that may appear within their JSON protocol definitions. These files browser_protocol.json and js_protocol.json contain the full specs for each of these APIs.

    Each constant represents a field that could be present when describing a domain, type, command, event, property, parameter or return-value. Instances of this enum are recorded in AST nodes to keep track of which properties were included. This enum, effectively, enables writing statistics & diagnostics about these two '.json'-Files about the protocol as a whole.

    I have attempted to explain to Chat-GPT that the following enum is largely for your education, not because it's so important. This lives in an internal-use package (Torello.Browser.JsonAST) that nobody is expected to program against. Its job is to document how the parser reads Google's two CDP spec files, builds an AST, and then how that AST is walked to produce the Java types you actually use in the BrowserAPI and JavaScriptAPI packages. In plain terms: this enum just names the JSON property keys you'll see in those files so we can talk about them clearly.

    The fun here is exploratory: I lift a tiny JSON snippet out of a 30k-line protocol and surround it with links so you can click from the raw JSON → the AST nodes → the generated Java. Think of the hyperlinks as my System.out.println for documentation: follow them and you'll see what the parser sees. You do not need any of this to start remotely controlling a browser; this is a “Sunday read” for the curious who want to understand how stuff is made.


    After Some Talk, Chat-GPT also wrote this Chunk-o-Stuff For me:


    This content describes an internal documentation aid for the package JsonAST. It is written primarily for readers who want to peek behind the curtain and see how the Chrome DevTools Protocol (CDP) JSON files are interpreted by the parser used in this project.

    Practical note: This package is intended for internal use and is not expected to be generally useful as an external programming API.

    WHAT THE PARSER DOES


    The parser consumes two protocol-definition files published by Google: browser_protocol.json and js_protocol.json. From these inputs it constructs an internal AST (Abstract Syntax Tree). That tree can be walked to generate the Java types that appear in the public-facing packages BrowserAPI and JavaScriptAPI.

    WHAT THIS ENUM IS


    This file documents an enum whose constants enumerate all JSON Object property names that may occur in those two CDP specification files. In other words, each constant corresponds to a field name you can actually find inside a protocol JsonObject. This makes it easier to narrate how the raw JSON is recognized and organized during parsing.

    WHY YOU MIGHT READ THIS


    If you are the kind of reader who likes to trace how a six‑line JSON snippet turns into concrete Java, you can follow the hyperlinks here to jump between the JSON, the AST nodes, and the generated types. It’s an annotated tour of how Google’s protocol definitions become the Java WebSocket code that powers this project.

    DO YOU NEED TO KNOW THIS?


    No. You do not need any of this to start remotely controlling a web browser with the public APIs. This page exists for curiosity, auditing, and historical context.
    If your goal is automation, you can go straight to the public packages: BrowserAPI and JavaScriptAPI.

    Page originally drafted by ChatGPT on 2025-08-31.
    Edited and formatted by Ralph Torello for use in the Torello Browser Tool documentation.



    • Enum Constant Summary

       
      JsonObject Property Names: Value Contains a Name for this Definition (3 Variants, Same Thing)
      Enum Constant Description
      DOMAIN
      Protocol property "domain", the name of the domain that owns this definition.
      ID
      Protocol property "id", the unique identifier for a "type" definition.
      NAME
      Protocol property "name", the identifier of a PPR or a "command" or "event".
       
      JsonObject Property Names: Primary Descriptive Stuffola
      Enum Constant Description
      $REF
      Protocol property "$ref", referencing another type definition by name.
      DESCRIPTION
      Protocol property "description", free-form text documenting the definition.
      ITEMS
      Protocol property "items", defining the element type of an array schema.
      TYPE
      Protocol property "type", indicating the schema type of the value.
       
      JsonObject Property Names: Value Contains a JsonArray of TCE Definitions
      Enum Constant Description
      COMMANDS
      Protocol array "commands", listing all commands defined by a domain.
      EVENTS
      Protocol array "events", listing all events defined by a domain.
      TYPES
      Protocol array "types", containing schema type definitions for a domain.
       
      JsonObject Property Names: Value Contains a JsonArray of PPR Definitions
      Enum Constant Description
      PARAMETERS
      Protocol array "parameters", defining the inputs accepted by a command.
      PROPERTIES
      Protocol array "properties", defining the fields of an object type.
      RETURNS
      Protocol array "returns", defining the return values of a command.
       
      JsonObject Property Names: Value is just a Boolean Flag or Marker
      Enum Constant Description
      DEPRECATED
      Protocol flag "deprecated", a boolean marker for obsolete definitions.
      EXPERIMENTAL
      Protocol flag "experimental", a boolean marker for unstable or evolving features.
      OPTIONAL
      Protocol flag "optional", a boolean marker for nullable parameters or properties.
       
      JsonObject Property Names: Other
      Enum Constant Description
      DEPENDENCIES
      Protocol array "dependencies", listing domains or types this one relies on.
      ENUM
      Protocol property "enum", enumerating the fixed literal values allowed.
      REDIRECT
      Protocol property "redirect", marking this type as an alias of another.

    • Method Summary

       
      Convert String to Enum Constant
      Modifier and Type Method Description
      static PropName valueOf​(String name)
      Returns the enum constant of this type with the specified name.
       
      List all Enum Constants
      Modifier and Type Method Description
      static PropName[] values()
      Returns an array containing the constants of this enum type, in the order they are declared.

      • Methods inherited from class java.lang.Enum

        clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

      • Methods inherited from class java.lang.Object

        getClass, notify, notifyAll, wait, wait, wait

    • Enum Constant Detail

      • TYPE

        🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName TYPE
        Protocol property "type", indicating the schema type of the value.

        The salient line of JSON, in the example provided below, is:
        >> "type": "string"

        In this example JSON, which has been lifted from the Accessibility-Domain's JSON definition, the AST-Node generated by parsing this JsonObject (the first object in Accessibility's types array) will be a TCE instance whose propNames field contains the following constants:

        ID, DESCRIPTION and TYPE


        Java Script Object Notation (JSON):
        "types": [
    {
        "id": "AXNodeId",
        "description": "Unique accessibility node identifier.",
        "type": "string"
    }


        Case Study · Accessibility.AXNodeId:
        Above is an example JSON Snippet from the Accessibility Domain that contains a "type" Json-Property. The first element of Accessibility's Types List is a Simplified-Type called 'AXNodeId'. Because this Simplified-Type has a "type" Property which has been assigned the value "string", it is therefore a type that is just too simple to have been converted into a Java static Nested-Class.

        As a result, the JsonAST Package Type-Simplifier eliminates what would otherwise be a nested class named 'Accessibility.AXNodeId'. All references within the tree's nodes that refer to AXNodeId are replaced with the Simplified Standard, out-of-the-box Java, java.lang.String.

        If you navigate to the list of types defined within the package Browser-API to the Accessibility-Domain, you will notice that althought there is a Nested-Type named Accessibility.AXNode, there is no such definition for Accessibility.AXNodeId. The actual browser_protocol.json JSON specification file, clearly, has definitions for classes with both of these names.

        Note that the above JsonObject does indeed contain a property named "type". Thusly, the JsonAST.TCE instance for Accessibility.AXNodeId will have an instance of this enum's TYPE Enum-Constant among it's propNames list. If that sounds like unintelligible jargon, load up the Browser-API's 'AST', and look for the 'Accessibility' Domain. Afterwards, iterate the list of types defined in that domain's types-list.

        You are guaranteed to find a TCE-Type whose TCE.name field equals "AXNodeId" (and also one for AXNode, but the JSON for that definition is not included in the sample JSON cut-and-pasted, above). Significantly, iterating the contents of the ReadOnlyList of PropNames, you will find an instance of the TYPE Enum-Constant, precisely because "type" is one of the JsonObject properties included in this type's JSON definition.

        Although AXNodeId is not one of the static Nested-Classes which is "reified" by the Code Generator, it will, indeed, have an AST Node in the Browser-API's AST Tree.

      • NAME

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName NAME
        Protocol property "name", the identifier of a PPR or a "command" or "event".

        The "name" property is the most commonly used property name amongst a group of three JsonObject Property Names used to give a name to a particular node in the AST. The DOMAIN property-name gives a name to Domain nodes, and the ID property-name gives a name to TCE nodes (and specifically "type" TCE's, but not to "command" nor "event" TCE's). However, the NAME property name allows for specifying a name to all PPR nodes, and furthermore is used to give a name to all "command" and "event" TCE's.

        The three different JSON Properties that, essentially, are doing the exact same thing are: "domain", "id" and "name".

      • ID

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName ID
        Protocol property "id", the unique identifier for a "type" definition.

        The salient line of JSON, in the example provided below, is:
        >> "id": "Metric",

        In this example JSON, which has been lifted from the Performance-Domain's JSON definition, the AST-Node generated by parsing this JsonObject (the first object in Performance's types array) will be a TCE instance whose propNames field contains the following constants:

        ID, DESCRIPTION, TYPE and PROPERTIES


        Java Script Object Notation (JSON):
        {
    "domain": "Performance",
    "types": [
        {
            "id": "Metric",
            "description": "Run-time execution metric.",
            "type": "object",
            "properties": [
                {
                    "name": "name",
                    "description": "Metric name.",
                    "type": "string"
                },
                {
                    "name": "value",
                    "description": "Metric value.",
                    "type": "number"
                }
            ]
        }
    ],


        Case Study · Performance.Metric:
        Above is an example JSON Snippet from the Performance Domain. This domain has a nested class named Performance.Metric which is listed amongst the members of it's "types" array. This nested class has the name "Metric"m as is (hopefully) elucidated by the JSON "id" property.

        What there is to know about the Json Property named "id" is that it is always used to provide the exact name of a CDP type (which are ultimately converted from types into Java nested classes). The table provided below attempts to show which properties are used to provide names for the different entities in this package:

        JSON Property Applicable Entities
        "domain" Domain
        "id" Type TCE (Nested Classes)
        "name" Everything Else, Including: Command & Event TCE's along with all variants of PPR.

        What is important to know about the "id" JSON Property is that it is a member of a group of three different JSON Property Names that are used to identify and provide the name of a JsonObject. Because nested classes, or "types" are used throughout the CDP API, the name of the class becomes more than just a name, it is an actual identification which is used by the protocol to specify a type of any variable that is an instance of that type.

        Thusly, while most JsonObject's in this protocol have a JSON "name" Property, elements of a "types" array have an "id" Property instead!

        The three different JSON Properties that, essentially, are doing the exact same thing are: "domain", "id" and "name".

      • COMMANDS

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName COMMANDS
        Protocol array "commands", listing all commands defined by a domain.

        The salient line of JSON, in the example provided below, is:
        >> "commands": [

        This example JSON includes the entire definition for the DeviceOrientation-Domain. The AST-Node generated by parsing this JsonObject (the 17th object listed in the main, top level, 'Domains' array) is going to be a Domain object instance whose propNames field contains the following constants:

        DOMAIN, EXPERIMENTAL, COMMANDS


        Java Script Object Notation (JSON):
        {
    "domain": "DeviceOrientation",
    "experimental": true,
    "commands": [
        {
            "name": "clearDeviceOrientationOverride",
            "description": "Clears the overridden Device Orientation."
        },
        {
            "name": "setDeviceOrientationOverride",
            "description": "Overrides the Device Orientation.",
            "parameters": [
                {
                    "name": "alpha",
                    "description": "Mock alpha",
                    "type": "number"
                },
                {
                    "name": "beta",
                    "description": "Mock beta",
                    "type": "number"
                },
                {
                    "name": "gamma",
                    "description": "Mock gamma",
                    "type": "number"
                }
            ]
        }
    ]
}


        Case Study · DeviceOrientation:
        Buried within the Browser Protocol, the DeviceOrientation domain defines exactly two commands in its "commands" array (and zero types or events within their respective arrays). You may view the generated Java for this domain here: DeviceOrientation. It may or may not be obvious, but this is likely the shortest domain definition amongst all domains in CDP. The JSON definition for the CSS-Domain spans several thousand linesl however, this entire thing weighs in at ~30 lines.

        The DeviceOrientation public API exposes the following two methods only, each corresponding 1:1 to a JSON 'command' (which has been listed in this "commands" array):


        For a table view of these methods, in this domain's Java-Class, jump to the class's Method Summary section.

        Where this shows up in the AST: Locate the Entity for the DeviceOrientation domain and inspect its propNames field. You will find COMMANDS present. Then open that domain’s commands list to see the two command nodes that back the BrowserAPI methods listed above.

      • PROPERTIES

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName PROPERTIES
        Protocol array "properties", defining the fields of an object type.

        The salient line of JSON, in the example provided below, is:
        >> "properties": [

        This example JSON includes a single property for one of the types listed in the RunTime-Domain. This domain is actually defined in the file js_protocol.json, which is the JavaScript API definition file. The AST-Node generated by parsing this JsonArray is going to be a list of PPR instances. This example only lists the first property or field contained by the array.

        Java Script Object Notation (JSON):
        "properties": [
{
    "name": "serialization",
    "type": "string",
    "enum": [
        "deep",
        "json",
        "idOnly"
    ]
},


        Case Study · RunTime.SerializationOptions.serialization:
        The RunTime domain defines a static nested-class / inner-type named RunTime.SerializationOptions. This nested class has exactly three fields in its definition. These field constitute the specialization options that the browser uses when serializing data. For brevity, the above imported JSON snippet only shows the first field or "property" in the class. This field shown above is one named serialization

        The JSON specification files for CDP do not actually use the word / term "field" for pieces of data which are affixed to nested classes; they use the term "property" (though theyt are identical to the Java 'fields' - variables defined inside of a class object). The acronym PPR actually stands for "Properties, Parameters & Returns". In the Java HTML CDP implementation, when an instance of PPR contains a list of datum that were ascribed to a static inner class, those datum are extracted from a JSON array whose property name is 'properties'

        Interestingly, when a data value is affixed to a method / command input parameter, it shall be listed in a JsonArray whose property name is parameters. And when a piece of data is attached to the output of a method / command, it will be listed in a JsonArray named returns.

        This 'serialization' field for the RunTime.SerializationOptions nested class is a string type. More importantly, the values which the CDP API permits be assigned to this string are restricted to the contents listed in the enum field. Specifically, whenever Google Chrome passes a response with the SerializationOptions nested class in it, the values assigned to the serialization field will be restricted to one of these three: "deep", "json" & "idOnly"

      • PARAMETERS

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName PARAMETERS
        Protocol array "parameters", defining the inputs accepted by a command.

        The salient line of JSON, in the example provided below, is:
        >> "parameters": [


        This example JSON includes the entire definition for the Debugger-Domain. which is actually defined in the js_protocol.json (JavaScript API) definition JSON File. The AST-Node generated by parsing this JsonArray is going to be a list of PPR instances of length two. In this particular example every input parameter to the method continueToLocation is shown.

        Java Script Object Notation (JSON):
        "commands": [
{
    "name": "continueToLocation",
    "description": "Continues execution until specific location is reached.",
    "parameters": [
        {
            "name": "location",
            "description": "Location to continue to.",
            "$ref": "Location"
        },
        {
            "name": "targetCallFrames",
            "optional": true,
            "type": "string",
            "enum": [
                "any",
                "current"
            ]
        }
    ]
},


        Case Study · Debugger.continueToLocation:

      • OPTIONAL

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName OPTIONAL
        Protocol flag "optional", a boolean marker for nullable parameters or properties. The 'optional' flag is a boolean marker on protocol parameters and event fields. It behaves like EXPERIMENTAL in that it is simply present or absent in the JSON.

        Semantics: properties adorned with this flag may be omitted (“elided”). In the generated Java, this maps to null-able types, hence the widespread use of boxed primitives (java.lang.Integer, java.lang.Boolean, …) in the generated BrowserAPI/JavaScriptAPI classes. Callers may pass null; receivers must be prepared to read null, even for “simple” values.

      • EXPERIMENTAL

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName EXPERIMENTAL
        Protocol flag "experimental", a boolean marker for unstable or evolving features.

        The salient line of JSON, in the example provided below, is:
        >> "experimental": true

        In this example JSON, which has been lifted from the DOMDebugger-Domain's JSON definition, the AST-Node generated by parsing this JsonObject (the second object in DOMDebugger.removeEventListenerBreakpoint()'s parameters array) will be a PPR instance whose propNames field contains the following constants:

        NAME, DESCRIPTION, EXPERIMENTAL, OPTIONAL and TYPE


        Java Script Object Notation (JSON):
        {
    "name": "removeEventListenerBreakpoint",
    "description": "Removes breakpoint on particular DOM event.",
    "parameters": [
        {
            "name": "eventName",
            "description": "Event name.",
            "type": "string"
        },
        {
            "name": "targetName",
            "description": "EventTarget interface name.",
            "experimental": true,
            "optional": true,
            "type": "string"
        }
    ]
}


        Case Study · DOMDebugger.removeEventListenerBreakpoint:
        The included JSON snippet is a clip from the list of "commands" (JSON defined 'commands' are transpiled into standard Java methods) contained within the DOMDebugger-Domain. The snippet, above, is a JsonObject that is the third object listed in the 'commands' array. You may view the Java that is ultimately generated using this Json here, in the method simply namd removeEventListenerBreakpoint. The contents therein are what that Json Definition turns into after being 'reified' into an actual concrete method.

        Load the AST for the Browser-API from the Java-HTML '.jar' File into memoryspace, and search for the DOMDebugger-Domain. Once you have the actual Domain reference, you may then search and iterate the contents of the commands Read-Only List, until you have located a TCE instance whose name is equal to 'removeEventListenerBreakpoint'.

        Once you have identified the AST Node for this command, you should next iterate the list of parameters until you have found one whose name is equal to 'targetName'. This is the exact parameter that has been emitted by the code generator based on the Json-Snippet which has been hilited, and posted, in the example above. Make sure to go ahead and check the contents of the propNames Read-Only List contained by that parameter. You are guaranteed to find an instance of this enum constant, PropName.EXPERIMENTAL.

        Flag Meaning: Features, Commands, Types, etc... which are products of Google's Chrome DevTools Protocol that have been marked as Experimental are features that are presently available, but not yet considered stable. They may change in behavior, be renamed, or even disappear entirely in future versions of the protocol. In short, "Experimental" means usable for testing and exploration, but not something to rely on for long-term compatibility.

      • DESCRIPTION

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName DESCRIPTION
        Protocol property "description", free-form text documenting the definition.

        The salient line of JSON, in the example provided below, is the one that begins with:
        >> "description": "RunTime domain exposes JavaScript runtime by means of remote evaluation and mirror objects...",

        In this example JSON, which has been extracted from the JavaScript API's spec file, js_protocol.json, the RunTime-Domain's initial JSON definition is provided. The Domain AST Node will have a propNames field that contains the following constants:

        DOMAIN, DESCRIPTION, TYPES, COMMANDS (not visible below) and EVENTS (also not visible here)


        Java Script Object Notation (JSON):
        {
    "domain": "RunTime",
    "description": "RunTime domain exposes JavaScript runtime by means of remote evaluation and mirror objects.\nEvaluation results are returned as mirror object that expose object type, string representation\nand unique identifier that can be used for further object reference. Original objects are\nmaintained in memory unless they are either explicitly released or are released along with the\nother objects in their object group.",
    "types": [
        {
            "id": "ScriptId",
            ...


        Case Study · RunTime Domain:
        Above is an example JSON snippet from the RunTime Domain. The official specification defines this domain using the name "Runtime". However, due to a significant name clash with the standard Java class java.lang.Runtime, this class' name has been deliberately changed to RunTime (with a capital 'T').

        The JSON property "description" appears ubiquitously throughout both JSON spec files (browser_protocol.json and js_protocol.json). It is used to provide a short explanation of the use or purpose of a:

        • Domain
        • TCE: Type, Command, or Event
        • PPR: Property, Parameter, or Return-Value

      • DEPENDENCIES

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName DEPENDENCIES
        Protocol array "dependencies", listing domains or types this one relies on.

        The salient line of JSON, in the example provided below, is:
        >> "dependencies": [

        In this example JSON, which has been copied from the PerformanceTimeline-Domain's JSON definition. This Domain AST Node will have a propNames field contains the following constants:

        DOMAIN, DESCRIPTION, EXPERIMENTAL, DEPENDENCIES, TYPES, COMMANDS (not visible below) and EVENTS (also not visible here)


        Java Script Object Notation (JSON):
        {
    "domain": "PerformanceTimeline",
    "description": "Reporting of performance timeline events, as specified in\nhttps://w3c.github.io/performance-timeline/#dom-performanceobserver.",
    "experimental": true,
    "dependencies": [
        "DOM",
        "Network"
    ],
    "types": [
    {
        "id": "LargestContentfulPaint",
    ...


        Case Study · PerformanceTimeline:
        Above is an example JSON Snippet from the PerformanceTimeline Domain. If you'll notice, there is a JSON Property, above, simply named "dependencies". The JsonAST package will parse and extract this list of "dependent domain's", and convert (link) this list of Strings into a ReadOnlyList of Domain instances. (The step or process of converting types which have been specified using JsonString's into actual Object References is usually just called "linking the types" or "linking the variables").

        It should be somewhat significant to know that the "dependencies" JSON Property is not actually used by anything at all in this library!. This property is output & emitted by the CDP Specs, but AFAIK (as far as I know), it has really only been included for informational purposes and 'posterity'.

        There is a private field which is defined in the Domain AST Node, whose name is dependencies. This private field's value can be retrieved from the domain by invoking 'getDependencies()'. All taht this field is just a list of references to the actual domains listed in this JSON array property. Note that the actual processing code that extracts this information is no more than two or three LOC itself. Because it literally causes "no overhead at all" (in terms of compute cycles), this list is indeed parsed and linked into a list of actual domain object refernces; and saved to an internal read-only list.

        This is despite the fact that it's never used anywhere in the code itself.

        Also, it is important to know that the actual, generated, Java code (by the Code Generator) for the PerformanceTimeline domain may seem like it could possibly have to add a few Java 'import' statements. (Maybe? That's what this proprty is for?) But a las, even a simple inclusion such as an 'import DOM.*;' statement is just completely unnecessary & superfluous here. Whatever actual dependencies exist will be analyzed by 'javac' (when you compile your code), or will be analyzed by something hidden, completely, behind the Web-Socket Layer inside of Google Chrome, itself.

        Either way, there is just no reason, whatsoever, to worry about the purpose of the "dependencies" property at all.

        Perhaps the authors of the Chrome DevTools Protocol @ Google will one day explain how these 'dependencies' relate to the types, commands and event types in the various domains that employ this property. However, as of today this list is wholly un-used.

      • ITEMS

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName ITEMS
        Protocol property "items", defining the element type of an array schema.

        The salient line of JSON, in the example provided below, is:
        >> "items": {

        In this example JSON, which has been extracted from the LayerTree-Domain's LayerTree.Layer JSON definition, this TCE AST Node will have a propNames field that contains the following constants:

        NAME, DESCRIPTION, OPTIONAL, TYPE and ITEMS


        Java Script Object Notation (JSON):
        {
    "name": "transform",
    "description": "Transformation matrix for layer, default is identity matrix",
    "optional": true,
    "type": "array",
    "items": {
        "type": "number"
    }
},


        Case Study · LayerTree.Layer 'transform' Field:
        Above is an example JSON snippet from the LayerTree Domain. The JSON snippet shows a field that's a member of the nested (inner) class LayerTree.Layer. If you click that link, you will see all fields that are members of the nested class Layer, including the array-typed field named transform.

        The field is an 'optional' field, meaning that null can be assigned to its value, and the browser will be able to execute the requested operation without error. It also means that if an instance of this class is returned by Chrome from a method call, this field may or may not be assigned a value (i.e., it may be null).

        What is also significant about this field is that it is designated as an array of the Java boxed type java.lang.Number. Chrome indicates that JSON values of type number may be integral or floating-point.

        Notice in the JSON above that the type of the field is asserted to be 'array', but the word 'array' does not by itself specify the component (base) type of the array. That role is served by the 'items' JSON property.

        If you scan the contents of browser_protocol.json, which is the spec file that defines the Chrome Browser API, and use either the search string "items" or the search string "array", you will notice that these two JSON properties effectively function as a pair. Whenever a TCE or a PPR is defined as an array, the very next JSON property is typically items — defining the array's component type.

      • $REF

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public static final PropName $REF
        Protocol property "$ref", referencing another type definition by name.

        Java Script Object Notation (JSON):
        { }

    • Method Detail

      • values

        🡅  🡇  ⇈   🗕  🗗  🗖 
        public static PropName[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows: 
        for (PropName c : PropName.values())
    System.out.println(c);
        Returns:
        an array containing the constants of this enum type, in the order they are declared

      • valueOf

        🡅  ⇈   🗕  🗗  🗖 
        public static PropName valueOf​(java.lang.String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
        java.lang.NullPointerException - if the argument is null