update sharpcifs

1 files changed, 158 insertions, 175 deletions

diff --git a/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/ThreadPoolExecutor.cs b/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/ThreadPoolExecutor.cs
index c8b2179b8..ef19b8bff 100644
--- a/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/ThreadPoolExecutor.cs
+++ b/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/ThreadPoolExecutor.cs
@@ -4,180 +4,163 @@ using ST = System.Threading;
 
 namespace SharpCifs.Util.Sharpen
 {
-    class ThreadPoolExecutor
-    {
-        ThreadFactory _tf;
-        int _corePoolSize;
-        int _maxPoolSize;
-        List<Thread> _pool = new List<Thread>();
-        int _runningThreads;
-        int _freeThreads;
-        bool _shutdown;
-        Queue<IRunnable> _pendingTasks = new Queue<IRunnable>();
-
-        public ThreadPoolExecutor(int corePoolSize, ThreadFactory factory)
-        {
-            this._corePoolSize = corePoolSize;
-            _maxPoolSize = corePoolSize;
-            _tf = factory;
-        }
-
-        public void SetMaximumPoolSize(int size)
-        {
-            _maxPoolSize = size;
-        }
-
-        public bool IsShutdown()
-        {
-            return _shutdown;
-        }
-
-        public virtual bool IsTerminated()
-        {
-            lock (_pendingTasks)
-            {
-                return _shutdown && _pendingTasks.Count == 0;
-            }
-        }
-
-        public virtual bool IsTerminating()
-        {
-            lock (_pendingTasks)
-            {
-                return _shutdown && !IsTerminated();
-            }
-        }
-
-        public int GetCorePoolSize()
-        {
-            return _corePoolSize;
-        }
-
-        public void PrestartAllCoreThreads()
-        {
-            lock (_pendingTasks)
-            {
-                while (_runningThreads < _corePoolSize)
-                    StartPoolThread();
-            }
-        }
-
-        public void SetThreadFactory(ThreadFactory f)
-        {
-            _tf = f;
-        }
-
-        public void Execute(IRunnable r)
-        {
-            InternalExecute(r, true);
-        }
-
-        internal void InternalExecute(IRunnable r, bool checkShutdown)
-        {
-            lock (_pendingTasks)
-            {
-                if (_shutdown && checkShutdown)
-                    throw new InvalidOperationException();
-                if (_runningThreads < _corePoolSize)
-                {
-                    StartPoolThread();
-                }
-                else if (_freeThreads > 0)
-                {
-                    _freeThreads--;
-                }
-                else if (_runningThreads < _maxPoolSize)
-                {
-                    StartPoolThread();
-                }
-                _pendingTasks.Enqueue(r);
-                ST.Monitor.PulseAll(_pendingTasks);
-            }
-        }
-
-        void StartPoolThread()
-        {
-            _runningThreads++;
-            _pool.Add(_tf.NewThread(new RunnableAction(RunPoolThread)));
-        }
-
-        public void RunPoolThread()
-        {
-            while (!IsTerminated())
-            {
-                try
-                {
-                    IRunnable r = null;
-                    lock (_pendingTasks)
-                    {
-                        _freeThreads++;
-                        while (!IsTerminated() && _pendingTasks.Count == 0)
-                            ST.Monitor.Wait(_pendingTasks);
-                        if (IsTerminated())
-                            break;
-                        r = _pendingTasks.Dequeue();
-                    }
-                    if (r != null)
-                        r.Run();
-                }
+	class ThreadPoolExecutor
+	{
+		ThreadFactory _tf;
+		int _corePoolSize;
+		int _maxPoolSize;
+		List<Thread> _pool = new List<Thread> ();
+		int _runningThreads;
+		int _freeThreads;
+		bool _shutdown;
+		Queue<IRunnable> _pendingTasks = new Queue<IRunnable> ();
+		
+		public ThreadPoolExecutor (int corePoolSize, ThreadFactory factory)
+		{
+			this._corePoolSize = corePoolSize;
+			_maxPoolSize = corePoolSize;
+			_tf = factory;
+		}
+		
+		public void SetMaximumPoolSize (int size)
+		{
+			_maxPoolSize = size;
+		}
+		
+		public bool IsShutdown ()
+		{
+			return _shutdown;
+		}
+		
+		public virtual bool IsTerminated ()
+		{
+			lock (_pendingTasks) {
+				return _shutdown && _pendingTasks.Count == 0;
+			}
+		}
+		
+		public virtual bool IsTerminating ()
+		{
+			lock (_pendingTasks) {
+				return _shutdown && !IsTerminated ();
+			}
+		}
+		
+		public int GetCorePoolSize ()
+		{
+			return _corePoolSize;
+		}
+		
+		public void PrestartAllCoreThreads ()
+		{
+			lock (_pendingTasks) {
+				while (_runningThreads < _corePoolSize)
+					StartPoolThread ();
+			}
+		}
+		
+		public void SetThreadFactory (ThreadFactory f)
+		{
+			_tf = f;
+		}
+		
+		public void Execute (IRunnable r)
+		{
+			InternalExecute (r, true);
+		}
+		
+		internal void InternalExecute (IRunnable r, bool checkShutdown)
+		{
+			lock (_pendingTasks) {
+				if (_shutdown && checkShutdown)
+					throw new InvalidOperationException ();
+				if (_runningThreads < _corePoolSize) {
+					StartPoolThread ();
+				}
+				else if (_freeThreads > 0) {
+					_freeThreads--;
+				}
+				else if (_runningThreads < _maxPoolSize) {
+					StartPoolThread ();
+				}
+				_pendingTasks.Enqueue (r);
+				ST.Monitor.PulseAll (_pendingTasks);
+			}
+		}
+		
+		void StartPoolThread ()
+		{
+			_runningThreads++;
+			_pool.Add (_tf.NewThread (new RunnableAction (RunPoolThread)));
+		}
+		
+		public void RunPoolThread ()
+		{
+			while (!IsTerminated ()) {
+				try {
+					IRunnable r = null;
+					lock (_pendingTasks) {
+						_freeThreads++;
+						while (!IsTerminated () && _pendingTasks.Count == 0)
+							ST.Monitor.Wait (_pendingTasks);
+						if (IsTerminated ())
+							break;
+						r = _pendingTasks.Dequeue ();
+					}
+					if (r != null)
+						r.Run ();
+				}
                 //supress all errors, anyway
-                //catch (ST.ThreadAbortException) {
-                //	// Do not catch a thread abort. If we've been aborted just let the thread die.
-                //	// Currently reseting an abort which was issued because the appdomain is being
-                //	// torn down results in the process living forever and consuming 100% cpu time.
-                //	return;
-                //}
-                catch
-                {
-                }
-            }
-        }
-
-        public virtual void Shutdown()
-        {
-            lock (_pendingTasks)
-            {
-                _shutdown = true;
-                ST.Monitor.PulseAll(_pendingTasks);
-            }
-        }
-
-        public virtual List<IRunnable> ShutdownNow()
-        {
-            lock (_pendingTasks)
-            {
-                _shutdown = true;
-                foreach (var t in _pool)
-                {
-                    try
-                    {
-                        t.Cancel(true);
-                        t.Dispose();
-                    }
-                    catch { }
-                }
-                _pool.Clear();
-                _freeThreads = 0;
-                _runningThreads = 0;
-                var res = new List<IRunnable>(_pendingTasks);
-                _pendingTasks.Clear();
-                return res;
-            }
-        }
-    }
-
-    class RunnableAction : IRunnable
-    {
-        Action _action;
-
-        public RunnableAction(Action a)
-        {
-            _action = a;
-        }
-
-        public void Run()
-        {
-            _action();
-        }
-    }
+				//catch (ST.ThreadAbortException) {
+				//	// Do not catch a thread abort. If we've been aborted just let the thread die.
+				//	// Currently reseting an abort which was issued because the appdomain is being
+				//	// torn down results in the process living forever and consuming 100% cpu time.
+				//	return;
+				//}
+				catch {
+				}
+			}
+		}
+		
+		public virtual void Shutdown ()
+		{
+			lock (_pendingTasks) {
+				_shutdown = true;
+				ST.Monitor.PulseAll (_pendingTasks);
+			}
+		}
+		
+		public virtual List<IRunnable> ShutdownNow ()
+		{
+			lock (_pendingTasks) {
+				_shutdown = true;
+				foreach (var t in _pool) {
+					try {
+						t.Abort ();
+					} catch {}
+				}
+				_pool.Clear ();
+				_freeThreads = 0;
+				_runningThreads = 0;
+				var res = new List<IRunnable> (_pendingTasks);
+				_pendingTasks.Clear ();
+				return res;
+			}
+		}
+	}
+	
+	class RunnableAction: IRunnable
+	{
+		Action _action;
+		
+		public RunnableAction (Action a)
+		{
+			_action = a;
+		}
+		
+		public void Run ()
+		{
+			_action ();
+		}
+	}
 }