Style fixes

Jellyfin.Server/SocketSharp/WebSocketSharpListener.cs

@@ -69,7 +69,7 @@ namespace Jellyfin.Server.SocketSharp
         {
             if (_listener == null)
             {
-                _listener = new HttpListener(_logger, _cryptoProvider, _socketFactory, _networkManager, _streamHelper, _fileSystem, _environment);
+                _listener = new HttpListener(_logger, _cryptoProvider, _socketFactory, _streamHelper, _fileSystem, _environment);
             }
 
             _listener.EnableDualMode = _enableDualMode;

SocketHttpListener/Net/HttpListener.cs

@@ -3,7 +3,6 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Net;
 using System.Security.Cryptography.X509Certificates;
-using MediaBrowser.Common.Net;
 using MediaBrowser.Model.Cryptography;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Net;
@@ -18,47 +17,55 @@ namespace SocketHttpListener.Net
         internal ISocketFactory SocketFactory { get; private set; }
         internal IFileSystem FileSystem { get; private set; }
         internal IStreamHelper StreamHelper { get; private set; }
-        internal INetworkManager NetworkManager { get; private set; }
         internal IEnvironmentInfo EnvironmentInfo { get; private set; }
 
         public bool EnableDualMode { get; set; }
 
-        AuthenticationSchemes auth_schemes;
-        HttpListenerPrefixCollection prefixes;
-        AuthenticationSchemeSelector auth_selector;
-        string realm;
-        bool unsafe_ntlm_auth;
-        bool listening;
-        bool disposed;
+        private AuthenticationSchemes auth_schemes;
+        private HttpListenerPrefixCollection prefixes;
+        private AuthenticationSchemeSelector auth_selector;
+        private string realm;
+        private bool unsafe_ntlm_auth;
+        private bool listening;
+        private bool disposed;
 
-        Dictionary<HttpListenerContext, HttpListenerContext> registry;   // Dictionary<HttpListenerContext,HttpListenerContext>
-        Dictionary<HttpConnection, HttpConnection> connections;
+        private Dictionary<HttpListenerContext, HttpListenerContext> registry;
+        private Dictionary<HttpConnection, HttpConnection> connections;
         private ILogger _logger;
         private X509Certificate _certificate;
 
         public Action<HttpListenerContext> OnContext { get; set; }
 
-        public HttpListener(ILogger logger, ICryptoProvider cryptoProvider, ISocketFactory socketFactory,
-            INetworkManager networkManager, IStreamHelper streamHelper, IFileSystem fileSystem,
+        public HttpListener(
+            ILogger logger,
+            ICryptoProvider cryptoProvider,
+            ISocketFactory socketFactory,
+            IStreamHelper streamHelper,
+            IFileSystem fileSystem,
             IEnvironmentInfo environmentInfo)
         {
             _logger = logger;
             CryptoProvider = cryptoProvider;
             SocketFactory = socketFactory;
-            NetworkManager = networkManager;
             StreamHelper = streamHelper;
             FileSystem = fileSystem;
             EnvironmentInfo = environmentInfo;
+
             prefixes = new HttpListenerPrefixCollection(logger, this);
             registry = new Dictionary<HttpListenerContext, HttpListenerContext>();
             connections = new Dictionary<HttpConnection, HttpConnection>();
             auth_schemes = AuthenticationSchemes.Anonymous;
         }
 
-        public HttpListener(ILogger logger, X509Certificate certificate, ICryptoProvider cryptoProvider,
-            ISocketFactory socketFactory, INetworkManager networkManager, IStreamHelper streamHelper,
-            IFileSystem fileSystem, IEnvironmentInfo environmentInfo)
-            : this(logger, cryptoProvider, socketFactory, networkManager, streamHelper, fileSystem, environmentInfo)
+        public HttpListener(
+            ILogger logger,
+            X509Certificate certificate,
+            ICryptoProvider cryptoProvider,
+            ISocketFactory socketFactory,
+            IStreamHelper streamHelper,
+            IFileSystem fileSystem,
+            IEnvironmentInfo environmentInfo)
+            : this(logger, cryptoProvider, socketFactory, streamHelper, fileSystem, environmentInfo)
         {
             _certificate = certificate;
         }

SocketHttpListener/Net/HttpListenerPrefixCollection.cs

@@ -7,18 +7,18 @@ namespace SocketHttpListener.Net
 {
     public class HttpListenerPrefixCollection : ICollection<string>, IEnumerable<string>, IEnumerable
     {
-        List<string> prefixes = new List<string>();
-        HttpListener listener;
+        private List<string> _prefixes = new List<string>();
+        private HttpListener _listener;
 
         private ILogger _logger;
 
         internal HttpListenerPrefixCollection(ILogger logger, HttpListener listener)
         {
             _logger = logger;
-            this.listener = listener;
+            _listener = listener;
         }
 
-        public int Count => prefixes.Count;
+        public int Count => _prefixes.Count;
 
         public bool IsReadOnly => false;
 
@@ -26,80 +26,90 @@ namespace SocketHttpListener.Net
 
         public void Add(string uriPrefix)
         {
-            listener.CheckDisposed();
+            _listener.CheckDisposed();
             //ListenerPrefix.CheckUri(uriPrefix);
-            if (prefixes.Contains(uriPrefix))
+            if (_prefixes.Contains(uriPrefix))
+            {
                 return;
+            }
 
-            prefixes.Add(uriPrefix);
-            if (listener.IsListening)
-                HttpEndPointManager.AddPrefix(_logger, uriPrefix, listener);
+            _prefixes.Add(uriPrefix);
+            if (_listener.IsListening)
+            {
+                HttpEndPointManager.AddPrefix(_logger, uriPrefix, _listener);
+            }
         }
 
         public void AddRange(IEnumerable<string> uriPrefixes)
         {
-            listener.CheckDisposed();
-            //ListenerPrefix.CheckUri(uriPrefix);
+            _listener.CheckDisposed();
+
             foreach (var uriPrefix in uriPrefixes)
             {
-                if (prefixes.Contains(uriPrefix))
+                if (_prefixes.Contains(uriPrefix))
                 {
                     continue;
                 }
 
-                prefixes.Add(uriPrefix);
-                if (listener.IsListening)
+                _prefixes.Add(uriPrefix);
+                if (_listener.IsListening)
                 {
-                    HttpEndPointManager.AddPrefix(_logger, uriPrefix, listener);
+                    HttpEndPointManager.AddPrefix(_logger, uriPrefix, _listener);
                 }
             }
         }
 
         public void Clear()
         {
-            listener.CheckDisposed();
-            prefixes.Clear();
-            if (listener.IsListening)
-                HttpEndPointManager.RemoveListener(_logger, listener);
+            _listener.CheckDisposed();
+            _prefixes.Clear();
+            if (_listener.IsListening)
+            {
+                HttpEndPointManager.RemoveListener(_logger, _listener);
+            }
         }
 
         public bool Contains(string uriPrefix)
         {
-            listener.CheckDisposed();
-            return prefixes.Contains(uriPrefix);
+            _listener.CheckDisposed();
+            return _prefixes.Contains(uriPrefix);
         }
 
         public void CopyTo(string[] array, int offset)
         {
-            listener.CheckDisposed();
-            prefixes.CopyTo(array, offset);
+            _listener.CheckDisposed();
+            _prefixes.CopyTo(array, offset);
         }
 
         public void CopyTo(Array array, int offset)
         {
-            listener.CheckDisposed();
-            ((ICollection)prefixes).CopyTo(array, offset);
+            _listener.CheckDisposed();
+            ((ICollection)_prefixes).CopyTo(array, offset);
         }
 
         public IEnumerator<string> GetEnumerator()
         {
-            return prefixes.GetEnumerator();
+            return _prefixes.GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
         {
-            return prefixes.GetEnumerator();
+            return _prefixes.GetEnumerator();
         }
 
         public bool Remove(string uriPrefix)
         {
-            listener.CheckDisposed();
+            _listener.CheckDisposed();
             if (uriPrefix == null)
+            {
                 throw new ArgumentNullException(nameof(uriPrefix));
+            }
 
-            bool result = prefixes.Remove(uriPrefix);
-            if (result && listener.IsListening)
-                HttpEndPointManager.RemovePrefix(_logger, uriPrefix, listener);
+            bool result = _prefixes.Remove(uriPrefix);
+            if (result && _listener.IsListening)
+            {
+                HttpEndPointManager.RemovePrefix(_logger, uriPrefix, _listener);
+            }
 
             return result;
         }