Make new experimental properties optional if they are not in the current stable Chrome

When new properties are added to experimental types in the most recent protocol
versions, the stable Chrome doesn't have them yet, and serialization fails because of
these missing properties.
This also affects tests which are using Docker containers with the latest-ish stable
Chrome version.

Author: joffrey-bion

protocol-generator/cdp-kotlin-generator/src/main/kotlin/org/hildan/chrome/devtools/protocol/preprocessing/JsonPreProcessor.kt

@@ -1,18 +1,33 @@
 package org.hildan.chrome.devtools.protocol.preprocessing
 
 import org.hildan.chrome.devtools.protocol.json.JsonDomain
+import org.hildan.chrome.devtools.protocol.json.JsonDomainCommand
 import org.hildan.chrome.devtools.protocol.json.JsonDomainParameter
 import org.hildan.chrome.devtools.protocol.json.JsonDomainType
 
 /**
  * Pre-processes the list of domains from the JSON definitions to work around some issues in the definitions themselves.
  */
 internal fun List<JsonDomain>.preprocessed(): List<JsonDomain> = this
+    .makeNewExperimentalPropsOptional()
     // Workaround for https://github.com/ChromeDevTools/devtools-protocol/issues/317
     .transformDomainTypeProperty("Network", "Cookie", "expires") { it.copy(optional = true) }
     // Workaround for https://github.com/ChromeDevTools/devtools-protocol/issues/244
     .map { it.pullNestedEnumsToTopLevel() }
 
+/**
+ * Modifies some new experimental properties to make them optional, so that serialization doesn't fail on stable Chrome
+ * versions.
+ *
+ * When new properties are added to experimental types in the most recent protocol versions, the stable Chrome doesn't
+ * have them yet, and serialization fails because of these missing properties. This also affects tests which are using
+ * Docker containers with the latest-ish stable Chrome version.
+ */
+// NOTE: only add properties that are not already in the latest stable. We don't want to make everything nullable.
+private fun List<JsonDomain>.makeNewExperimentalPropsOptional(): List<JsonDomain> =
+    transformDomainCommandReturnProp("Runtime", "getHeapUsage", "embedderHeapUsedSize") { it.copy(optional = true) }
+    .transformDomainCommandReturnProp("Runtime", "getHeapUsage", "backingStorageSize") { it.copy(optional = true) }
+
 private fun List<JsonDomain>.transformDomainTypeProperty(
     domain: String,
     type: String,
@@ -24,6 +39,17 @@ private fun List<JsonDomain>.transformDomainTypeProperty(
     }
 }
 
+private fun List<JsonDomain>.transformDomainCommandReturnProp(
+    domain: String,
+    command: String,
+    property: String,
+    transform: (JsonDomainParameter) -> JsonDomainParameter,
+): List<JsonDomain> = transformDomain(domain) { d ->
+    d.transformCommand(command) { t ->
+        t.transformReturnProperty(property, transform)
+    }
+}
+
 private fun List<JsonDomain>.transformDomain(
     name: String,
     transform: (JsonDomain) -> JsonDomain,
@@ -39,5 +65,15 @@ private fun JsonDomainType.transformProperty(
     transform: (JsonDomainParameter) -> JsonDomainParameter,
 ): JsonDomainType = copy(properties = properties.transformIf({ it.name == name }) { transform(it) })
 
+private fun JsonDomain.transformCommand(
+    name: String,
+    transform: (JsonDomainCommand) -> JsonDomainCommand,
+): JsonDomain = copy(commands = commands.transformIf({ it.name == name }) { transform(it) })
+
+private fun JsonDomainCommand.transformReturnProperty(
+    name: String,
+    transform: (JsonDomainParameter) -> JsonDomainParameter,
+): JsonDomainCommand = copy(returns = returns.transformIf({ it.name == name }) { transform(it) })
+
 private fun <T> List<T>.transformIf(predicate: (T) -> Boolean, transform: (T) -> T): List<T> =
     map { if (predicate(it)) transform(it) else it }

src/jvmTest/kotlin/LocalIntegrationTestBase.kt

@@ -1,4 +1,6 @@
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
 import org.hildan.chrome.devtools.domains.accessibility.AXProperty
 import org.hildan.chrome.devtools.domains.accessibility.AXPropertyName
@@ -108,6 +110,29 @@ abstract class LocalIntegrationTestBase : IntegrationTestBase() {
         }
     }
 
+    @OptIn(ExperimentalChromeApi::class)
+    @Test
+    fun parallelPages() = runTestWithRealTime {
+        withResourceServerForTestcontainers { baseUrl ->
+            chromeWebSocket().use { browser ->
+                // we want all coroutines to finish before we close the browser session
+                withContext(Dispatchers.IO) {
+                    repeat(20) {
+                        launch {
+                            browser.newPage().use { page ->
+                                page.goto("$baseUrl/test-server-pages/basic.html")
+                                page.runtime.getHeapUsage()
+                                val docRoot = page.dom.getDocumentRootNodeId()
+                                page.dom.describeNode(DescribeNodeRequest(docRoot, depth = 2))
+                                page.storage.getCookies()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun sessionThrowsIOExceptionIfAlreadyClosed() = runTestWithRealTime {

src/jvmTest/kotlin/ZenikaIntegrationTests.kt

@@ -1,8 +1,6 @@
 import kotlinx.coroutines.*
 import org.hildan.chrome.devtools.*
-import org.hildan.chrome.devtools.domains.dom.*
 import org.hildan.chrome.devtools.protocol.*
-import org.hildan.chrome.devtools.sessions.*
 import org.junit.jupiter.api.Test
 import org.testcontainers.containers.*
 import org.testcontainers.junit.jupiter.*
@@ -62,27 +60,4 @@ class ZenikaIntegrationTests : LocalIntegrationTestBase() {
             message = "the google.com page target should be closed, got:\n${targetsAfterClose.joinToString("\n")}",
         )
     }
-
-    @OptIn(ExperimentalChromeApi::class)
-    @Test
-    fun parallelPages() = runTestWithRealTime {
-        withResourceServerForTestcontainers { baseUrl ->
-            chromeWebSocket().use { browser ->
-                // we want all coroutines to finish before we close the browser session
-                withContext(Dispatchers.IO) {
-                    repeat(20) {
-                        launch {
-                            browser.newPage().use { page ->
-                                page.goto("$baseUrl/test-server-pages/basic.html")
-                                page.runtime.getHeapUsage()
-                                val docRoot = page.dom.getDocumentRootNodeId()
-                                page.dom.describeNode(DescribeNodeRequest(docRoot, depth = 2))
-                                page.storage.getCookies()
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
 }