Imported Upstream version 5.4.0.167

Former-commit-id: 5624ac747d633e885131e8349322922b6a59baaa

mcs/class/referencesource/mscorlib/system/threading/CDSsyncETWBCLProvider.cs

@@ -7,12 +7,12 @@
 //
 // CdsSyncEtwBCLProvider.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // A helper class for firing ETW events related to the Coordination Data Structure 
-// [....] primitives. This provider is used by CDS [....] primitives in both mscorlib.dll 
+// sync primitives. This provider is used by CDS sync primitives in both mscorlib.dll 
 // and system.dll. The purpose of sharing the provider class is to be able to enable 
-// ETW tracing on all CDS [....] types with a single ETW provider GUID, and to minimize
+// ETW tracing on all CDS sync types with a single ETW provider GUID, and to minimize
 // the number of providers in use.
 //
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -36,8 +36,8 @@ namespace System.Threading
     internal sealed class CdsSyncEtwBCLProvider : EventSource
     {
         /// <summary>
-        /// Defines the singleton instance for the CDS [....] ETW provider.
-        /// The CDS [....] Event provider GUID is {EC631D38-466B-4290-9306-834971BA0217}.
+        /// Defines the singleton instance for the CDS Sync ETW provider.
+        /// The CDS Sync Event provider GUID is {EC631D38-466B-4290-9306-834971BA0217}.
         /// </summary>
         public static CdsSyncEtwBCLProvider Log = new CdsSyncEtwBCLProvider();
         /// <summary>Prevent external instantiation.  All logging should go through the Log instance.</summary>

mcs/class/referencesource/mscorlib/system/threading/CancellationToken.cs

@@ -4,7 +4,7 @@
 // 
 // ==--==
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 ////////////////////////////////////////////////////////////////////////////////
 
 #pragma warning disable 0420 // turn off 'a reference to a volatile field will not be treated as volatile' during CAS.
@@ -334,8 +334,8 @@ namespace System.Threading
                 return new CancellationTokenRegistration(); // nothing to do for tokens than can never reach the canceled state. Give them a dummy registration.
             }
 
-            // Capture [....]/execution contexts if required.
-            // Note: Only capture [....]/execution contexts if IsCancellationRequested = false
+            // Capture sync/execution contexts if required.
+            // Note: Only capture sync/execution contexts if IsCancellationRequested = false
             // as we know that if it is true that the callback will just be called synchronously.
 
             SynchronizationContext capturedSyncContext = null;

mcs/class/referencesource/mscorlib/system/threading/CancellationTokenRegistration.cs

@@ -4,7 +4,7 @@
 // 
 // ==--==
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 ////////////////////////////////////////////////////////////////////////////////
 
 using System.Diagnostics.Contracts;

mcs/class/referencesource/mscorlib/system/threading/CancellationTokenSource.cs

@@ -5,7 +5,7 @@
 // 
 // ==--==
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 ////////////////////////////////////////////////////////////////////////////////
 
 using System;
