diff options
Diffstat (limited to 'src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs')
-rw-r--r-- | src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs | 64 |
1 files changed, 23 insertions, 41 deletions
diff --git a/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs b/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs index 4c035dfddb..70b9418dbf 100644 --- a/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs +++ b/src/mscorlib/src/System/Threading/Tasks/TaskContinuation.cs @@ -11,6 +11,7 @@ // =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- using System.Security; +using System.Diagnostics; using System.Diagnostics.Contracts; using System.Runtime.ExceptionServices; using System.Runtime.CompilerServices; @@ -45,7 +46,7 @@ namespace System.Threading.Tasks // Get and null out the antecedent. This is crucial to avoid a memory // leak with long chains of continuations. var antecedent = m_antecedent; - Contract.Assert(antecedent != null, + Debug.Assert(antecedent != null, "No antecedent was set for the ContinuationTaskFromTask."); m_antecedent = null; @@ -53,7 +54,7 @@ namespace System.Threading.Tasks antecedent.NotifyDebuggerOfWaitCompletionIfNecessary(); // Invoke the delegate - Contract.Assert(m_action != null); + Debug.Assert(m_action != null); var action = m_action as Action<Task>; if (action != null) { @@ -66,7 +67,7 @@ namespace System.Threading.Tasks actionWithState(antecedent, m_stateObject); return; } - Contract.Assert(false, "Invalid m_action in ContinuationTaskFromTask"); + Debug.Assert(false, "Invalid m_action in ContinuationTaskFromTask"); } } @@ -93,7 +94,7 @@ namespace System.Threading.Tasks // Get and null out the antecedent. This is crucial to avoid a memory // leak with long chains of continuations. var antecedent = m_antecedent; - Contract.Assert(antecedent != null, + Debug.Assert(antecedent != null, "No antecedent was set for the ContinuationResultTaskFromTask."); m_antecedent = null; @@ -101,7 +102,7 @@ namespace System.Threading.Tasks antecedent.NotifyDebuggerOfWaitCompletionIfNecessary(); // Invoke the delegate - Contract.Assert(m_action != null); + Debug.Assert(m_action != null); var func = m_action as Func<Task, TResult>; if (func != null) { @@ -114,7 +115,7 @@ namespace System.Threading.Tasks m_result = funcWithState(antecedent, m_stateObject); return; } - Contract.Assert(false, "Invalid m_action in ContinuationResultTaskFromTask"); + Debug.Assert(false, "Invalid m_action in ContinuationResultTaskFromTask"); } } @@ -141,7 +142,7 @@ namespace System.Threading.Tasks // Get and null out the antecedent. This is crucial to avoid a memory // leak with long chains of continuations. var antecedent = m_antecedent; - Contract.Assert(antecedent != null, + Debug.Assert(antecedent != null, "No antecedent was set for the ContinuationTaskFromResultTask."); m_antecedent = null; @@ -149,7 +150,7 @@ namespace System.Threading.Tasks antecedent.NotifyDebuggerOfWaitCompletionIfNecessary(); // Invoke the delegate - Contract.Assert(m_action != null); + Debug.Assert(m_action != null); var action = m_action as Action<Task<TAntecedentResult>>; if (action != null) { @@ -162,7 +163,7 @@ namespace System.Threading.Tasks actionWithState(antecedent, m_stateObject); return; } - Contract.Assert(false, "Invalid m_action in ContinuationTaskFromResultTask"); + Debug.Assert(false, "Invalid m_action in ContinuationTaskFromResultTask"); } } @@ -189,7 +190,7 @@ namespace System.Threading.Tasks // Get and null out the antecedent. This is crucial to avoid a memory // leak with long chains of continuations. var antecedent = m_antecedent; - Contract.Assert(antecedent != null, + Debug.Assert(antecedent != null, "No antecedent was set for the ContinuationResultTaskFromResultTask."); m_antecedent = null; @@ -197,7 +198,7 @@ namespace System.Threading.Tasks antecedent.NotifyDebuggerOfWaitCompletionIfNecessary(); // Invoke the delegate - Contract.Assert(m_action != null); + Debug.Assert(m_action != null); var func = m_action as Func<Task<TAntecedentResult>, TResult>; if (func != null) { @@ -210,7 +211,7 @@ namespace System.Threading.Tasks m_result = funcWithState(antecedent, m_stateObject); return; } - Contract.Assert(false, "Invalid m_action in ContinuationResultTaskFromResultTask"); + Debug.Assert(false, "Invalid m_action in ContinuationResultTaskFromResultTask"); } } @@ -235,11 +236,10 @@ namespace System.Threading.Tasks /// <param name="needsProtection"> /// true if we need to protect against multiple threads racing to start/cancel the task; otherwise, false. /// </param> - [SecuritySafeCritical] protected static void InlineIfPossibleOrElseQueue(Task task, bool needsProtection) { Contract.Requires(task != null); - Contract.Assert(task.m_taskScheduler != null); + Debug.Assert(task.m_taskScheduler != null); // Set the TASK_STATE_STARTED flag. This only needs to be done // if the task may be canceled or if someone else has a reference to it @@ -305,7 +305,7 @@ namespace System.Threading.Tasks m_options = options; m_taskScheduler = scheduler; if (AsyncCausalityTracer.LoggingOn) - AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, m_task.Id, "Task.ContinueWith: " + ((Delegate)task.m_action).Method.Name, 0); + AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, m_task.Id, "Task.ContinueWith: " + task.m_action.Method.Name, 0); if (Task.s_asyncDebuggingEnabled) { @@ -318,8 +318,8 @@ namespace System.Threading.Tasks /// <param name="bCanInlineContinuationTask">Whether the continuation can be inlined.</param> internal override void Run(Task completedTask, bool bCanInlineContinuationTask) { - Contract.Assert(completedTask != null); - Contract.Assert(completedTask.IsCompleted, "ContinuationTask.Run(): completedTask not completed"); + Debug.Assert(completedTask != null); + Debug.Assert(completedTask.IsCompleted, "ContinuationTask.Run(): completedTask not completed"); // Check if the completion status of the task works with the desired // activation criteria of the TaskContinuationOptions. @@ -374,7 +374,7 @@ namespace System.Threading.Tasks return m_task.GetDelegateContinuationsForDebugger(); } - return new Delegate[] { m_task.m_action as Delegate }; + return new Delegate[] { m_task.m_action }; } } @@ -384,7 +384,6 @@ namespace System.Threading.Tasks /// <summary>SendOrPostCallback delegate to invoke the action.</summary> private readonly static SendOrPostCallback s_postCallback = state => ((Action)state)(); // can't use InvokeAction as it's SecurityCritical /// <summary>Cached delegate for PostAction</summary> - [SecurityCritical] private static ContextCallback s_postActionCallback; /// <summary>The context with which to run the action.</summary> private readonly SynchronizationContext m_syncContext; @@ -394,19 +393,17 @@ namespace System.Threading.Tasks /// <param name="action">The action to invoke. Must not be null.</param> /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param> /// <param name="stackMark">The captured stack mark.</param> - [SecurityCritical] internal SynchronizationContextAwaitTaskContinuation( SynchronizationContext context, Action action, bool flowExecutionContext, ref StackCrawlMark stackMark) : base(action, flowExecutionContext, ref stackMark) { - Contract.Assert(context != null); + Debug.Assert(context != null); m_syncContext = context; } /// <summary>Inlines or schedules the continuation.</summary> /// <param name="ignored">The antecedent task, which is ignored.</param> /// <param name="canInlineContinuationTask">true if inlining is permitted; otherwise, false.</param> - [SecuritySafeCritical] internal sealed override void Run(Task task, bool canInlineContinuationTask) { // If we're allowed to inline, run the action on this thread. @@ -431,7 +428,6 @@ namespace System.Threading.Tasks /// <summary>Calls InvokeOrPostAction(false) on the supplied SynchronizationContextAwaitTaskContinuation.</summary> /// <param name="state">The SynchronizationContextAwaitTaskContinuation.</param> - [SecurityCritical] private static void PostAction(object state) { var c = (SynchronizationContextAwaitTaskContinuation)state; @@ -465,7 +461,6 @@ namespace System.Threading.Tasks /// to be passed as state. /// </returns> [MethodImpl(MethodImplOptions.AggressiveInlining)] - [SecurityCritical] private static ContextCallback GetPostActionCallback() { ContextCallback callback = s_postActionCallback; @@ -485,12 +480,11 @@ namespace System.Threading.Tasks /// <param name="action">The action to invoke. Must not be null.</param> /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param> /// <param name="stackMark">The captured stack mark.</param> - [SecurityCritical] internal TaskSchedulerAwaitTaskContinuation( TaskScheduler scheduler, Action action, bool flowExecutionContext, ref StackCrawlMark stackMark) : base(action, flowExecutionContext, ref stackMark) { - Contract.Assert(scheduler != null); + Debug.Assert(scheduler != null); m_scheduler = scheduler; } @@ -550,7 +544,6 @@ namespace System.Threading.Tasks /// <param name="action">The action to invoke. Must not be null.</param> /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param> /// <param name="stackMark">The captured stack mark with which to construct an ExecutionContext.</param> - [SecurityCritical] internal AwaitTaskContinuation(Action action, bool flowExecutionContext, ref StackCrawlMark stackMark) { Contract.Requires(action != null); @@ -566,7 +559,6 @@ namespace System.Threading.Tasks /// <summary>Initializes the continuation.</summary> /// <param name="action">The action to invoke. Must not be null.</param> /// <param name="flowExecutionContext">Whether to capture and restore ExecutionContext.</param> - [SecurityCritical] internal AwaitTaskContinuation(Action action, bool flowExecutionContext) { Contract.Requires(action != null); @@ -598,7 +590,6 @@ namespace System.Threading.Tasks /// <summary>Inlines or schedules the continuation onto the default scheduler.</summary> /// <param name="ignored">The antecedent task, which is ignored.</param> /// <param name="canInlineContinuationTask">true if inlining is permitted; otherwise, false.</param> - [SecuritySafeCritical] internal override void Run(Task task, bool canInlineContinuationTask) { // For the base AwaitTaskContinuation, we allow inlining if our caller allows it @@ -657,7 +648,6 @@ namespace System.Threading.Tasks } /// <summary>IThreadPoolWorkItem override, which is the entry function for this when the ThreadPool scheduler decides to run it.</summary> - [SecurityCritical] void ExecuteWorkItemHelper() { var etwLog = TplEtwProvider.Log; @@ -696,7 +686,6 @@ namespace System.Threading.Tasks } } - [SecurityCritical] void IThreadPoolWorkItem.ExecuteWorkItem() { // inline the fast path @@ -714,20 +703,16 @@ namespace System.Threading.Tasks /// <summary> /// The ThreadPool calls this if a ThreadAbortException is thrown while trying to execute this workitem. /// </summary> - [SecurityCritical] void IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae) { /* nop */ } /// <summary>Cached delegate that invokes an Action passed as an object parameter.</summary> - [SecurityCritical] private static ContextCallback s_invokeActionCallback; /// <summary>Runs an action provided as an object parameter.</summary> /// <param name="state">The Action to invoke.</param> - [SecurityCritical] private static void InvokeAction(object state) { ((Action)state)(); } [MethodImpl(MethodImplOptions.AggressiveInlining)] - [SecurityCritical] protected static ContextCallback GetInvokeActionCallback() { ContextCallback callback = s_invokeActionCallback; @@ -739,11 +724,10 @@ namespace System.Threading.Tasks /// <param name="callback">The callback to run.</param> /// <param name="state">The state to pass to the callback.</param> /// <param name="currentTask">A reference to Task.t_currentTask.</param> - [SecurityCritical] protected void RunCallback(ContextCallback callback, object state, ref Task currentTask) { Contract.Requires(callback != null); - Contract.Assert(currentTask == Task.t_currentTask); + Debug.Assert(currentTask == Task.t_currentTask); // Pretend there's no current task, so that no task is seen as a parent // and TaskScheduler.Current does not reflect false information @@ -787,10 +771,9 @@ namespace System.Threading.Tasks /// only happens in Task.SetContinuationForAwait if execution context flow was disabled /// via using TaskAwaiter.UnsafeOnCompleted or a similar path. /// </remarks> - [SecurityCritical] internal static void RunOrScheduleAction(Action action, bool allowInlining, ref Task currentTask) { - Contract.Assert(currentTask == Task.t_currentTask); + Debug.Assert(currentTask == Task.t_currentTask); // If we're not allowed to run here, schedule the action if (!allowInlining || !IsValidLocationForInlining) @@ -818,7 +801,6 @@ namespace System.Threading.Tasks /// <summary>Schedules the action to be executed. No ExecutionContext work is performed used.</summary> /// <param name="action">The action to invoke or queue.</param> - [SecurityCritical] internal static void UnsafeScheduleAction(Action action, Task task) { AwaitTaskContinuation atc = new AwaitTaskContinuation(action, flowExecutionContext: false); @@ -859,7 +841,7 @@ namespace System.Threading.Tasks internal override Delegate[] GetDelegateContinuationsForDebugger() { - Contract.Assert(m_action != null); + Debug.Assert(m_action != null); return new Delegate[] { AsyncMethodBuilderCore.TryGetStateMachineForDebugger(m_action) }; } } |