Merge branch 'trunk' into annotate-relative-by

Author: gryznar

dotnet/src/webdriver/DevTools/Json/DevToolsJsonOptions.cs

@@ -0,0 +1,35 @@
+// <copyright file="DevToolsJsonOptions.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+using System.Text.Json;
+
+#nullable enable
+
+namespace OpenQA.Selenium.DevTools.Json;
+
+internal static class DevToolsJsonOptions
+{
+    public static JsonSerializerOptions Default { get; } = new JsonSerializerOptions()
+    {
+        Converters =
+        {
+            new StringConverter(),
+        }
+    };
+}

dotnet/src/webdriver/DevTools/Json/StringConverter.cs

@@ -0,0 +1,61 @@
+// <copyright file="StringConverter.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+using System;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+#nullable enable
+
+namespace OpenQA.Selenium.DevTools.Json;
+
+internal sealed class StringConverter : JsonConverter<string>
+{
+    public override bool HandleNull => true;
+
+    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        try
+        {
+            return reader.GetString();
+        }
+        catch (InvalidOperationException)
+        {
+            // Fallback to read the value as bytes instead of string.
+            // System.Text.Json library throws exception when CDP remote end sends non-encoded string as binary data.
+            // Using JavaScriptEncoder.UnsafeRelaxedJsonEscaping doesn't help because the string actually is byte[].
+            // https://chromedevtools.github.io/devtools-protocol/tot/Network/#type-Request - here "postData" property
+            // is a string, which we cannot deserialize properly. This property is marked as deprecated, and new "postDataEntries"
+            // is suggested for using, where most likely it is base64 encoded.
+
+            var bytes = reader.ValueSpan;
+            var sb = new StringBuilder(bytes.Length);
+            foreach (byte b in bytes)
+            {
+                sb.Append(Convert.ToChar(b));
+            }
+
+            return sb.ToString();
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) =>
+        writer.WriteStringValue(value);
+}

dotnet/src/webdriver/Internal/Logging/LogContext.cs

@@ -20,6 +20,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 #nullable enable
@@ -30,7 +31,7 @@ namespace OpenQA.Selenium.Internal.Logging
     /// Represents a logging context that provides methods for creating sub-contexts, retrieving loggers, emitting log messages, and configuring minimum log levels.
     /// </summary>
     /// <inheritdoc cref="ILogContext"/>
