Use abstract classes for DevTools domains instead of interfaces in .NET

Author: jimevans

dotnet/src/webdriver/DevTools/ConsoleApiCalledEventArgs.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Text;
 
 namespace OpenQA.Selenium.DevTools
@@ -40,6 +41,6 @@ public class ConsoleApiCalledEventArgs : EventArgs
         /// <summary>
         /// Gets the arguments of the call to the browser's console API.
         /// </summary>
-        public List<ConsoleApiArgument> Arguments { get; internal set; }
+        public ReadOnlyCollection<ConsoleApiArgument> Arguments { get; internal set; }
     }
 }

dotnet/src/webdriver/DevTools/IDomains.cs

@@ -34,21 +34,21 @@ public interface IDomains
         /// <summary>
         /// Gets the object used for manipulating network information in the browser.
         /// </summary>
-        INetwork Network { get; }
+        Network Network { get; }
 
         /// <summary>
         /// Gets the object used for manipulating the browser's JavaScript execution.
         /// </summary>
-        IJavaScript JavaScript { get; }
+        JavaScript JavaScript { get; }
 
         /// <summary>
         /// Gets the object used for manipulating DevTools Protocol targets.
         /// </summary>
-        ITarget Target { get; }
+        Target Target { get; }
 
         /// <summary>
         /// Gets the object used for manipulating the browser's logs.
         /// </summary>
-        ILog Log { get; }
+        Log Log { get; }
     }
 }

dotnet/src/webdriver/DevTools/IJavaScript.cs renamed to dotnet/src/webdriver/DevTools/JavaScript.cs

@@ -21,75 +21,99 @@
 namespace OpenQA.Selenium.DevTools
 {
     /// <summary>
-    /// Interface representing the browser's JavaScript execution as referenced by the DevTools Protocol.
+    /// Class representing the browser's JavaScript execution as referenced by the DevTools Protocol.
     /// </summary>
-    public interface IJavaScript
+    public abstract class JavaScript
     {
         /// <summary>
         /// Occurs when a JavaScript script binding is called.
         /// </summary>
-        event EventHandler<BindingCalledEventArgs> BindingCalled;
+        public event EventHandler<BindingCalledEventArgs> BindingCalled;
 
         /// <summary>
         /// Occurs when the browser's JavaScript console API is called.
         /// </summary>
-        event EventHandler<ConsoleApiCalledEventArgs> ConsoleApiCalled;
+        public event EventHandler<ConsoleApiCalledEventArgs> ConsoleApiCalled;
 
         /// <summary>
         /// Occurs when a JavaScript exception is thrown.
         /// </summary>
-        event EventHandler<ExceptionThrownEventArgs> ExceptionThrown;
+        public event EventHandler<ExceptionThrownEventArgs> ExceptionThrown;
 
         /// <summary>
         /// Asynchronously enables the Runtime domain in the DevTools Protocol.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EnableRuntime();
+        public abstract Task EnableRuntime();
 
         /// <summary>
         /// Asynchronously disables the Runtime domain in the DevTools Protocol.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task DisableRuntime();
+        public abstract Task DisableRuntime();
 
         /// <summary>
         /// Asynchronously enables the Page domain in the DevTools Protocol.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EnablePage();
+        public abstract Task EnablePage();
 
         /// <summary>
         /// Asynchronously disables the Page domain in the DevTools Protocol.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task DisablePage();
+        public abstract Task DisablePage();
 
         /// <summary>
         /// Adds a binding to a specific JavaScript name.
         /// </summary>
         /// <param name="name">The name to which to bind to.</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task AddBinding(string name);
+        public abstract Task AddBinding(string name);
 
         /// <summary>
         /// Removes a binding from a specific JavaScript name.
         /// </summary>
         /// <param name="name">The name to which to remove the bind from.</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task RemoveBinding(string name);
+        public abstract Task RemoveBinding(string name);
 
         /// <summary>
         /// Adds a JavaScript snippet to evaluate when a new document is opened.
         /// </summary>
         /// <param name="script">The script to add to be evaluated when a new document is opened.</param>
         /// <returns>A task that represents the asynchronous operation. The task result contains the internal ID of the script.</returns>
-        Task<string> AddScriptToEvaluateOnNewDocument(string script);
+        public abstract Task<string> AddScriptToEvaluateOnNewDocument(string script);
 
         /// <summary>
         /// Removes a JavaScript snippet from evaluate when a new document is opened.
         /// </summary>
         /// <param name="scriptId">The ID of the script to be removed.</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task RemoveScriptToEvaluateOnNewDocument(string scriptId);
+        public abstract Task RemoveScriptToEvaluateOnNewDocument(string scriptId);
+
+        protected virtual void OnBindingCalled(BindingCalledEventArgs e)
+        {
+            if (this.BindingCalled != null)
+            {
+                this.BindingCalled(this, e);
+            }
+        }
+
+        protected virtual void OnConsoleApiCalled(ConsoleApiCalledEventArgs e)
+        {
+            if (this.ConsoleApiCalled != null)
+            {
+                this.ConsoleApiCalled(this, e);
+            }
+        }
+
+        protected virtual void OnExceptionThrown(ExceptionThrownEventArgs e)
+        {
+            if (this.ExceptionThrown != null)
+            {
+                this.ExceptionThrown(this, e);
+            }
+        }
     }
 }