@@ -826,7 +826,7 @@ namespace System.Threading
                                 m_executingCallback = currArrayFragment[i];
                                 if (m_executingCallback != null)
                                 {
-                                    //Transition to the target [....] context (if necessary), and continue our work there.
+                                    //Transition to the target sync context (if necessary), and continue our work there.
                                     CancellationCallbackCoreWorkArguments args = new CancellationCallbackCoreWorkArguments(currArrayFragment, i);
 
                                     // marshal exceptions: either aggregate or perform an immediate rethrow
@@ -892,7 +892,7 @@ namespace System.Threading
             {
                 if (callback.TargetExecutionContext != null)
                 {
-                    // we are running via a custom [....] context, so update the executing threadID
+                    // we are running via a custom sync context, so update the executing threadID
                     callback.CancellationTokenSource.ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
                 }
                 callback.ExecuteCallback();
@@ -988,7 +988,7 @@ namespace System.Threading
     // ----------------------------------------------------------
     // -- CancellationCallbackCoreWorkArguments --
     // ----------------------------------------------------------
-    // Helper struct for passing data to the target [....] context
+    // Helper struct for passing data to the target sync context
     internal struct CancellationCallbackCoreWorkArguments
     {
         internal SparselyPopulatedArrayFragment<CancellationCallbackInfo> m_currArrayFragment;

mcs/class/referencesource/mscorlib/system/threading/CountdownEvent.cs

@@ -7,7 +7,7 @@
 //
 // CountdownEvent.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // A simple coordination data structure that we use for fork/join style parallelism.
 //
@@ -115,7 +115,7 @@ namespace System.Threading
                 // The latch is "completed" if its current count has reached 0. Note that this is NOT
                 // the same thing is checking the event's IsCompleted property. There is a tiny window
                 // of time, after the final decrement of the current count to 0 and before setting the
-                // event, where the two values are out of [....].
+                // event, where the two values are out of sync.
                 return (m_currentCount <= 0);
             }
         }

mcs/class/referencesource/mscorlib/system/threading/LazyInitializer.cs

@@ -7,7 +7,7 @@
 //
 // LazyInitializer.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // a set of lightweight static helpers for lazy initialization.
 //

mcs/class/referencesource/mscorlib/system/threading/ManualResetEventSlim.cs

@@ -8,7 +8,7 @@
 //
 // SlimManualResetEvent.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // An manual-reset event that mixes a little spinning with a true Win32 event.
 //
@@ -281,7 +281,7 @@ namespace System.Threading
             // guarantee only one event is actually stored in this field.
             if (Interlocked.CompareExchange(ref m_eventObj, newEventObj, null) != null)
             {
-                // We ----d with someone else and lost. Destroy the garbage event.
+                // We raced with someone else and lost. Destroy the garbage event.
                 newEventObj.Close();
 
                 return false;

mcs/class/referencesource/mscorlib/system/threading/SemaphoreSlim.cs

@@ -7,7 +7,7 @@
 //
 // SemaphoreSlim.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // A lightweight semahore class that contains the basic semaphore functions plus some useful functions like interrupt
 // and wait handle exposing to allow waiting on multiple semaphores.

mcs/class/referencesource/mscorlib/system/threading/SpinLock.cs

@@ -11,7 +11,7 @@
 // repeatedly checking until the lock becomes available. As the thread remains active performing a non-useful task,
 // the use of such a lock is a kind of busy waiting and consumes CPU resources without performing real work. 
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 using System;

mcs/class/referencesource/mscorlib/system/threading/SpinWait.cs

@@ -7,7 +7,7 @@
 //
 // SpinWait.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // Central spin logic used across the entire code-base.
 //

mcs/class/referencesource/mscorlib/system/threading/Tasks/BeginEndAwaitableAdapter.cs

@@ -3,7 +3,7 @@
 ///     Copyright (c) Microsoft Corporation.  All rights reserved.
 /// </copyright>                               
 ///
-/// <owner>[....]</owner>
+/// <owner>Microsoft</owner>
 /// <owner>gpaperin</owner>
 ///----------- ----------- ----------- ----------- ----------- -----------
 

mcs/class/referencesource/mscorlib/system/threading/Tasks/ConcurrentExclusiveSchedulerPair.cs

@@ -7,7 +7,7 @@
 //
 // ConcurrentExclusiveSchedulerPair.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // A pair of schedulers that together support concurrent (reader) / exclusive (writer) 
 // task scheduling.  Using just the exclusive scheduler can be used to simulate a serial
@@ -70,7 +70,7 @@ namespace System.Threading.Tasks
         /// <summary>Default MaxConcurrencyLevel is the processor count if not otherwise specified.</summary>
         private static Int32 DefaultMaxConcurrencyLevel { get { return Environment.ProcessorCount; } }
 
-        /// <summary>Gets the [....] obj used to protect all state on this instance.</summary>
+        /// <summary>Gets the sync obj used to protect all state on this instance.</summary>
         private object ValueLock { get { return m_threadProcessingMapping; } }
 
         /// <summary>
@@ -763,7 +763,7 @@ namespace System.Threading.Tasks
         /// <param name="isReplacementReplica">If this task is being created to replace another.</param>
         /// <remarks>
         /// These options should be used for all tasks that have the potential to run user code or
-        /// that are repeatedly spawned and thus need a modi---- of fair treatment.
+        /// that are repeatedly spawned and thus need a modicum of fair treatment.
         /// </remarks>
         /// <returns>The options to use.</returns>
         internal static TaskCreationOptions GetCreationOptionsForTask(bool isReplacementReplica = false)

mcs/class/referencesource/mscorlib/system/threading/Tasks/Future.cs

@@ -7,7 +7,7 @@
 //
 // Future.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // A task that produces a value.
 //

mcs/class/referencesource/mscorlib/system/threading/Tasks/FutureFactory.cs.REMOVED.git-id

@@ -1 +1 @@
-21ec1d7b8346d780a4a059738ca4bb8f908e7f5c
+4c11ddf08d97379ccb571f04173f8445ebcb3c31

mcs/class/referencesource/mscorlib/system/threading/Tasks/Parallel.cs.REMOVED.git-id

@@ -1 +1 @@
-89ae7f7d20e98d27c2f40234107dd5d469f715c5
+3622447b1d39e6d5795142f6584dc81d79ea6a8e

mcs/class/referencesource/mscorlib/system/threading/Tasks/ParallelLoopState.cs

@@ -7,7 +7,7 @@
 //
 // ParallelState.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // A non-generic and generic parallel state class, used by the Parallel helper class
 // for parallel loop management.

mcs/class/referencesource/mscorlib/system/threading/Tasks/ParallelRangeManager.cs

@@ -7,7 +7,7 @@
 //
 // ParallelRangeManager.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // Implements the algorithm for distributing loop indices to parallel loop workers
 //

mcs/class/referencesource/mscorlib/system/threading/Tasks/ProducerConsumerQueues.cs

@@ -7,7 +7,7 @@
 //
 // ProducerConsumerQueues.cs
 //
-// <OWNER>[....], [....]</OWNER>
+// <OWNER>Microsoft, Microsoft</OWNER>
 //
 // Specialized producer/consumer queues.
 //
@@ -58,7 +58,7 @@ namespace System.Threading.Tasks
         int Count { get; }
 
         /// <summary>A thread-safe way to get the number of items in the collection. May synchronize access by locking the provided synchronization object.</summary>
-        /// <param name="syncObj">The [....] object used to lock</param>
+        /// <param name="syncObj">The sync object used to lock</param>
         /// <returns>The collection count</returns>
         int GetCountSafe(object syncObj);
     }

mcs/class/referencesource/mscorlib/system/threading/Tasks/TPLETWProvider.cs

@@ -7,7 +7,7 @@
 //
 // TplEtwProvider.cs
 //
-// <OWNER>[....]</OWNER>
+// <OWNER>Microsoft</OWNER>
 //
 // EventSource for TPL.
 //

mcs/class/referencesource/mscorlib/system/threading/Tasks/Task.cs.REMOVED.git-id

@@ -1 +1 @@
-6ee970a08efe8a6db1ba7d82b85a2d685c96bd2b
+0ca6568e9fbbe9f32c8048eca0973d09bcb98996