-    internal class LogContext : ILogContext
+    internal sealed class LogContext : ILogContext
     {
         private ConcurrentDictionary<Type, ILogger>? _loggers;
 
@@ -46,7 +47,7 @@ public LogContext(LogEventLevel level, ILogContext? parentLogContext, Concurrent
 
             _parentLogContext = parentLogContext;
 
-            _loggers = loggers;
+            _loggers = CloneLoggers(loggers, level);
 
             if (handlers is not null)
             {
@@ -65,12 +66,7 @@ public ILogContext CreateContext()
 
         public ILogContext CreateContext(LogEventLevel minimumLevel)
         {
-            ConcurrentDictionary<Type, ILogger>? loggers = null;
-
-            if (_loggers != null)
-            {
-                loggers = new ConcurrentDictionary<Type, ILogger>(_loggers.Select(l => new KeyValuePair<Type, ILogger>(l.Key, new Logger(l.Value.Issuer, minimumLevel))));
-            }
+            ConcurrentDictionary<Type, ILogger>? loggers = CloneLoggers(_loggers, minimumLevel);
 
             var context = new LogContext(minimumLevel, this, loggers, Handlers);
 
@@ -98,7 +94,7 @@ public ILogger GetLogger(Type type)
 
         public bool IsEnabled(ILogger logger, LogEventLevel level)
         {
-            return Handlers != null && level >= _level && level >= logger.Level;
+            return Handlers != null && level >= _level && (_loggers?.TryGetValue(logger.Issuer, out var loggerEntry) != true || level >= loggerEntry?.Level);
         }
 
         public void EmitMessage(ILogger logger, LogEventLevel level, string message)
@@ -155,5 +151,24 @@ public void Dispose()
 
             Log.CurrentContext = _parentLogContext;
         }
+
+        [return: NotNullIfNotNull(nameof(loggers))]
+        private static ConcurrentDictionary<Type, ILogger>? CloneLoggers(ConcurrentDictionary<Type, ILogger>? loggers, LogEventLevel minimumLevel)
+        {
+            if (loggers is null)
+            {
+                return null;
+            }
+
+            var cloned = new Dictionary<Type, ILogger>(loggers.Count);
+
+            foreach (KeyValuePair<Type, ILogger> logger in loggers)
+            {
+                var clonedLogger = new Logger(logger.Value.Issuer, minimumLevel);
+                cloned.Add(logger.Key, clonedLogger);
+            }
+
+            return new ConcurrentDictionary<Type, ILogger>(cloned);
+        }
     }
 }

dotnet/src/webdriver/cdp/README.md

@@ -17,7 +17,7 @@ add an entry for version `<N>` to the `SupportedDevToolsVersions` dictionary ini
 6. In [`//dotnet/src/webdriver:WebDriver.csproj.prebuild.cmd`](https://github.com/SeleniumHQ/selenium/blob/trunk/dotnet/src/webdriver/WebDriver.csproj.prebuild.cmd),
 add the following block (substituting the proper value for `<N>`):
 
-```
+```bash
 if not exist  "%1..\..\..\bazel-bin\dotnet\src\webdriver\cdp\v<N>\DevToolsSessionDomains.cs" (
   echo Generating CDP code for version <N>
   pushd "%1..\..\.."
@@ -29,7 +29,7 @@ if not exist  "%1..\..\..\bazel-bin\dotnet\src\webdriver\cdp\v<N>\DevToolsSessio
 7. In [`//dotnet/src/webdriver:WebDriver.csproj.prebuild.sh`](https://github.com/SeleniumHQ/selenium/blob/trunk/dotnet/src/webdriver/WebDriver.csproj.prebuild.sh),
 add the following block (substituting the proper value for `<N>`):
 
-```
+```bash
 if [[ ! -f "$1../../../bazel-bin/dotnet/src/webdriver/cdp/v<N>/DevToolsSessionDomains.cs" ]]
 then
   echo "Generating CDP code for version <N>"

dotnet/test/common/Internal/Logging/LogTest.cs

@@ -28,13 +28,27 @@ public class LogTest
         private TestLogHandler testLogHandler;
         private ILogger logger;
 
+        private void ResetGlobalLog()
+        {
+            Log.SetLevel(LogEventLevel.Info);
+            Log.Handlers.Clear().Handlers.Add(new ConsoleLogHandler());
+        }
+
         [SetUp]
         public void SetUp()
         {
+            ResetGlobalLog();
+
             testLogHandler = new TestLogHandler();
             logger = Log.GetLogger<LogTest>();
         }
 
+        [TearDown]
+        public void TearDown()
+        {
+            ResetGlobalLog();
+        }
+
         [Test]
         public void LoggerShouldEmitEvent()
         {
@@ -160,6 +174,16 @@ public void ContextShouldChangeLevel()
             Assert.That(logger.Level, Is.EqualTo(LogEventLevel.Warn));
         }
 
+        [Test]
+        public void ContextShouldEmitMessages()
+        {
+            using var context = Log.CreateContext(LogEventLevel.Trace).Handlers.Add(testLogHandler);
+
+            logger.Trace("test message");
+
+            Assert.That(testLogHandler.Events.Count, Is.EqualTo(1));
+        }
+
         [Test]
         public void ShouldCreateContextWithCustomHandler()
         {

java/src/org/openqa/selenium/devtools/DevTools.java

@@ -42,7 +42,7 @@ public class DevTools implements Closeable {
   private static final Logger LOG = Logger.getLogger(DevTools.class.getName());
 
   private final Domains protocol;
-  private final Duration timeout = Duration.ofSeconds(10);
+  private final Duration timeout = Duration.ofSeconds(30);
   private final Connection connection;
   private SessionID cdpSession = null;
 

third_party/dotnet/devtools/src/generator/CodeGen/CodeGenerationDefinitionTemplateSettings.cs

@@ -16,7 +16,8 @@ public CodeGenerationDefinitionTemplateSettings()
                 OutputPath = "{{domainName}}\\{{className}}Adapter.cs",
             };
 
-            CommandTemplate = new CodeGenerationTemplateSettings {
+            CommandTemplate = new CodeGenerationTemplateSettings
+            {
                 TemplatePath = "command.hbs",
                 OutputPath = "{{domainName}}\\{{className}}Command.cs",
             };
@@ -47,46 +48,21 @@ public CodeGenerationDefinitionTemplateSettings()
         }
 
         [JsonProperty("domainTemplate")]
-        public CodeGenerationTemplateSettings DomainTemplate
-        {
-            get;
-            set;
-        }
+        public CodeGenerationTemplateSettings DomainTemplate { get; set; }
 
         [JsonProperty("commandTemplate")]
-        public CodeGenerationTemplateSettings CommandTemplate
-        {
-            get;
-            set;
-        }
+        public CodeGenerationTemplateSettings CommandTemplate { get; set; }
 
         [JsonProperty("eventTemplate")]
-        public CodeGenerationTemplateSettings EventTemplate
-        {
-            get;
-            set;
-        }
+        public CodeGenerationTemplateSettings EventTemplate { get; set; }
 
         [JsonProperty("typeObjectTemplate")]
-        public CodeGenerationTemplateSettings TypeObjectTemplate
-        {
-            get;
-            set;
-        }
+        public CodeGenerationTemplateSettings TypeObjectTemplate { get; set; }
 
         [JsonProperty("typeHashTemplate")]
-        public CodeGenerationTemplateSettings TypeHashTemplate
-        {
-            get;
-            set;
-        }
+        public CodeGenerationTemplateSettings TypeHashTemplate { get; set; }
 
         [JsonProperty("typeEnumTemplate")]
-        public CodeGenerationTemplateSettings TypeEnumTemplate
-        {
-            get;
-            set;
-        }
-
+        public CodeGenerationTemplateSettings TypeEnumTemplate { get; set; }
     }
 }

third_party/dotnet/devtools/src/generator/CodeGen/CodeGenerationSettings.cs

@@ -1,4 +1,4 @@
-namespace OpenQA.Selenium.DevToolsGenerator.CodeGen
+namespace OpenQA.Selenium.DevToolsGenerator.CodeGen
 {
     using Newtonsoft.Json;
     using System.Collections.Generic;
@@ -27,74 +27,42 @@ public CodeGenerationSettings()
         /// Collection of templates that will be parsed and output in the target folder.
         /// </summary>
         [JsonProperty("include")]
-        public ICollection<CodeGenerationTemplateSettings> Include
-        {
-            get;
-            set;
-        }
+        public ICollection<CodeGenerationTemplateSettings> Include { get; set; }
 
         /// <summary>
         /// Indicates whether or not domains marked as depreciated will be generated. (Default: true)
         /// </summary>
         [JsonProperty("includeDeprecatedDomains")]
-        public bool IncludeDeprecatedDomains
-        {
-            get;
-            set;
-        }
+        public bool IncludeDeprecatedDomains { get; set; }
 
         /// <summary>
         /// Indicates whether or not domains marked as depreciated will be generated. (Default: true)
         /// </summary>
         [JsonProperty("includeExperimentalDomains")]
-        public bool IncludeExperimentalDomains
-        {
-            get;
-            set;
-        }
+        public bool IncludeExperimentalDomains { get; set; }
 
         /// <summary>
         /// Gets or sets the root namespace of generated classes.
         /// </summary>
         [JsonProperty("rootNamespace")]
-        public string RootNamespace
-        {
-            get;
-            set;
-        }
+        public string RootNamespace { get; set; }
 
         /// <summary>
         /// Gets the version number of the runtime.
         /// </summary>
         [JsonProperty("runtimeVersion")]
-        public string RuntimeVersion
-        {
-            get;
-            set;
-        }
+        public string RuntimeVersion { get; set; }
 
         [JsonProperty("definitionTemplates")]
-        public CodeGenerationDefinitionTemplateSettings DefinitionTemplates
-        {
-            get;
-            set;
-        }
+        public CodeGenerationDefinitionTemplateSettings DefinitionTemplates { get; set; }
 
         [JsonProperty("templatesPath")]
-        public string TemplatesPath
-        {
-            get;
-            set;
-        }
+        public string TemplatesPath { get; set; }
 
         /// <summary>
         /// The using statements that will be included on each generated file.
         /// </summary>
         [JsonProperty("usingStatements")]
-        public ICollection<string> UsingStatements
-        {
-            get;
-            set;
-        }
+        public ICollection<string> UsingStatements { get; set; }
     }
 }