dotnet/src/webdriver/DevTools/ILog.cs renamed to dotnet/src/webdriver/DevTools/Log.cs

@@ -21,25 +21,39 @@
 namespace OpenQA.Selenium.DevTools
 {
     /// <summary>
-    /// Interface representing the browser's log as referenced by the DevTools Protocol.
+    /// Class representing the browser's log as referenced by the DevTools Protocol.
     /// </summary>
-    public interface ILog
+    public abstract class Log
     {
         /// <summary>
         /// Occurs when an entry is added to the browser's log.
         /// </summary>
-        event EventHandler<EntryAddedEventArgs> EntryAdded;
+        public event EventHandler<EntryAddedEventArgs> EntryAdded;
 
         /// <summary>
-        /// Asynchrounously enables manipulation of the browser's log.
+        /// Asynchronously enables manipulation of the browser's log.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task Enable();
+        public abstract Task Enable();
 
         /// <summary>
-        /// Asynchrounously clears the browser's log.
+        /// Asynchronously disables manipulation of the browser's log.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task Clear();
+        public abstract Task Disable();
+
+        /// <summary>
+        /// Asynchronously clears the browser's log.
+        /// </summary>
+        /// <returns>A task that represents the asynchronous operation.</returns>
+        public abstract Task Clear();
+
+        protected virtual void OnEntryAdded(EntryAddedEventArgs e)
+        {
+            if (this.EntryAdded != null)
+            {
+                this.EntryAdded(this, e);
+            }
+        }
     }
 }

dotnet/src/webdriver/DevTools/INetwork.cs renamed to dotnet/src/webdriver/DevTools/Network.cs

@@ -22,58 +22,58 @@
 namespace OpenQA.Selenium.DevTools
 {
     /// <summary>
-    /// Interface providing functionality for manipulating network calls using DevTools Protocol commands
+    /// Class providing functionality for manipulating network calls using DevTools Protocol commands
     /// </summary>
-    public interface INetwork
+    public abstract class Network
     {
         /// <summary>
         /// Occurs when a network request requires authorization.
         /// </summary>
-        event EventHandler<AuthRequiredEventArgs> AuthRequired;
+        public event EventHandler<AuthRequiredEventArgs> AuthRequired;
 
         /// <summary>
         /// Occurs when a network request is intercepted.
         /// </summary>
-        event EventHandler<RequestPausedEventArgs> RequestPaused;
+        public event EventHandler<RequestPausedEventArgs> RequestPaused;
 
         /// <summary>
         /// Asynchronously disables network caching.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task DisableNetworkCaching();
+        public abstract Task DisableNetworkCaching();
 
         /// <summary>
         /// Asynchronously enables network caching.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EnableNetworkCaching();
+        public abstract Task EnableNetworkCaching();
 
         /// <summary>
         /// Asynchronously enables the fetch domain for all URL patterns.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EnableFetchForAllPatterns();
+        public abstract Task EnableFetchForAllPatterns();
 
         /// <summary>
         /// Asynchronously diables the fetch domain.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task DisableFetch();
+        public abstract Task DisableFetch();
 
         /// <summary>
         /// Asynchronously continues an intercepted network request.
         /// </summary>
         /// <param name="requestData">The <see cref="HttpRequestData"/> of the request.</param>
         /// <param name="responseData">The <see cref="HttpResponseData"/> with which to respond to the request</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task ContinueRequest(HttpRequestData requestData, HttpResponseData responseData);
+        public abstract Task ContinueRequest(HttpRequestData requestData, HttpResponseData responseData);
 
         /// <summary>
         /// Asynchronously contines an intercepted network call without modification.
         /// </summary>
         /// <param name="requestData">The <see cref="HttpRequestData"/> of the network request.</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task ContinueWithoutModification(HttpRequestData requestData);
+        public abstract Task ContinueWithoutModification(HttpRequestData requestData);
 
         /// <summary>
         /// Asynchronously continues an intercepted network call using authentication.
@@ -82,13 +82,29 @@ public interface INetwork
         /// <param name="userName">The user name with which to authenticate.</param>
         /// <param name="password">The password with which to authenticate.</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task ContinueWithAuth(HttpRequestData requestData, string userName, string password);
+        public abstract Task ContinueWithAuth(HttpRequestData requestData, string userName, string password);
 
         /// <summary>
         /// Asynchronously cancels authorization of an intercepted network request.
         /// </summary>
         /// <param name="requestData">The <see cref="HttpRequestData"/> of the network request.</param>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task CancelAuth(HttpRequestData requestData);
+        public abstract Task CancelAuth(HttpRequestData requestData);
+
+        protected virtual void OnAuthRequired(AuthRequiredEventArgs e)
+        {
+            if (this.AuthRequired != null)
+            {
+                this.AuthRequired(this, e);
+            }
+        }
+
+        protected virtual void OnRequestPaused(RequestPausedEventArgs e)
+        {
+            if (this.RequestPaused != null)
+            {
+                this.RequestPaused(this, e);
+            }
+        }
     }
 }

dotnet/src/webdriver/DevTools/ITarget.cs renamed to dotnet/src/webdriver/DevTools/Target.cs

@@ -17,14 +17,15 @@
 // </copyright>
 
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Threading.Tasks;
 
 namespace OpenQA.Selenium.DevTools
 {
     /// <summary>
-    /// Interface representing a target for DevTools Protocol commands
+    /// Class representing a target for DevTools Protocol commands
     /// </summary>
-    public interface ITarget
+    public abstract class Target
     {
         /// <summary>
         /// Asynchronously gets the targets available for this session.
@@ -34,7 +35,7 @@ public interface ITarget
         /// contains the list of <see cref="TargetInfo"/> objects describing the
         /// targets available for this session.
         /// </returns>
-        Task<List<TargetInfo>> GetTargets();
+        public abstract Task<ReadOnlyCollection<TargetInfo>> GetTargets();
 
         /// <summary>
         /// Asynchronously attaches to a target.
@@ -44,12 +45,22 @@ public interface ITarget
         /// A task representing the asynchronous attach operation. The task result contains the
         /// session ID established for commands to the target attached to.
         /// </returns>
-        Task<string> AttachToTarget(string TargetId);
+        public abstract Task<string> AttachToTarget(string targetId);
+
+        /// <summary>
+        /// Asynchronously detaches from a target.
+        /// </summary>
+        /// <param name="sessionId">The ID of the session of the target from which to detach.</param>
+        /// <param name="targetId">The ID of the target from which to detach.</param>
+        /// <returns>
+        /// A task representing the asynchronous detach operation.
+        /// </returns>
+        public abstract Task DetachFromTarget(string sessionId = null, string targetId = null);
 
         /// <summary>
         /// Asynchronously sets the DevTools Protocol connection to automatically attach to new targets.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task SetAutoAttach();
+        public abstract Task SetAutoAttach();
     }
 }

dotnet/src/webdriver/DevTools/v84/V84Domains.cs

@@ -50,21 +50,21 @@ public V84Domains(DevToolsSession session)
         /// <summary>
         /// Gets the object used for manipulating network information in the browser.
         /// </summary>
-        public INetwork Network => new V84Network(domains.Network, domains.Fetch);
+        public DevTools.Network Network => new V84Network(domains.Network, domains.Fetch);
 
         /// <summary>
         /// Gets the object used for manipulating the browser's JavaScript execution.
         /// </summary>
-        public IJavaScript JavaScript => new V84JavaScript(domains.Runtime, domains.Page);
+        public JavaScript JavaScript => new V84JavaScript(domains.Runtime, domains.Page);
 
         /// <summary>
         /// Gets the object used for manipulating DevTools Protocol targets.
         /// </summary>
-        public ITarget Target => new V84Target(domains.Target);
+        public DevTools.Target Target => new V84Target(domains.Target);
 
         /// <summary>
         /// Gets the object used for manipulating the browser's logs.
         /// </summary>
-        public ILog Log => new V84Log(domains.Log);
+        public DevTools.Log Log => new V84Log(domains.Log);
     }
 }