File: HttpApplication.cs

package info (click to toggle)
mono 6.8.0.105%2Bdfsg-3.3
links: PTS, VCS
area: main
in suites: bookworm
size: 1,284,512 kB
sloc: cs: 11,172,132; xml: 2,850,069; ansic: 671,653; cpp: 122,091; perl: 59,366; javascript: 30,841; asm: 22,168; makefile: 20,093; sh: 15,020; python: 4,827; pascal: 925; sql: 859; sed: 16; php: 1
file content (4473 lines) | stat: -rw-r--r-- 201,432 bytes
parent folder | download | duplicates (6)
//------------------------------------------------------------------------------
// <copyright file="HttpApplication.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Globalization;
    using System.IO;
    using System.Linq;
    using System.Net;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.ExceptionServices;
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting.Messaging;
    using System.Runtime.Serialization.Formatters;
    using System.Security;
    using System.Security.Permissions;
    using System.Security.Principal;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Web;
    using System.Web.Compilation;
    using System.Web.Configuration;
    using System.Web.Configuration.Common;
    using System.Web.Hosting;
    using System.Web.Management;
    using System.Web.Security;
    using System.Web.SessionState;
    using System.Web.UI;
    using System.Web.Util;
    using IIS = System.Web.Hosting.UnsafeIISMethods;


    //
    // Async EventHandler support
    //


    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public delegate IAsyncResult BeginEventHandler(object sender, EventArgs e, AsyncCallback cb, object extraData);

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public delegate void EndEventHandler(IAsyncResult ar);

    // Represents an event handler using TAP (Task Asynchronous Pattern).
    public delegate Task TaskEventHandler(object sender, EventArgs e);


    /// <devdoc>
    ///    <para>
    ///       The  HttpApplication class defines the methods, properties and events common to all
    ///       HttpApplication objects within the ASP.NET Framework.
    ///    </para>
    /// </devdoc>
    [
    ToolboxItem(false)
    ]
    public class HttpApplication : IComponent, IHttpAsyncHandler, IRequestCompletedNotifier, ISyncContext {
        // application state dictionary
        private HttpApplicationState _state;

        // context during init for config lookups
        private HttpContext _initContext;

        // async support
        private HttpAsyncResult _ar; // currently pending async result for call into application

        // list of modules
        private static readonly DynamicModuleRegistry _dynamicModuleRegistry = new DynamicModuleRegistry();
        private HttpModuleCollection  _moduleCollection;

        // event handlers
        private static readonly object EventDisposed = new object();
        private static readonly object EventErrorRecorded = new object();
        private static readonly object EventRequestCompleted = new object();
        private static readonly object EventPreSendRequestHeaders = new object();
        private static readonly object EventPreSendRequestContent = new object();

        private static readonly object EventBeginRequest = new object();
        private static readonly object EventAuthenticateRequest = new object();
        private static readonly object EventDefaultAuthentication = new object();
        private static readonly object EventPostAuthenticateRequest = new object();
        private static readonly object EventAuthorizeRequest = new object();
        private static readonly object EventPostAuthorizeRequest = new object();
        private static readonly object EventResolveRequestCache = new object();
        private static readonly object EventPostResolveRequestCache = new object();
        private static readonly object EventMapRequestHandler = new object();
        private static readonly object EventPostMapRequestHandler = new object();
        private static readonly object EventAcquireRequestState = new object();
        private static readonly object EventPostAcquireRequestState = new object();
        private static readonly object EventPreRequestHandlerExecute = new object();
        private static readonly object EventPostRequestHandlerExecute = new object();
        private static readonly object EventReleaseRequestState = new object();
        private static readonly object EventPostReleaseRequestState = new object();
        private static readonly object EventUpdateRequestCache = new object();
        private static readonly object EventPostUpdateRequestCache = new object();
        private static readonly object EventLogRequest = new object();
        private static readonly object EventPostLogRequest = new object();
        private static readonly object EventEndRequest = new object();
        internal static readonly string AutoCulture = "auto";

        private EventHandlerList _events;
        private AsyncAppEventHandlersTable _asyncEvents;

        // execution steps
        private StepManager _stepManager;

        // callback for Application ResumeSteps
        #pragma warning disable 0649
        private WaitCallback _resumeStepsWaitCallback;
        #pragma warning restore 0649

        // event passed to modules
        private EventArgs _appEvent;

        // list of handler mappings
        private Hashtable _handlerFactories = new Hashtable();

        // list of handler/factory pairs to be recycled
        private ArrayList _handlerRecycleList;

        // flag to hide request and response intrinsics
        private bool _hideRequestResponse;

        // application execution variables
        private HttpContext _context;
        private Exception _lastError;  // placeholder for the error when context not avail
        private bool _timeoutManagerInitialized;

        // session (supplied by session-on-end outside of context)
        private HttpSessionState _session;

        // culture (needs to be set per thread)
        private CultureInfo _appLevelCulture;
        private CultureInfo _appLevelUICulture;
        private CultureInfo _savedAppLevelCulture;
        private CultureInfo _savedAppLevelUICulture;
        private bool _appLevelAutoCulture;
        private bool _appLevelAutoUICulture;

        // pipeline event mappings
        private Dictionary<string, RequestNotification> _pipelineEventMasks;


        // IComponent support
        private ISite _site;

        // IIS7 specific fields
        internal const string MANAGED_PRECONDITION = "managedHandler";
        internal const string IMPLICIT_FILTER_MODULE = "AspNetFilterModule";
        internal const string IMPLICIT_HANDLER = "ManagedPipelineHandler";

        // map modules to their index
        private static Hashtable _moduleIndexMap = new Hashtable();
        private static bool _initSpecialCompleted;

        private bool _initInternalCompleted;
        private RequestNotification _appRequestNotifications;
        private RequestNotification _appPostNotifications;

        // Set the current module init key to the global.asax module to enable
        // the custom global.asax derivation constructor to register event handlers
        private string _currentModuleCollectionKey = HttpApplicationFactory.applicationFileName;

        // module config is read once per app domain and used to initialize the per-instance _moduleContainers array
        private static List<ModuleConfigurationInfo> _moduleConfigInfo;

        // this is the per instance list that contains the events for each module
        private PipelineModuleStepContainer[] _moduleContainers;

        // Byte array to be used by HttpRequest.GetEntireRawContent. Windows OS Bug 1632921
        private byte[] _entityBuffer;

        // Counts the number of code paths consuming this HttpApplication instance. When the counter hits zero,
        // it is safe to release this HttpApplication instance back into the HttpApplication pool.
        // This counter can be null if we're not using the new Task-friendly code paths.
        internal CountdownTask ApplicationInstanceConsumersCounter;

        private IAllocatorProvider _allocator;

        //
        // Public Application properties
        //


        /// <devdoc>
        ///    <para>
        ///          HTTPRuntime provided context object that provides access to additional
        ///          pipeline-module exposed objects.
        ///       </para>
        ///    </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpContext Context {
            get {
                return(_context != null) ? _context : _initContext;
            }
        }

        private bool IsContainerInitalizationAllowed {
            get {
                if (HttpRuntime.UseIntegratedPipeline && _initSpecialCompleted && !_initInternalCompleted) {
                    // return true if
                    //      i) this is integrated pipeline mode,
                    //     ii) InitSpecial has been called at least once in this AppDomain to register events with IIS,
                    //    iii) InitInternal has not been invoked yet or is currently executing
                    return true;
                }
                return false;
            }
        }

        private void ThrowIfEventBindingDisallowed() {
            if (HttpRuntime.UseIntegratedPipeline && _initSpecialCompleted && _initInternalCompleted) {
                // throw if we're using the integrated pipeline and both InitSpecial and InitInternal have completed.
                throw new InvalidOperationException(SR.GetString(SR.Event_Binding_Disallowed));
            }
        }

        private PipelineModuleStepContainer[] ModuleContainers {
            get {
                if (_moduleContainers == null) {

                    Debug.Assert(_moduleIndexMap != null && _moduleIndexMap.Count > 0, "_moduleIndexMap != null && _moduleIndexMap.Count > 0");

                    // At this point, all modules have been registered with IIS via RegisterIntegratedEvent.
                    // Now we need to create a container for each module and add execution steps.
                    // The number of containers is the same as the number of modules that have been
                    // registered (_moduleIndexMap.Count).

                    _moduleContainers = new PipelineModuleStepContainer[_moduleIndexMap.Count];

                    for (int i = 0; i < _moduleContainers.Length; i++) {
                        _moduleContainers[i] = new PipelineModuleStepContainer();
                    }

                }

                return _moduleContainers;
            }
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public event EventHandler Disposed {
            add {
                Events.AddHandler(EventDisposed, value);
            }

            remove {
                Events.RemoveHandler(EventDisposed, value);
            }
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected EventHandlerList Events {
            get {
                if (_events == null) {
                    _events = new EventHandlerList();
                }
                return _events;
            }
        }

        internal IExecutionStep CreateImplicitAsyncPreloadExecutionStep() {
            ImplicitAsyncPreloadModule implicitAsyncPreloadModule = new ImplicitAsyncPreloadModule();
            BeginEventHandler beginHandler = null;
            EndEventHandler endHandler = null;
            implicitAsyncPreloadModule.GetEventHandlers(out beginHandler, out endHandler);
            return new AsyncEventExecutionStep(this, beginHandler, endHandler, null);            
        }

        private AsyncAppEventHandlersTable AsyncEvents {
            get {
                if (_asyncEvents == null)
                    _asyncEvents = new AsyncAppEventHandlersTable();
                return _asyncEvents;
            }
        }

        // Last error during the processing of the current request.
        internal Exception LastError {
            get {
                // only temporaraly public (will be internal and not related context)
                return (_context != null) ? _context.Error : _lastError;
            }

        }

        // Used by HttpRequest.GetEntireRawContent. Windows OS Bug 1632921
        internal byte[] EntityBuffer
        {
            get
            {
                if (_entityBuffer == null)
                {
                    _entityBuffer = new byte[8 * 1024];
                }
                return _entityBuffer;
            }
        }

        // Provides fixed size reusable buffers per request
        // Benefit:
        //   1) Eliminates global locks - access to HttpApplication instance is lock free and no concurrent access is expected (by design).
        //      36+ cores show really bad spin lock characteristics for short locks.
        //   2) Better lifetime dynamics - Buffers increase/decrease as HttpApplication instances grow/shrink on demand.
        internal IAllocatorProvider AllocatorProvider {
            get {
                if (_allocator == null) {
                    AllocatorProvider alloc = new AllocatorProvider();

                    alloc.CharBufferAllocator = new SimpleBufferAllocator<char>(BufferingParams.CHAR_BUFFER_SIZE);
                    alloc.IntBufferAllocator = new SimpleBufferAllocator<int>(BufferingParams.INT_BUFFER_SIZE);
                    alloc.IntPtrBufferAllocator = new SimpleBufferAllocator<IntPtr>(BufferingParams.INTPTR_BUFFER_SIZE);

                    Interlocked.CompareExchange(ref _allocator, alloc, null);
                }

                return _allocator;
            }
        }

        internal void ClearError() {
            _lastError = null;
        }

        /// <devdoc>
        ///    <para>HTTPRuntime provided request intrinsic object that provides access to incoming HTTP
        ///       request data.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpRequest Request {
            get {
                HttpRequest request = null;

                if (_context != null && !_hideRequestResponse)
                    request = _context.Request;

                if (request == null)
                    throw new HttpException(SR.GetString(SR.Request_not_available));

                return request;
            }
        }


        /// <devdoc>
        ///    <para>HTTPRuntime provided
        ///       response intrinsic object that allows transmission of HTTP response data to a
        ///       client.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpResponse Response {
            get {
                HttpResponse response = null;

                if (_context != null && !_hideRequestResponse)
                    response = _context.Response;

                if (response == null)
                    throw new HttpException(SR.GetString(SR.Response_not_available));

                return response;
            }
        }


        /// <devdoc>
        ///    <para>
        ///    HTTPRuntime provided session intrinsic.
        ///    </para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpSessionState Session {
            get {
                HttpSessionState session = null;

                if (_session != null)
                    session = _session;
                else if (_context != null)
                    session = _context.Session;

                if (session == null)
                    throw new HttpException(SR.GetString(SR.Session_not_available));

                return session;
            }
        }


        /// <devdoc>
        ///    <para>
        ///       Returns
        ///          a reference to an HTTPApplication state bag instance.
        ///       </para>
        ///    </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpApplicationState Application {
            get {
                Debug.Assert(_state != null);  // app state always available
                return _state;
            }
        }


        /// <devdoc>
        ///    <para>Provides the web server Intrinsic object.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpServerUtility Server {
            get {
                if (_context != null)
                    return _context.Server;
                else
                    return new HttpServerUtility(this); // special Server for application only
            }
        }


        /// <devdoc>
        ///    <para>Provides the User Intrinsic object.</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public IPrincipal User {
            get {
                if (_context == null)
                    throw new HttpException(SR.GetString(SR.User_not_available));

                return _context.User;
            }
        }


        /// <devdoc>
        ///    <para>
        ///       Collection
        ///          of all IHTTPModules configured for the current application.
        ///       </para>
        ///    </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public HttpModuleCollection Modules {
            [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)]
            get {
                if (_moduleCollection == null)
                    _moduleCollection = new HttpModuleCollection();
                return _moduleCollection;
            }
        }

        // event passed to all modules
        internal EventArgs AppEvent {
            get {
                if (_appEvent == null)
                    _appEvent = EventArgs.Empty;

                return _appEvent;
            }

            set {
                _appEvent = null;
            }
        }

        private ISessionStateModule FindISessionStateModule() {
            if (!HttpRuntime.UseIntegratedPipeline)
                return null;

            if (_moduleCollection != null) {
                for (int i = 0; i < _moduleCollection.Count; i++) {
                    ISessionStateModule module = _moduleCollection.Get(i) as ISessionStateModule;
                    if (module != null) {
                        return module;
                    }
                }
            }

            return null;
        }

        // DevDiv Bugs 151914: Release session state before executing child request
        internal void EnsureReleaseState() {
            ISessionStateModule module = FindISessionStateModule();
            if (module != null) {
                module.ReleaseSessionState(Context);
            }
        }

        internal Task EnsureReleaseStateAsync() {
            ISessionStateModule module = FindISessionStateModule();
            if (module != null) {
                return module.ReleaseSessionStateAsync(Context);
            }

            return TaskAsyncHelper.CompletedTask;
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void CompleteRequest() {
            //
            // Request completion (force skipping all steps until RequestEnd
            //
            _stepManager.CompleteRequest();
        }

        internal bool IsRequestCompleted {
            get {
                if (null == _stepManager) {
                    return false;
                }

                return _stepManager.IsCompleted;
            }
        }

        bool IRequestCompletedNotifier.IsRequestCompleted {
            get {
                return IsRequestCompleted;
            }
        }

        // Dev10 745301: Asynchronous pipeline steps can start a new thread that triggers
        // a SendResponse notification.  E.g., it might call Flush when a module is registered
        // for PreSendRequestHeaders/Content.  If the async pipeline step returns from ExecuteStep
        // while the SendResponse notification is executing, the NotificationContext can 
        // be corrupted.  To fix this, a lock is now taken to prevent multi-threaded access when
        // the async pipeline step sets the NotificationContext.PendingAsyncCompletion field.  
        // The SendResponse notification also acquires the lock when it enters managed code and 
        // releases the lock when it leaves.
        internal void AcquireNotifcationContextLock(ref bool locked) {
            Debug.Assert(HttpRuntime.UseIntegratedPipeline, "HttpRuntime.UseIntegratedPipeline");
            Monitor.Enter(_stepManager, ref locked);
        }

        internal void ReleaseNotifcationContextLock() {
            Debug.Assert(HttpRuntime.UseIntegratedPipeline, "HttpRuntime.UseIntegratedPipeline");
            Monitor.Exit(_stepManager);
        }

        // Some frameworks built on top of the integrated pipeline call Flush() on background thread which will trigger nested 
        // RQ_SEND_RESPONSE notification and replace the old context.NotificationContext with the new context.NotificationContext.
        // In order to maintain proper synchronization logic at the time when the completion callback is called we need to make sure 
        // we access the original context.NotificationContext (and don't touch the nested one).
        // It will make sure that we read the correct NotificationContext
        [MethodImpl(MethodImplOptions.NoInlining)]
        private void GetNotifcationContextPropertiesUnderLock(ref bool isReentry, ref int eventCount) {
            bool locked = false;
            try {
                AcquireNotifcationContextLock(ref locked);
                isReentry = Context.NotificationContext.IsReEntry;
                eventCount = CurrentModuleContainer.GetEventCount(Context.CurrentNotification, Context.IsPostNotification) - 1;
            }
            finally {
                if (locked) {
                    ReleaseNotifcationContextLock();
                }
            }
        }
        
        [MethodImpl(MethodImplOptions.NoInlining)] // Iniling this causes throughtput regression in ResumeStep
        private void GetNotifcationContextProperties(ref bool isReentry, ref int eventCount) {
            // Read optimistically (without lock)
            var nc = Context.NotificationContext;
            isReentry = nc.IsReEntry;
            // We can continue optimistic read only if this is not reentry
            if (!isReentry) {
                eventCount = ModuleContainers[nc.CurrentModuleIndex].GetEventCount(nc.CurrentNotification, nc.IsPostNotification) - 1;
                // Check if the optimistic read was consistent
                if (object.ReferenceEquals(nc, Context.NotificationContext)) {
                    return;
                }
            }
            GetNotifcationContextPropertiesUnderLock(ref isReentry, ref eventCount);
        }

        private void RaiseOnError() {
            EventHandler handler = (EventHandler)Events[EventErrorRecorded];
            if (handler != null) {
                try {
                    handler(this, AppEvent);
                }
                catch (Exception e) {
                    if (_context != null) {
                        _context.AddError(e);
                    }
                }
            }
        }

        private void RaiseOnRequestCompleted() {
            EventHandler handler = (EventHandler)Events[EventRequestCompleted];
            if (handler != null) {
                try {
                    handler(this, AppEvent);
                }
                catch (Exception e) {
                    WebBaseEvent.RaiseRuntimeError(e, this);
                }
            }
        }

        internal void RaiseOnPreSendRequestHeaders() {
            EventHandler handler = (EventHandler)Events[EventPreSendRequestHeaders];
            if (handler != null) {
                try {
                    handler(this, AppEvent);
                }
                catch (Exception e) {
                    RecordError(e);
                }
            }
        }

        internal void RaiseOnPreSendRequestContent() {
            EventHandler handler = (EventHandler)Events[EventPreSendRequestContent];
            if (handler != null) {
                try {
                    handler(this, AppEvent);
                }
                catch (Exception e) {
                    RecordError(e);
                }
            }
        }

        internal HttpAsyncResult AsyncResult {
            get {
                if (HttpRuntime.UseIntegratedPipeline) {
                    return (_context.NotificationContext != null) ? _context.NotificationContext.AsyncResult : null;
                }
                else {
                    return _ar;
                }
            }
            set {
                if (HttpRuntime.UseIntegratedPipeline) {
                    _context.NotificationContext.AsyncResult = value;
                }
                else {
                    _ar = value;
                }
            }
        }

        internal void AddSyncEventHookup(object key, Delegate handler, RequestNotification notification) {
            AddSyncEventHookup(key, handler, notification, false);
        }

        private PipelineModuleStepContainer CurrentModuleContainer { get { return ModuleContainers[_context.CurrentModuleIndex]; } }

        private PipelineModuleStepContainer GetModuleContainer(string moduleName) {
            object value = _moduleIndexMap[moduleName];

            if (value == null) {
                return null;
            }

            int moduleIndex = (int)value;

#if DBG
            Debug.Trace("PipelineRuntime", "GetModuleContainer: moduleName=" + moduleName + ", index=" + moduleIndex.ToString(CultureInfo.InvariantCulture) + "\r\n");
            Debug.Assert(moduleIndex >= 0 && moduleIndex < ModuleContainers.Length, "moduleIndex >= 0 && moduleIndex < ModuleContainers.Length");
#endif

            PipelineModuleStepContainer container = ModuleContainers[moduleIndex];

            Debug.Assert(container != null, "container != null");

            return container;
        }

        private void AddSyncEventHookup(object key, Delegate handler, RequestNotification notification, bool isPostNotification) {
            ThrowIfEventBindingDisallowed();

            // add the event to the delegate invocation list
            // this keeps non-pipeline ASP.NET hosts working
            Events.AddHandler(key, handler);

            // For integrated pipeline mode, add events to the IExecutionStep containers only if
            // InitSpecial has completed and InitInternal has not completed.
            if (IsContainerInitalizationAllowed) {
                // lookup the module index and add this notification
                PipelineModuleStepContainer container = GetModuleContainer(CurrentModuleCollectionKey);
                //WOS 1985878: HttpModule unsubscribing an event handler causes AV in Integrated Mode
                if (container != null) {
#if DBG
                    container.DebugModuleName = CurrentModuleCollectionKey;
#endif
                    SyncEventExecutionStep step = new SyncEventExecutionStep(this, (EventHandler)handler);
                    container.AddEvent(notification, isPostNotification, step);
                }
            }
        }

        internal void RemoveSyncEventHookup(object key, Delegate handler, RequestNotification notification) {
            RemoveSyncEventHookup(key, handler, notification, false);
        }

        internal void RemoveSyncEventHookup(object key, Delegate handler, RequestNotification notification, bool isPostNotification) {
            ThrowIfEventBindingDisallowed();

            Events.RemoveHandler(key, handler);

            if (IsContainerInitalizationAllowed) {
                PipelineModuleStepContainer container = GetModuleContainer(CurrentModuleCollectionKey);
                //WOS 1985878: HttpModule unsubscribing an event handler causes AV in Integrated Mode
                if (container != null) {
                    container.RemoveEvent(notification, isPostNotification, handler);
                }
            }
        }

        private void AddSendResponseEventHookup(object key, Delegate handler) {
            ThrowIfEventBindingDisallowed();

            // add the event to the delegate invocation list
            // this keeps non-pipeline ASP.NET hosts working
            Events.AddHandler(key, handler);

            // For integrated pipeline mode, add events to the IExecutionStep containers only if
            // InitSpecial has completed and InitInternal has not completed.
            if (IsContainerInitalizationAllowed) {
                // lookup the module index and add this notification
                PipelineModuleStepContainer container = GetModuleContainer(CurrentModuleCollectionKey);
                //WOS 1985878: HttpModule unsubscribing an event handler causes AV in Integrated Mode
                if (container != null) {
#if DBG
                    container.DebugModuleName = CurrentModuleCollectionKey;
#endif
                    bool isHeaders = (key == EventPreSendRequestHeaders);
                    SendResponseExecutionStep step = new SendResponseExecutionStep(this, (EventHandler)handler, isHeaders);
                    container.AddEvent(RequestNotification.SendResponse, false /*isPostNotification*/, step);
                }
            }
        }

        private void RemoveSendResponseEventHookup(object key, Delegate handler) {
            ThrowIfEventBindingDisallowed();

            Events.RemoveHandler(key, handler);

            if (IsContainerInitalizationAllowed) {
                PipelineModuleStepContainer container = GetModuleContainer(CurrentModuleCollectionKey);
                //WOS 1985878: HttpModule unsubscribing an event handler causes AV in Integrated Mode
                if (container != null) {
                    container.RemoveEvent(RequestNotification.SendResponse, false /*isPostNotification*/, handler);
                }
            }
        }

        //
        // Sync event hookup
        //


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler BeginRequest {
            add { AddSyncEventHookup(EventBeginRequest, value, RequestNotification.BeginRequest); }
            remove { RemoveSyncEventHookup(EventBeginRequest, value, RequestNotification.BeginRequest); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler AuthenticateRequest {
            add { AddSyncEventHookup(EventAuthenticateRequest, value, RequestNotification.AuthenticateRequest); }
            remove { RemoveSyncEventHookup(EventAuthenticateRequest, value, RequestNotification.AuthenticateRequest); }
        }

        // internal - for back-stop module only
        internal event EventHandler DefaultAuthentication {
            add { AddSyncEventHookup(EventDefaultAuthentication, value, RequestNotification.AuthenticateRequest); }
            remove { RemoveSyncEventHookup(EventDefaultAuthentication, value, RequestNotification.AuthenticateRequest); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostAuthenticateRequest {
            add { AddSyncEventHookup(EventPostAuthenticateRequest, value, RequestNotification.AuthenticateRequest, true); }
            remove { RemoveSyncEventHookup(EventPostAuthenticateRequest, value, RequestNotification.AuthenticateRequest, true); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler AuthorizeRequest {
            add { AddSyncEventHookup(EventAuthorizeRequest, value, RequestNotification.AuthorizeRequest); }
            remove { RemoveSyncEventHookup(EventAuthorizeRequest, value, RequestNotification.AuthorizeRequest); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostAuthorizeRequest {
            add { AddSyncEventHookup(EventPostAuthorizeRequest, value, RequestNotification.AuthorizeRequest, true); }
            remove { RemoveSyncEventHookup(EventPostAuthorizeRequest, value, RequestNotification.AuthorizeRequest, true); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler ResolveRequestCache {
            add { AddSyncEventHookup(EventResolveRequestCache, value, RequestNotification.ResolveRequestCache); }
            remove { RemoveSyncEventHookup(EventResolveRequestCache, value, RequestNotification.ResolveRequestCache); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostResolveRequestCache {
            add { AddSyncEventHookup(EventPostResolveRequestCache, value, RequestNotification.ResolveRequestCache, true); }
            remove { RemoveSyncEventHookup(EventPostResolveRequestCache, value, RequestNotification.ResolveRequestCache, true); }
        }

        public event EventHandler MapRequestHandler {
            add {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                AddSyncEventHookup(EventMapRequestHandler, value, RequestNotification.MapRequestHandler);
            }
            remove {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                RemoveSyncEventHookup(EventMapRequestHandler, value, RequestNotification.MapRequestHandler);
            }
        }

        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostMapRequestHandler {
            add { AddSyncEventHookup(EventPostMapRequestHandler, value, RequestNotification.MapRequestHandler, true); }
            remove { RemoveSyncEventHookup(EventPostMapRequestHandler, value, RequestNotification.MapRequestHandler); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler AcquireRequestState {
            add { AddSyncEventHookup(EventAcquireRequestState, value, RequestNotification.AcquireRequestState); }
            remove { RemoveSyncEventHookup(EventAcquireRequestState, value, RequestNotification.AcquireRequestState); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostAcquireRequestState {
            add { AddSyncEventHookup(EventPostAcquireRequestState, value, RequestNotification.AcquireRequestState, true); }
            remove { RemoveSyncEventHookup(EventPostAcquireRequestState, value, RequestNotification.AcquireRequestState, true); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PreRequestHandlerExecute {
            add { AddSyncEventHookup(EventPreRequestHandlerExecute, value, RequestNotification.PreExecuteRequestHandler); }
            remove { RemoveSyncEventHookup(EventPreRequestHandlerExecute, value, RequestNotification.PreExecuteRequestHandler); }
        }

        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostRequestHandlerExecute {
            add { AddSyncEventHookup(EventPostRequestHandlerExecute, value, RequestNotification.ExecuteRequestHandler, true); }
            remove { RemoveSyncEventHookup(EventPostRequestHandlerExecute, value, RequestNotification.ExecuteRequestHandler, true); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler ReleaseRequestState {
            add { AddSyncEventHookup(EventReleaseRequestState, value, RequestNotification.ReleaseRequestState ); }
            remove { RemoveSyncEventHookup(EventReleaseRequestState, value, RequestNotification.ReleaseRequestState); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostReleaseRequestState {
            add { AddSyncEventHookup(EventPostReleaseRequestState, value, RequestNotification.ReleaseRequestState, true); }
            remove { RemoveSyncEventHookup(EventPostReleaseRequestState, value, RequestNotification.ReleaseRequestState, true); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler UpdateRequestCache {
            add { AddSyncEventHookup(EventUpdateRequestCache, value, RequestNotification.UpdateRequestCache); }
            remove { RemoveSyncEventHookup(EventUpdateRequestCache, value, RequestNotification.UpdateRequestCache); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PostUpdateRequestCache {
            add { AddSyncEventHookup(EventPostUpdateRequestCache, value, RequestNotification.UpdateRequestCache, true); }
            remove { RemoveSyncEventHookup(EventPostUpdateRequestCache, value, RequestNotification.UpdateRequestCache, true); }
        }

        public event EventHandler LogRequest {
            add {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                AddSyncEventHookup(EventLogRequest, value, RequestNotification.LogRequest);
            }
            remove {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                RemoveSyncEventHookup(EventLogRequest, value, RequestNotification.LogRequest);
            }
        }

        public event EventHandler PostLogRequest {
            add {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                AddSyncEventHookup(EventPostLogRequest, value, RequestNotification.LogRequest, true);
            }
            remove {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                RemoveSyncEventHookup(EventPostLogRequest, value, RequestNotification.LogRequest, true);
            }
        }

        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler EndRequest {
            add { AddSyncEventHookup(EventEndRequest, value, RequestNotification.EndRequest); }
            remove { RemoveSyncEventHookup(EventEndRequest, value, RequestNotification.EndRequest); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler Error {
            add { Events.AddHandler(EventErrorRecorded, value); }
            remove { Events.RemoveHandler(EventErrorRecorded, value); }
        }


        // Dev10 902404: a new HttpApplication.RequestCompleted event raised when the managed objects associated with 
        // the request are being released.  It allows modules to cleanup resources after all managed modules and handlers
        // have executed.  This may occur before the native processing of the request has completed; for example, before 
        // the final response bytes have been sent to the client.  The HttpContext is not available during this event 
        // because it has already been released.
        public event EventHandler RequestCompleted {
            add { Events.AddHandler(EventRequestCompleted, value); }
            remove { Events.RemoveHandler(EventRequestCompleted, value); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PreSendRequestHeaders {
            add { AddSendResponseEventHookup(EventPreSendRequestHeaders, value); }
            remove { RemoveSendResponseEventHookup(EventPreSendRequestHeaders, value); }
        }


        /// <devdoc><para>[To be supplied.]</para></devdoc>
        public event EventHandler PreSendRequestContent {
            add { AddSendResponseEventHookup(EventPreSendRequestContent, value); }
            remove { RemoveSendResponseEventHookup(EventPreSendRequestContent, value); }
        }

        //
        // Async event hookup
        //

        public void AddOnBeginRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnBeginRequestAsync(bh, eh, null);
        }

        public void AddOnBeginRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventBeginRequest, beginHandler, endHandler, state, RequestNotification.BeginRequest, false, this);
        }

        public void AddOnAuthenticateRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnAuthenticateRequestAsync(bh, eh, null);
        }

        public void AddOnAuthenticateRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventAuthenticateRequest, beginHandler, endHandler, state,
                                   RequestNotification.AuthenticateRequest, false, this);
        }

        public void AddOnPostAuthenticateRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostAuthenticateRequestAsync(bh, eh, null);
        }

        public void AddOnPostAuthenticateRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostAuthenticateRequest, beginHandler, endHandler, state,
                                   RequestNotification.AuthenticateRequest, true, this);
        }

        public void AddOnAuthorizeRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnAuthorizeRequestAsync(bh, eh, null);
        }

        public void AddOnAuthorizeRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventAuthorizeRequest, beginHandler, endHandler, state,
                                   RequestNotification.AuthorizeRequest, false, this);
        }

        public void AddOnPostAuthorizeRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostAuthorizeRequestAsync(bh, eh, null);
        }

        public void AddOnPostAuthorizeRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostAuthorizeRequest, beginHandler, endHandler, state,
                                   RequestNotification.AuthorizeRequest, true, this);
        }

        public void AddOnResolveRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnResolveRequestCacheAsync(bh, eh, null);
        }

        public void AddOnResolveRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventResolveRequestCache, beginHandler, endHandler, state,
                                   RequestNotification.ResolveRequestCache, false, this);
        }

        public void AddOnPostResolveRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostResolveRequestCacheAsync(bh, eh, null);
        }

        public void AddOnPostResolveRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostResolveRequestCache, beginHandler, endHandler, state,
                                   RequestNotification.ResolveRequestCache, true, this);
        }

        public void AddOnMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh) {
            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }
            AddOnMapRequestHandlerAsync(bh, eh, null);
        }

        public void AddOnMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }
            AsyncEvents.AddHandler(EventMapRequestHandler, beginHandler, endHandler, state,
                                   RequestNotification.MapRequestHandler, false, this);
        }

        public void AddOnPostMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostMapRequestHandlerAsync(bh, eh, null);
        }

        public void AddOnPostMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostMapRequestHandler, beginHandler, endHandler, state,
                                   RequestNotification.MapRequestHandler, true, this);
        }

        public void AddOnAcquireRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnAcquireRequestStateAsync(bh, eh, null);
        }

        public void AddOnAcquireRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventAcquireRequestState, beginHandler, endHandler, state,
                                   RequestNotification.AcquireRequestState, false, this);
        }

        public void AddOnPostAcquireRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostAcquireRequestStateAsync(bh, eh, null);
        }

        public void AddOnPostAcquireRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostAcquireRequestState, beginHandler, endHandler, state,
                                   RequestNotification.AcquireRequestState, true, this);
        }

        public void AddOnPreRequestHandlerExecuteAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPreRequestHandlerExecuteAsync(bh, eh, null);
        }

        public void AddOnPreRequestHandlerExecuteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPreRequestHandlerExecute, beginHandler, endHandler, state,
                                   RequestNotification.PreExecuteRequestHandler, false, this);
        }

        public void AddOnPostRequestHandlerExecuteAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostRequestHandlerExecuteAsync(bh, eh, null);
        }

        public void AddOnPostRequestHandlerExecuteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostRequestHandlerExecute, beginHandler, endHandler, state,
                                   RequestNotification.ExecuteRequestHandler, true, this);
        }

        public void AddOnReleaseRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnReleaseRequestStateAsync(bh, eh, null);
        }

        public void AddOnReleaseRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventReleaseRequestState, beginHandler, endHandler, state,
                                   RequestNotification.ReleaseRequestState, false, this);
        }

        public void AddOnPostReleaseRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostReleaseRequestStateAsync(bh, eh, null);
        }

        public void AddOnPostReleaseRequestStateAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostReleaseRequestState, beginHandler, endHandler, state,
                                   RequestNotification.ReleaseRequestState, true, this);
        }

        public void AddOnUpdateRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnUpdateRequestCacheAsync(bh, eh, null);
        }

        public void AddOnUpdateRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventUpdateRequestCache, beginHandler, endHandler, state,
                                   RequestNotification.UpdateRequestCache , false, this);
        }

        public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnPostUpdateRequestCacheAsync(bh, eh, null);
        }

        public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventPostUpdateRequestCache, beginHandler, endHandler, state,
                                   RequestNotification.UpdateRequestCache , true, this);
        }

        public void AddOnLogRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }
            AddOnLogRequestAsync(bh, eh, null);
        }

        public void AddOnLogRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }
            AsyncEvents.AddHandler(EventLogRequest, beginHandler, endHandler, state,
                                   RequestNotification.LogRequest, false, this);
        }

        public void AddOnPostLogRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }
            AddOnPostLogRequestAsync(bh, eh, null);
        }

        public void AddOnPostLogRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }
            AsyncEvents.AddHandler(EventPostLogRequest, beginHandler, endHandler, state,
                                   RequestNotification.LogRequest, true, this);
        }

        public void AddOnEndRequestAsync(BeginEventHandler bh, EndEventHandler eh) {
            AddOnEndRequestAsync(bh, eh, null);
        }

        public void AddOnEndRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            AsyncEvents.AddHandler(EventEndRequest, beginHandler, endHandler, state,
                                   RequestNotification.EndRequest, false, this);
        }

        //
        // Public Application virtual methods
        //


        /// <devdoc>
        ///    <para>
        ///       Used
        ///          to initialize a HttpModule?s instance variables, and to wireup event handlers to
        ///          the hosting HttpApplication.
        ///       </para>
        ///    </devdoc>
        public virtual void Init() {
            // derived class implements this
        }


        /// <devdoc>
        ///    <para>
        ///       Used
        ///          to clean up an HttpModule?s instance variables
        ///       </para>
        ///    </devdoc>
        public virtual void Dispose() {
            // also part of IComponent
            // derived class implements this
            _site = null;
            if (_events != null) {
                try {
                    EventHandler handler = (EventHandler)_events[EventDisposed];
                    if (handler != null)
                        handler(this, EventArgs.Empty);
                }
                finally {
                    _events.Dispose();
                }
            }
        }

        [SecurityPermission(SecurityAction.Assert, ControlPrincipal = true)]
        internal static void SetCurrentPrincipalWithAssert(IPrincipal user) {
            Thread.CurrentPrincipal = user;
        }

        [SecurityPermission(SecurityAction.Assert, ControlPrincipal = true)]
        internal static WindowsIdentity GetCurrentWindowsIdentityWithAssert() {
            return WindowsIdentity.GetCurrent();
        }

        private HttpHandlerAction GetHandlerMapping(HttpContext context, String requestType, VirtualPath path, bool useAppConfig) {
            CachedPathData pathData = null;
            HandlerMappingMemo memo = null;
            HttpHandlerAction mapping = null;

            // Check if cached handler could be used
            if (!useAppConfig) {
                // Grab mapping from cache - verify that the verb matches exactly
                pathData = context.GetPathData(path);
                memo = pathData.CachedHandler;

                // Invalidate cache on missmatch
                if (memo != null && !memo.IsMatch(requestType, path)) {
                    memo = null;
                }
            }

            // Get new mapping
            if (memo == null) {
                // Load from config
                HttpHandlersSection map = useAppConfig ? RuntimeConfig.GetAppConfig().HttpHandlers
                                                       : RuntimeConfig.GetConfig(context).HttpHandlers;
                mapping = map.FindMapping(requestType, path);

                // Add cache entry
                if (!useAppConfig) {
                    memo = new HandlerMappingMemo(mapping, requestType, path);
                    pathData.CachedHandler = memo;
                }
            }
            else {
                // Get mapping from the cache
                mapping = memo.Mapping;
            }

            return mapping;
        }

        internal IHttpHandler MapIntegratedHttpHandler(HttpContext context, String requestType, VirtualPath path, String pathTranslated, bool useAppConfig, bool convertNativeStaticFileModule) {
            IHttpHandler handler = null;

            using (new ApplicationImpersonationContext()) {
                string type;

                // vpath is a non-relative virtual path
                string vpath = path.VirtualPathString;

                // If we're using app config, modify vpath by appending the path after the last slash
                // to the app's virtual path.  This will force IIS IHttpContext::MapHandler to use app configuration.
                if (useAppConfig) {
                    int index = vpath.LastIndexOf('/');
                    index++;
                    if (index != 0 && index < vpath.Length) {
                        vpath = UrlPath.SimpleCombine(HttpRuntime.AppDomainAppVirtualPathString, vpath.Substring(index));
                    }
                    else {
                        vpath = HttpRuntime.AppDomainAppVirtualPathString;
                    }
                }


                IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
                type = wr.MapHandlerAndGetHandlerTypeString(method: requestType, path: vpath, convertNativeStaticFileModule: convertNativeStaticFileModule, ignoreWildcardMappings: false);

                // If a page developer has removed the default mappings with <handlers><clear>
                // without replacing them then we need to give a more descriptive error than
                // a null parameter exception.
                if (type == null) {
                    PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_NOT_FOUND);
                    PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_FAILED);
                    throw new HttpException(SR.GetString(SR.Http_handler_not_found_for_request_type, requestType));
                }

                // if it's a native type, don't go any further
                if(String.IsNullOrEmpty(type)) {
                    return handler;
                }

                // Get factory from the mapping
                IHttpHandlerFactory factory = GetFactory(type);

                try {
                    handler = factory.GetHandler(context, requestType, path.VirtualPathString, pathTranslated);
                }
                catch (FileNotFoundException e) {
                    if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                        throw new HttpException(404, null, e);
                    else
                        throw new HttpException(404, null);
                }
                catch (DirectoryNotFoundException e) {
                    if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                        throw new HttpException(404, null, e);
                    else
                        throw new HttpException(404, null);
                }
                catch (PathTooLongException e) {
                    if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                        throw new HttpException(414, null, e);
                    else
                        throw new HttpException(414, null);
                }

                // Remember for recycling
                if (_handlerRecycleList == null)
                    _handlerRecycleList = new ArrayList();
                _handlerRecycleList.Add(new HandlerWithFactory(handler, factory));
            }

            return handler;
        }

        internal IHttpHandler MapHttpHandler(HttpContext context, String requestType, VirtualPath path, String pathTranslated, bool useAppConfig) {
            // Don't use remap handler when HttpServerUtility.Execute called
            IHttpHandler handler = (context.ServerExecuteDepth == 0) ? context.RemapHandlerInstance : null;

            using (new ApplicationImpersonationContext()) {
                // Use remap handler if possible
                if (handler != null){
                    return handler;
                }

                // Map new handler
                HttpHandlerAction mapping = GetHandlerMapping(context, requestType, path, useAppConfig);

                // If a page developer has removed the default mappings with <httpHandlers><clear>
                // without replacing them then we need to give a more descriptive error than
                // a null parameter exception.
                if (mapping == null) {
                    PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_NOT_FOUND);
                    PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_FAILED);
                    throw new HttpException(SR.GetString(SR.Http_handler_not_found_for_request_type, requestType));
                }

                // Get factory from the mapping
                IHttpHandlerFactory factory = GetFactory(mapping);


                // Get factory from the mapping
                try {
                    // Check if it supports the more efficient GetHandler call that can avoid
                    // a VirtualPath object creation.
                    IHttpHandlerFactory2 factory2 = factory as IHttpHandlerFactory2;

                    if (factory2 != null) {
                        handler = factory2.GetHandler(context, requestType, path, pathTranslated);
                    }
                    else {
                        handler = factory.GetHandler(context, requestType, path.VirtualPathString, pathTranslated);
                    }
                }
                catch (FileNotFoundException e) {
                    if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                        throw new HttpException(404, null, e);
                    else
                        throw new HttpException(404, null);
                }
                catch (DirectoryNotFoundException e) {
                    if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                        throw new HttpException(404, null, e);
                    else
                        throw new HttpException(404, null);
                }
                catch (PathTooLongException e) {
                    if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                        throw new HttpException(414, null, e);
                    else
                        throw new HttpException(414, null);
                }

                // Remember for recycling
                if (_handlerRecycleList == null)
                    _handlerRecycleList = new ArrayList();
                _handlerRecycleList.Add(new HandlerWithFactory(handler, factory));
            }

            return handler;
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public virtual string GetVaryByCustomString(HttpContext context, string custom) {

            if (StringUtil.EqualsIgnoreCase(custom, "browser")) {
                return context.Request.Browser.Type;
            }

            return null;
        }

        public virtual string GetOutputCacheProviderName(HttpContext context) {
            // default implementation
            return System.Web.Caching.OutputCache.DefaultProviderName;
        }

        //
        // IComponent implementation
        //


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public ISite Site {
            get { return _site;}
            set { _site = value;}
        }

        //
        // IHttpAsyncHandler implementation
        //


        /// <internalonly/>
        IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData) {
            HttpAsyncResult result;

            // Setup the asynchronous stuff and application variables
            _context = context;
            _context.ApplicationInstance = this;

            _stepManager.InitRequest();

            // Make sure the context stays rooted (including all async operations)
            _context.Root();

            // Create the async result
            result = new HttpAsyncResult(cb, extraData);

            // Remember the async result for use in async completions
            AsyncResult = result;

            if (_context.TraceIsEnabled)
                HttpRuntime.Profile.StartRequest(_context);

            // Start the application
            ResumeSteps(null);

            // Return the async result
            return result;
        }


        /// <internalonly/>
        void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result) {
            // throw error caught during execution
            HttpAsyncResult ar = (HttpAsyncResult)result;
            if (ar.Error != null)
                throw ar.Error;
        }

        //
        // IHttpHandler implementation
        //


        /// <internalonly/>
        void IHttpHandler.ProcessRequest(HttpContext context) {
            throw new HttpException(SR.GetString(SR.Sync_not_supported));
        }


        /// <internalonly/>
        bool IHttpHandler.IsReusable {
            get { return true; }
        }

        //
        // Support for external calls into the application like app_onStart
        //

        [ReflectionPermission(SecurityAction.Assert, Flags=ReflectionPermissionFlag.RestrictedMemberAccess)]
        private void InvokeMethodWithAssert(MethodInfo method, int paramCount, object eventSource, EventArgs eventArgs) {
            if (paramCount == 0) {
                method.Invoke(this, new Object[0]);
            }
            else {
                Debug.Assert(paramCount == 2);

                method.Invoke(this, new Object[2] { eventSource, eventArgs });
            }
        }

        internal void ProcessSpecialRequest(HttpContext context,
                                            MethodInfo method,
                                            int paramCount,
                                            Object eventSource,
                                            EventArgs eventArgs,
                                            HttpSessionState session) {
            _context = context;
            if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                _context.HideRequestResponse = true;
            }
            _hideRequestResponse = true;
            _session = session;
            _lastError = null;

            using (new DisposableHttpContextWrapper(context)) {
                using (new ApplicationImpersonationContext()) {
                    try {
                        // set culture on the current thread
                        SetAppLevelCulture();
                        InvokeMethodWithAssert(method, paramCount, eventSource, eventArgs);
                    }
                    catch (Exception e) {
                        // dereference reflection invocation exceptions
                        Exception eActual;
                        if (e is TargetInvocationException)
                            eActual = e.InnerException;
                        else
                            eActual = e;

                        RecordError(eActual);

                        if (context == null) {
                            try {
                                WebBaseEvent.RaiseRuntimeError(eActual, this);
                            }
                            catch {
                            }
                        }

                    }
                    finally {

                        // this thread should not be locking app state
                        if (_state != null)
                            _state.EnsureUnLock();

                        // restore culture
                        RestoreAppLevelCulture();

                        if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                            _context.HideRequestResponse = false;
                        }
                        _hideRequestResponse = false;
                        _context = null;
                        _session = null;
                        _lastError = null;
                        _appEvent = null;
                    }
                }
            }
        }

        //
        // Report context-less error
        //

        internal void RaiseErrorWithoutContext(Exception error) {
            try {
                try {
                    SetAppLevelCulture();
                    _lastError = error;

                    RaiseOnError();
                }
                finally {
                    // this thread should not be locking app state
                    if (_state != null)
                        _state.EnsureUnLock();

                    RestoreAppLevelCulture();
                    _lastError = null;
                    _appEvent = null;
                }
            }
            catch { // Protect against exception filters
                throw;
            }
        }

        //
        //
        //

        internal void InitInternal(HttpContext context, HttpApplicationState state, MethodInfo[] handlers) {
            Debug.Assert(context != null, "context != null");

            // Remember state
            _state = state;

            PerfCounters.IncrementCounter(AppPerfCounter.PIPELINES);

            try {
                try {
                    // Remember context for config lookups
                    _initContext = context;
                    _initContext.ApplicationInstance = this;

                    // Set config path to be application path for the application initialization
                    context.ConfigurationPath = context.Request.ApplicationPathObject;

                    // keep HttpContext.Current working while running user code
                    using (new DisposableHttpContextWrapper(context)) {

                        // Build module list from config
                        if (HttpRuntime.UseIntegratedPipeline) {

                            Debug.Assert(_moduleConfigInfo != null, "_moduleConfigInfo != null");
                            Debug.Assert(_moduleConfigInfo.Count >= 0, "_moduleConfigInfo.Count >= 0");

                            try {
                                context.HideRequestResponse = true;
                                _hideRequestResponse = true;
                                InitIntegratedModules();
                            }
                            finally {
                                context.HideRequestResponse = false;
                                _hideRequestResponse = false;
                            }
                        }
                        else {
                            InitModules();

                            // this is used exclusively for integrated mode
                            Debug.Assert(null == _moduleContainers, "null == _moduleContainers");
                        }

                        // Hookup event handlers via reflection
                        if (handlers != null)
                            HookupEventHandlersForApplicationAndModules(handlers);

                        // Initialization of the derived class
                        _context = context;
                        if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                            _context.HideRequestResponse = true;
                        }
                        _hideRequestResponse = true;

                        try {
                            Init();
                        }
                        catch (Exception e) {
                            RecordError(e);
                        }
                    }

                    if (HttpRuntime.UseIntegratedPipeline && _context != null) {
                        _context.HideRequestResponse = false;
                    }
                    _hideRequestResponse = false;
                    _context = null;
                    _resumeStepsWaitCallback= new WaitCallback(this.ResumeStepsWaitCallback);

                    // Construct the execution steps array
                    if (HttpRuntime.UseIntegratedPipeline) {
                        _stepManager = new PipelineStepManager(this);
                    }
                    else {
                        _stepManager = new ApplicationStepManager(this);
                    }

                    _stepManager.BuildSteps(_resumeStepsWaitCallback);
                }
                finally {
                    _initInternalCompleted = true;

                    // Reset config path
                    context.ConfigurationPath = null;

                    // don't hold on to the context
                    _initContext.ApplicationInstance = null;
                    _initContext = null;
                }
            }
            catch { // Protect against exception filters
                throw;
            }
        }

        // helper to expand an event handler into application steps
        private void CreateEventExecutionSteps(Object eventIndex, ArrayList steps) {
            // async
            AsyncAppEventHandler asyncHandler = AsyncEvents[eventIndex];

            if (asyncHandler != null) {
                asyncHandler.CreateExecutionSteps(this, steps);
            }

            // sync
            EventHandler handler = (EventHandler)Events[eventIndex];

            if (handler != null) {
                Delegate[] handlers = handler.GetInvocationList();

                for (int i = 0; i < handlers.Length; i++)  {
                    steps.Add(new SyncEventExecutionStep(this, (EventHandler)handlers[i]));
                }
            }
        }

        internal void InitSpecial(HttpApplicationState state, MethodInfo[] handlers, IntPtr appContext, HttpContext context) {
            // Remember state
            _state = state;

            try {
                //  Remember the context for the initialization
                if (context != null) {
                    _initContext = context;
                    _initContext.ApplicationInstance = this;
                }

                // if we're doing integrated pipeline wireup, then appContext is non-null and we need to init modules and register event subscriptions with IIS
                if (appContext != IntPtr.Zero) {
                    // 1694356: app_offline.htm and <httpRuntime enabled=/> require that we make this check here for integrated mode
                    using (new ApplicationImpersonationContext()) {
                        HttpRuntime.CheckApplicationEnabled();
                    }

                    // retrieve app level culture
                    InitAppLevelCulture();

                    Debug.Trace("PipelineRuntime", "InitSpecial for " + appContext.ToString() + "\n");
                    RegisterEventSubscriptionsWithIIS(appContext, context, handlers);
                }
                else {
                    // retrieve app level culture
                    InitAppLevelCulture();

                    // Hookup event handlers via reflection
                    if (handlers != null) {
                        HookupEventHandlersForApplicationAndModules(handlers);
                    }
                }

                // if we're doing integrated pipeline wireup, then appContext is non-null and we need to register the application (global.asax) event handlers
                if (appContext != IntPtr.Zero) {
                    if (_appPostNotifications != 0 || _appRequestNotifications != 0) {
                        RegisterIntegratedEvent(appContext,
                                                HttpApplicationFactory.applicationFileName,
                                                _appRequestNotifications,
                                                _appPostNotifications,
                                                this.GetType().FullName,
                                                MANAGED_PRECONDITION,
                                                false);
                    }
                }
            }
            finally  {
                _initSpecialCompleted = true;

                //  Do not hold on to the context
                if (_initContext != null) {
                    _initContext.ApplicationInstance = null;
                    _initContext = null;
                }
            }
        }

        internal void DisposeInternal() {
            PerfCounters.DecrementCounter(AppPerfCounter.PIPELINES);

            // call derived class

            try {
                Dispose();
            }
            catch (Exception e) {
                RecordError(e);
            }

            // dispose modules

            if (_moduleCollection != null) {
                int numModules = _moduleCollection.Count;

                for (int i = 0; i < numModules; i++) {
                    try {
                        // set the init key during Dispose for modules
                        // that try to unregister events
                        if (HttpRuntime.UseIntegratedPipeline) {
                            _currentModuleCollectionKey = _moduleCollection.GetKey(i);
                        }
                        _moduleCollection[i].Dispose();
                    }
                    catch {
                    }
                }

                _moduleCollection = null;
            }

            // Release buffers
            if (_allocator != null) {
                _allocator.TrimMemory();
            }
        }

        private void BuildEventMaskDictionary(Dictionary<string, RequestNotification> eventMask) {
            eventMask["BeginRequest"]              = RequestNotification.BeginRequest;
            eventMask["AuthenticateRequest"]       = RequestNotification.AuthenticateRequest;
            eventMask["PostAuthenticateRequest"]   = RequestNotification.AuthenticateRequest;
            eventMask["AuthorizeRequest"]          = RequestNotification.AuthorizeRequest;
            eventMask["PostAuthorizeRequest"]      = RequestNotification.AuthorizeRequest;
            eventMask["ResolveRequestCache"]       = RequestNotification.ResolveRequestCache;
            eventMask["PostResolveRequestCache"]   = RequestNotification.ResolveRequestCache;
            eventMask["MapRequestHandler"]         = RequestNotification.MapRequestHandler;
            eventMask["PostMapRequestHandler"]     = RequestNotification.MapRequestHandler;
            eventMask["AcquireRequestState"]       = RequestNotification.AcquireRequestState;
            eventMask["PostAcquireRequestState"]   = RequestNotification.AcquireRequestState;
            eventMask["PreRequestHandlerExecute"]  = RequestNotification.PreExecuteRequestHandler;
            eventMask["PostRequestHandlerExecute"] = RequestNotification.ExecuteRequestHandler;
            eventMask["ReleaseRequestState"]       = RequestNotification.ReleaseRequestState;
            eventMask["PostReleaseRequestState"]   = RequestNotification.ReleaseRequestState;
            eventMask["UpdateRequestCache"]        = RequestNotification.UpdateRequestCache;
            eventMask["PostUpdateRequestCache"]    = RequestNotification.UpdateRequestCache;
            eventMask["LogRequest"]                = RequestNotification.LogRequest;
            eventMask["PostLogRequest"]            = RequestNotification.LogRequest;
            eventMask["EndRequest"]                = RequestNotification.EndRequest;
            eventMask["PreSendRequestHeaders"]     = RequestNotification.SendResponse;
            eventMask["PreSendRequestContent"]     = RequestNotification.SendResponse;
        }

        private void HookupEventHandlersForApplicationAndModules(MethodInfo[] handlers) {
            _currentModuleCollectionKey = HttpApplicationFactory.applicationFileName;

            if(null == _pipelineEventMasks) {
                Dictionary<string, RequestNotification> dict = new Dictionary<string, RequestNotification>();
                BuildEventMaskDictionary(dict);
                if(null == _pipelineEventMasks) {
                    _pipelineEventMasks = dict;
                }
            }


            for (int i = 0; i < handlers.Length; i++) {
                MethodInfo appMethod = handlers[i];
                String appMethodName = appMethod.Name;
                int namePosIndex = appMethodName.IndexOf('_');
                String targetName = appMethodName.Substring(0, namePosIndex);

                // Find target for method
                Object target = null;

                if (StringUtil.EqualsIgnoreCase(targetName, "Application"))
                    target = this;
                else if (_moduleCollection != null)
                    target = _moduleCollection[targetName];

                if (target == null)
                    continue;

                // Find event on the module type
                Type targetType = target.GetType();
                EventDescriptorCollection events = TypeDescriptor.GetEvents(targetType);
                string eventName = appMethodName.Substring(namePosIndex+1);

                EventDescriptor foundEvent = events.Find(eventName, true);
                if (foundEvent == null
                    && StringUtil.EqualsIgnoreCase(eventName.Substring(0, 2), "on")) {

                    eventName = eventName.Substring(2);
                    foundEvent = events.Find(eventName, true);
                }

                MethodInfo addMethod = null;
                if (foundEvent != null) {
                    EventInfo reflectionEvent = targetType.GetEvent(foundEvent.Name);
                    Debug.Assert(reflectionEvent != null);
                    if (reflectionEvent != null) {
                        addMethod = reflectionEvent.GetAddMethod();
                    }
                }

                if (addMethod == null)
                    continue;

                ParameterInfo[] addMethodParams = addMethod.GetParameters();

                if (addMethodParams.Length != 1)
                    continue;

                // Create the delegate from app method to pass to AddXXX(handler) method

                Delegate handlerDelegate = null;

                ParameterInfo[] appMethodParams = appMethod.GetParameters();

                if (appMethodParams.Length == 0) {
                    // If the app method doesn't have arguments --
                    // -- hookup via intermidiate handler

                    // only can do it for EventHandler, not strongly typed
                    if (addMethodParams[0].ParameterType != typeof(System.EventHandler))
                        continue;

                    ArglessEventHandlerProxy proxy = new ArglessEventHandlerProxy(this, appMethod);
                    handlerDelegate = proxy.Handler;
                }
                else {
                    // Hookup directly to the app methods hoping all types match

                    try {
                        handlerDelegate = Delegate.CreateDelegate(addMethodParams[0].ParameterType, this, appMethodName);
                    }
                    catch {
                        // some type mismatch
                        continue;
                    }
                }

                // Call the AddXXX() to hook up the delegate

                try {
                    addMethod.Invoke(target, new Object[1]{handlerDelegate});
                }
                catch {
                    if (HttpRuntime.UseIntegratedPipeline) {
                        throw;
                    }
                }

                if (eventName != null) {
                    if (_pipelineEventMasks.ContainsKey(eventName)) {
                        if (!StringUtil.StringStartsWith(eventName, "Post")) {
                            _appRequestNotifications |= _pipelineEventMasks[eventName];
                        }
                        else {
                            _appPostNotifications |= _pipelineEventMasks[eventName];
                        }
                    }
                }
            }
        }

        private void RegisterIntegratedEvent(IntPtr appContext,
                                             string moduleName,
                                             RequestNotification requestNotifications,
                                             RequestNotification postRequestNotifications,
                                             string moduleType,
                                             string modulePrecondition,
                                             bool useHighPriority) {

            // lookup the modules event index, if it already exists
            // use it, otherwise, bump the global count
            // the module is used for event dispatch

            int moduleIndex;
            if (_moduleIndexMap.ContainsKey(moduleName)) {
                moduleIndex = (int) _moduleIndexMap[moduleName];
            }
            else {
                moduleIndex = _moduleIndexMap.Count;
                _moduleIndexMap[moduleName] = moduleIndex;
            }

#if DBG
            Debug.Assert(moduleIndex >= 0, "moduleIndex >= 0");
            Debug.Trace("PipelineRuntime", "RegisterIntegratedEvent:"
                        + " module=" + moduleName
                        + ", index=" + moduleIndex.ToString(CultureInfo.InvariantCulture)
                        + ", rq_notify=" + requestNotifications
                        + ", post_rq_notify=" + postRequestNotifications
                        + ", preconditon=" + modulePrecondition + "\r\n");
#endif

            int result = UnsafeIISMethods.MgdRegisterEventSubscription(appContext,
                                                                       moduleName,
                                                                       requestNotifications,
                                                                       postRequestNotifications,
                                                                       moduleType,
                                                                       modulePrecondition,
                                                                       new IntPtr(moduleIndex),
                                                                       useHighPriority);

            if(result < 0) {
                throw new HttpException(SR.GetString(SR.Failed_Pipeline_Subscription, moduleName));
            }
        }


        private void SetAppLevelCulture() {
            CultureInfo culture = null;
            CultureInfo uiculture = null;
            CultureInfo browserCulture = null;
            //get the language from the browser
            //DevDivBugs 2001091: Request object is not available in integrated mode during Application_Start,
            //so don't try to access it if it is hidden
            if((_appLevelAutoCulture || _appLevelAutoUICulture) && _context != null && _context.HideRequestResponse == false) {
                string[] userLanguages = _context.UserLanguagesFromContext();
                if (userLanguages != null) {
                    try { browserCulture = CultureUtil.CreateReadOnlyCulture(userLanguages, requireSpecific: true); }
                    catch { }
                }
            }

            culture = _appLevelCulture;
            uiculture = _appLevelUICulture;
            if(browserCulture != null) {
                if(_appLevelAutoCulture) {
                    culture = browserCulture;
                }
                if(_appLevelAutoUICulture) {
                    uiculture = browserCulture;
                }
            }

            _savedAppLevelCulture = Thread.CurrentThread.CurrentCulture;
            _savedAppLevelUICulture = Thread.CurrentThread.CurrentUICulture;

            if (culture != null && culture != Thread.CurrentThread.CurrentCulture) {
                HttpRuntime.SetCurrentThreadCultureWithAssert(culture);
            }

            if (uiculture != null && uiculture != Thread.CurrentThread.CurrentUICulture) {
                Thread.CurrentThread.CurrentUICulture = uiculture;
            }
        }

        private void RestoreAppLevelCulture() {
            CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
            CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;

            if (_savedAppLevelCulture != null) {
                // Avoid the cost of the Demand when setting the culture by comparing the cultures first
                if (currentCulture != _savedAppLevelCulture) {
                    HttpRuntime.SetCurrentThreadCultureWithAssert(_savedAppLevelCulture);
                }

                _savedAppLevelCulture = null;
            }

            if (_savedAppLevelUICulture != null) {
                // Avoid the cost of the Demand when setting the culture by comparing the cultures first
                if (currentUICulture  != _savedAppLevelUICulture) {
                    Thread.CurrentThread.CurrentUICulture = _savedAppLevelUICulture;
                }

                _savedAppLevelUICulture = null;
            }
        }

        // Initializes the thread on entry to the managed pipeline. A ThreadContext is returned, on
        // which the caller must call Leave.  The IIS7 integrated pipeline uses setImpersonationContext
        // to prevent it from being set until after the authentication notification.

        // OnThreadEnterPrivate returns ThreadContext.
        // ThreadContext.Enter sets variables that are stored on the thread,
        // and saves anything currently on the thread so it can be restored
        // during the call to ThreadContext.Leave.  All variables that are
        // modified on the thread should be stored in ThreadContext so they
        // can be restored later.  ThreadContext.Enter should only be called
        // when holding a lock on the HttpApplication instance.
        // ThreadContext.Leave is also normally called under the lock, but
        // the Integrated Pipeline may delay this call until after the call to
        // IndicateCompletion returns.  When IndicateCompletion is called,
        // IIS7 will execute the remaining notifications for the request on
        // the current thread.  As a performance improvement, we do not call
        // Leave before calling IndicateCompletion, and we do not call Enter/Leave
        // for the notifications executed while we are in the call to
        // IndicateCompletion.  But when IndicateCompletion returns, we do not
        // have a lock on the HttpApplication instance and therefore cannot
        // modify request state, such as the HttpContext or HttpApplication.
        // The only thing we can do is restore the state of the thread.
        // There's one problem, the Culture/UICulture may be changed by
        // user code that directly updates the values on the current thread, so
        // before leaving the pipeline we call ThreadContext.Synchronize to
        // synchronize the values that are stored on the HttpContext with what
        // is on the thread.  Because of this, the next notification will end up using
        // the Culture/UICulture set by user-code, just as it did on IIS6.
        private ThreadContext OnThreadEnterPrivate(bool setImpersonationContext) {
            ThreadContext threadContext = new ThreadContext(_context);
            threadContext.AssociateWithCurrentThread(setImpersonationContext);

            // An entry is added to the request timeout manager once per request
            // and removed in ReleaseAppInstance.
            if (!_timeoutManagerInitialized) {
                // ensure Timeout is set (see ASURT 148698)
                // to avoid ---- getting config later (ASURT 127388)
                _context.EnsureTimeout();

                HttpRuntime.RequestTimeoutManager.Add(_context);
                _timeoutManagerInitialized = true;
            }

            return threadContext;
        }

        // consumed by AppVerifier when it is enabled
        HttpContext ISyncContext.HttpContext {
            get {
                return _context;
            }
        }

        // consumed by AspNetSynchronizationContext
        ISyncContextLock ISyncContext.Enter() {
            return OnThreadEnter();
        }

        internal ThreadContext OnThreadEnter() {
            return OnThreadEnterPrivate(true /* setImpersonationContext */);
        }

        internal ThreadContext OnThreadEnter(bool setImpersonationContext) {
            return OnThreadEnterPrivate(setImpersonationContext);
        }

        private StepInvoker _stepInvoker;

        public void OnExecuteRequestStep(Action<HttpContextBase, Action> callback) {
            if (callback == null) {
                throw new ArgumentNullException("callback");
            }

            if (!HttpRuntime.UseIntegratedPipeline) {
                throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
            }

            if (_initSpecialCompleted && _initInternalCompleted) {
                //throw if both InitSpecial and InitInternal have completed.
                throw new InvalidOperationException(SR.GetString(SR.OnExecuteRequestStep_Cannot_Be_Called));
            }

            if (_stepInvoker == null) {
                _stepInvoker = new StepInvoker();
            }

            var nextStep = _stepInvoker;
            _stepInvoker = new StepInvoker((nextStepAction) => callback(new HttpContextWrapper(_context), nextStepAction), nextStep);
        }

        private void ExecuteStepImpl(IExecutionStep step) {
            if(_stepInvoker != null) {
                bool stepCalled = false;

                _stepInvoker.Invoke(() => {
                    if (!stepCalled) {
                        stepCalled = true;
                        step.Execute();
                    }
                });

                if (!stepCalled) {
                    step.Execute();
                }
            } else {
                step.Execute();
            }
        }
        /*
         * Execute single step catching exceptions in a fancy way (see below)
         */
        internal Exception ExecuteStep(IExecutionStep step, ref bool completedSynchronously) {
            Exception error = null;

            try {
                try {
                    if (step.IsCancellable) {
                        _context.BeginCancellablePeriod();  // request can be cancelled from this point

                        try {
                            ExecuteStepImpl(step);
                        }
                        finally {
                            _context.EndCancellablePeriod();  // request can be cancelled until this point
                        }

                        _context.WaitForExceptionIfCancelled();  // wait outside of finally
                    }
                    else {
                        ExecuteStepImpl(step);
                    }

                    if (!step.CompletedSynchronously) {
                        completedSynchronously = false;
                        return null;
                    }
                }
                catch (Exception e) {
                    error = e;

                    // Since we will leave the context later, we need to remember if we are impersonating
                    // before we lose that info - VSWhidbey 494476
                    if (ImpersonationContext.CurrentThreadTokenExists) {
                        e.Data[System.Web.Management.WebThreadInformation.IsImpersonatingKey] = String.Empty;
                    }
                    // This might force ThreadAbortException to be thrown
                    // automatically, because we consumed an exception that was
                    // hiding ThreadAbortException behind it

                    if (e is ThreadAbortException &&
                        ((Thread.CurrentThread.ThreadState & ThreadState.AbortRequested) == 0))  {
                        // Response.End from a COM+ component that re-throws ThreadAbortException
                        // It is not a real ThreadAbort
                        // VSWhidbey 178556
                        error = null;
                        _stepManager.CompleteRequest();
                    }
                }
#pragma warning disable 1058
                catch {
                    // ignore non-Exception objects that could be thrown
                }
#pragma warning restore 1058
            }
            catch (ThreadAbortException e) {
                // ThreadAbortException could be masked as another one
                // the try-catch above consumes all exceptions, only
                // ThreadAbortException can filter up here because it gets
                // auto rethrown if no other exception is thrown on catch

                if (e.ExceptionState != null && e.ExceptionState is CancelModuleException) {
                    // one of ours (Response.End or timeout) -- cancel abort

                    CancelModuleException cancelException = (CancelModuleException)e.ExceptionState;

                    if (cancelException.Timeout) {
                        // Timed out
                        error = new HttpException(SR.GetString(SR.Request_timed_out),
                                            null, WebEventCodes.RuntimeErrorRequestAbort);
                        PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_TIMED_OUT);
                    }
                    else {
                        // Response.End
                        error = null;
                        _stepManager.CompleteRequest();
                    }

                    Thread.ResetAbort();
                }
            }

            completedSynchronously = true;
            return error;
        }

        /*
         * Resume execution of the app steps
         */

        private void ResumeStepsFromThreadPoolThread(Exception error) {
            if (Thread.CurrentThread.IsThreadPoolThread) {
                // if on thread pool thread, use the current thread
                ResumeSteps(error);
            }
            else {
                // if on a non-threadpool thread, requeue
                ThreadPool.QueueUserWorkItem(_resumeStepsWaitCallback, error);
            }
        }

        private void ResumeStepsWaitCallback(Object error) {
            ResumeSteps(error as Exception);
        }

        private void ResumeSteps(Exception error) {
            _stepManager.ResumeSteps(error);
        }


        /*
         * Add error to the context fire OnError on first error
         */
        private void RecordError(Exception error) {
            bool firstError = true;

            if (_context != null) {
                if (_context.Error != null)
                    firstError = false;

                _context.AddError(error);
            }
            else {
                if (_lastError != null)
                    firstError = false;

                _lastError = error;
            }

            if (firstError)
                RaiseOnError();
        }


        //
        // Init module list
        //

        private void InitModulesCommon() {
            int n = _moduleCollection.Count;

            for (int i = 0; i < n; i++) {
                // remember the module being inited for event subscriptions
                // we'll later use this for routing
                _currentModuleCollectionKey = _moduleCollection.GetKey(i);
                _moduleCollection[i].Init(this);
            }

            _currentModuleCollectionKey = null;
            InitAppLevelCulture();
        }

        private void InitIntegratedModules() {
            Debug.Assert(null != _moduleConfigInfo, "null != _moduleConfigInfo");
            _moduleCollection = BuildIntegratedModuleCollection(_moduleConfigInfo);
            InitModulesCommon();
        }

        private void InitModules() {
            HttpModulesSection pconfig = RuntimeConfig.GetAppConfig().HttpModules;

            // get the static list, then add the dynamic members
            HttpModuleCollection moduleCollection = pconfig.CreateModules();
            HttpModuleCollection dynamicModules = CreateDynamicModules();

            moduleCollection.AppendCollection(dynamicModules);
            _moduleCollection = moduleCollection; // don't assign until all ops have succeeded

            InitModulesCommon();
        }

        // instantiates modules that have been added to the dynamic registry (classic pipeline)
        private HttpModuleCollection CreateDynamicModules() {
            HttpModuleCollection moduleCollection = new HttpModuleCollection();

            foreach (DynamicModuleRegistryEntry entry in _dynamicModuleRegistry.LockAndFetchList()) {
                HttpModuleAction modAction = new HttpModuleAction(entry.Name, entry.Type);
                moduleCollection.AddModule(modAction.Entry.ModuleName, modAction.Entry.Create());
            }

            return moduleCollection;
        }

        internal string CurrentModuleCollectionKey {
            get {
                return (null == _currentModuleCollectionKey) ? "UnknownModule" : _currentModuleCollectionKey;
            }
        }

        internal static void RegisterModuleInternal(Type moduleType) {
            _dynamicModuleRegistry.Add(moduleType);
        }

        public static void RegisterModule(Type moduleType) {
            RuntimeConfig config = RuntimeConfig.GetAppConfig();
            HttpRuntimeSection runtimeSection = config.HttpRuntime;
            if (runtimeSection.AllowDynamicModuleRegistration) {
                RegisterModuleInternal(moduleType);
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.DynamicModuleRegistrationOff));
            }
        }

        private void RegisterEventSubscriptionsWithIIS(IntPtr appContext, HttpContext context, MethodInfo[] handlers) {
            RequestNotification requestNotifications;
            RequestNotification postRequestNotifications;

            // register an implicit filter module
            RegisterIntegratedEvent(appContext,
                                    IMPLICIT_FILTER_MODULE,
                                    RequestNotification.UpdateRequestCache| RequestNotification.LogRequest  /*requestNotifications*/,
                                    0 /*postRequestNotifications*/,
                                    String.Empty /*type*/,
                                    String.Empty /*precondition*/,
                                    true /*useHighPriority*/);

            // integrated pipeline will always use serverModules instead of <httpModules>
            _moduleCollection = GetModuleCollection(appContext);

            if (handlers != null) {
                HookupEventHandlersForApplicationAndModules(handlers);
            }

            // 1643363: Breaking Change: ASP.Net v2.0: Application_OnStart is called after Module.Init (Integarted mode)
            HttpApplicationFactory.EnsureAppStartCalledForIntegratedMode(context, this);

            // Call Init on HttpApplication derived class ("global.asax")
            // and process event subscriptions before processing other modules.
            // Doing this now prevents clearing any events that may
            // have been added to event handlers during instantiation of this instance.
            // NOTE:  If "global.asax" has a constructor which hooks up event handlers,
            // then they were added to the event handler lists but have not been registered with IIS yet,
            // so we MUST call ProcessEventSubscriptions on it first, before the other modules.
            _currentModuleCollectionKey = HttpApplicationFactory.applicationFileName;

            try {
                _hideRequestResponse = true;
                context.HideRequestResponse = true;
                _context = context;
                Init();
            }
            catch (Exception e) {
                RecordError(e);
                Exception error = context.Error;
                if (error != null) {
                    throw error;
                }
            }
            finally {
                _context = null;
                context.HideRequestResponse = false;
                _hideRequestResponse = false;
            }

            ProcessEventSubscriptions(out requestNotifications, out postRequestNotifications);

            // Save the notification subscriptions so we can register them with IIS later, after
            // we call HookupEventHandlersForApplicationAndModules and process global.asax event handlers.
            _appRequestNotifications |= requestNotifications;
            _appPostNotifications    |= postRequestNotifications;

            for (int i = 0; i < _moduleCollection.Count; i++) {
                _currentModuleCollectionKey = _moduleCollection.GetKey(i);
                IHttpModule httpModule = _moduleCollection.Get(i);
                ModuleConfigurationInfo moduleInfo = _moduleConfigInfo[i];

#if DBG
                Debug.Trace("PipelineRuntime", "RegisterEventSubscriptionsWithIIS: name=" + CurrentModuleCollectionKey
                            + ", type=" + httpModule.GetType().FullName + "\n");

                // make sure collections are in sync
                Debug.Assert(moduleInfo.Name == _currentModuleCollectionKey, "moduleInfo.Name == _currentModuleCollectionKey");
#endif

                httpModule.Init(this);

                ProcessEventSubscriptions(out requestNotifications, out postRequestNotifications);

                // are any events wired up?
                if (requestNotifications != 0 || postRequestNotifications != 0) {

                    RegisterIntegratedEvent(appContext,
                                            moduleInfo.Name,
                                            requestNotifications,
                                            postRequestNotifications,
                                            moduleInfo.Type,
                                            moduleInfo.Precondition,
                                            false /*useHighPriority*/);
                }
            }

            // WOS 1728067: RewritePath does not remap the handler when rewriting from a non-ASP.NET request
            // register a default implicit handler
            RegisterIntegratedEvent(appContext,
                                    IMPLICIT_HANDLER,
                                    RequestNotification.ExecuteRequestHandler | RequestNotification.MapRequestHandler /*requestNotifications*/,
                                    RequestNotification.EndRequest /*postRequestNotifications*/,
                                    String.Empty /*type*/,
                                    String.Empty /*precondition*/,
                                    false /*useHighPriority*/);
        }

        private void ProcessEventSubscriptions(out RequestNotification requestNotifications,
                                               out RequestNotification postRequestNotifications) {
            requestNotifications = 0;
            postRequestNotifications = 0;

            // Begin
            if(HasEventSubscription(EventBeginRequest)) {
                requestNotifications |= RequestNotification.BeginRequest;
            }

            // Authenticate
            if(HasEventSubscription(EventAuthenticateRequest)) {
                requestNotifications |= RequestNotification.AuthenticateRequest;
            }

            if(HasEventSubscription(EventPostAuthenticateRequest)) {
                postRequestNotifications |= RequestNotification.AuthenticateRequest;
            }

            // Authorize
            if(HasEventSubscription(EventAuthorizeRequest)) {
                requestNotifications |= RequestNotification.AuthorizeRequest;
            }
            if(HasEventSubscription(EventPostAuthorizeRequest)) {
                postRequestNotifications |= RequestNotification.AuthorizeRequest;
            }

            // ResolveRequestCache
            if(HasEventSubscription(EventResolveRequestCache)) {
                requestNotifications |= RequestNotification.ResolveRequestCache;
            }
            if(HasEventSubscription(EventPostResolveRequestCache)) {
                postRequestNotifications |= RequestNotification.ResolveRequestCache;
            }

            // MapRequestHandler
            if(HasEventSubscription(EventMapRequestHandler)) {
                requestNotifications |= RequestNotification.MapRequestHandler;
            }
            if(HasEventSubscription(EventPostMapRequestHandler)) {
                postRequestNotifications |= RequestNotification.MapRequestHandler;
            }

            // AcquireRequestState
            if(HasEventSubscription(EventAcquireRequestState)) {
                requestNotifications |= RequestNotification.AcquireRequestState;
            }
            if(HasEventSubscription(EventPostAcquireRequestState)) {
                postRequestNotifications |= RequestNotification.AcquireRequestState;
            }

            // PreExecuteRequestHandler
            if(HasEventSubscription(EventPreRequestHandlerExecute)) {
                requestNotifications |= RequestNotification.PreExecuteRequestHandler;
            }

            // PostRequestHandlerExecute
            if (HasEventSubscription(EventPostRequestHandlerExecute)) {
                postRequestNotifications |= RequestNotification.ExecuteRequestHandler;
            }

            // ReleaseRequestState
            if(HasEventSubscription(EventReleaseRequestState)) {
                requestNotifications |= RequestNotification.ReleaseRequestState;
            }
            if(HasEventSubscription(EventPostReleaseRequestState)) {
                postRequestNotifications |= RequestNotification.ReleaseRequestState;
            }

            // UpdateRequestCache
            if(HasEventSubscription(EventUpdateRequestCache)) {
                requestNotifications |= RequestNotification.UpdateRequestCache;
            }
            if(HasEventSubscription(EventPostUpdateRequestCache)) {
                postRequestNotifications |= RequestNotification.UpdateRequestCache;
            }

            // LogRequest
            if(HasEventSubscription(EventLogRequest)) {
                requestNotifications |= RequestNotification.LogRequest;
            }
            if(HasEventSubscription(EventPostLogRequest)) {
                postRequestNotifications |= RequestNotification.LogRequest;
            }

            // EndRequest
            if(HasEventSubscription(EventEndRequest)) {
                requestNotifications |= RequestNotification.EndRequest;
            }

            // PreSendRequestHeaders
            if(HasEventSubscription(EventPreSendRequestHeaders)) {
                requestNotifications |= RequestNotification.SendResponse;
            }

            // PreSendRequestContent
            if(HasEventSubscription(EventPreSendRequestContent)) {
                requestNotifications |= RequestNotification.SendResponse;
            }
        }

        // check if an event has subscribers
        // and *reset* them if so
        // this is used only for special app instances
        // and not for processing requests
        private bool HasEventSubscription(Object eventIndex) {
            bool hasEvents = false;

            // async
            AsyncAppEventHandler asyncHandler = AsyncEvents[eventIndex];

            if (asyncHandler != null && asyncHandler.Count > 0) {
                asyncHandler.Reset();
                hasEvents = true;
            }

            // sync
            EventHandler handler = (EventHandler)Events[eventIndex];

            if (handler != null) {
                Delegate[] handlers = handler.GetInvocationList();
                if( handlers.Length > 0 ) {
                    hasEvents = true;
                }

                foreach(Delegate d in handlers) {
                    Events.RemoveHandler(eventIndex, d);
                }
            }

            return hasEvents;
        }


        //
        // Get app-level culture info (needed to context-less 'global' methods)
        //

        private void InitAppLevelCulture() {
            GlobalizationSection globConfig = RuntimeConfig.GetAppConfig().Globalization;
            string culture = globConfig.Culture;
            string uiCulture = globConfig.UICulture;
            if (!String.IsNullOrEmpty(culture)) {
                if (StringUtil.StringStartsWithIgnoreCase(culture, AutoCulture)) {
                    _appLevelAutoCulture = true;
                    string appLevelCulture = GetFallbackCulture(culture);
                    if(appLevelCulture != null) {
                        _appLevelCulture = HttpServerUtility.CreateReadOnlyCultureInfo(culture.Substring(5));
                    }
                }
                else {
                    _appLevelAutoCulture = false;
                    _appLevelCulture = HttpServerUtility.CreateReadOnlyCultureInfo(globConfig.Culture);
                }
            }
            if (!String.IsNullOrEmpty(uiCulture)) {
                if (StringUtil.StringStartsWithIgnoreCase(uiCulture, AutoCulture))
                {
                    _appLevelAutoUICulture = true;
                    string appLevelUICulture = GetFallbackCulture(uiCulture);
                    if(appLevelUICulture != null) {
                        _appLevelUICulture = HttpServerUtility.CreateReadOnlyCultureInfo(uiCulture.Substring(5));
                    }
                }
                else {
                    _appLevelAutoUICulture = false;
                    _appLevelUICulture = HttpServerUtility.CreateReadOnlyCultureInfo(globConfig.UICulture);
                }
            }
        }

        internal static string GetFallbackCulture(string culture) {
            if((culture.Length > 5) && (culture.IndexOf(':') == 4)) {
                return culture.Substring(5);
            }
            return null;
        }

        //
        // Request mappings management functions
        //

        private IHttpHandlerFactory GetFactory(HttpHandlerAction mapping) {
            HandlerFactoryCache entry = (HandlerFactoryCache)_handlerFactories[mapping.Type];
            if (entry == null) {
                entry = new HandlerFactoryCache(mapping);
                _handlerFactories[mapping.Type] = entry;
            }

            return entry.Factory;
        }

        private IHttpHandlerFactory GetFactory(string type) {
            HandlerFactoryCache entry = (HandlerFactoryCache)_handlerFactories[type];
            if (entry == null) {
                entry = new HandlerFactoryCache(type);
                _handlerFactories[type] = entry;
            }

            return entry.Factory;
        }


        /*
         * Recycle all handlers mapped during the request processing
         */
        private void RecycleHandlers() {
            if (_handlerRecycleList != null) {
                int numHandlers = _handlerRecycleList.Count;

                for (int i = 0; i < numHandlers; i++)
                    ((HandlerWithFactory)_handlerRecycleList[i]).Recycle();

                _handlerRecycleList = null;
            }
        }

        /*
         * Special exception to cancel module execution (not really an exception)
         * used in Response.End and when cancelling requests
         */
        internal class CancelModuleException {
            private bool _timeout;

            internal CancelModuleException(bool timeout) {
                _timeout = timeout;
            }

            internal bool Timeout { get { return _timeout;}}
        }

        // Setup the asynchronous stuff and application variables
        // context for the entire deal is already rooted for native handler
        internal void AssignContext(HttpContext context) {
            Debug.Assert(HttpRuntime.UseIntegratedPipeline, "HttpRuntime.UseIntegratedPipeline");

            if (null == _context) {
                _stepManager.InitRequest();

                _context = context;
                _context.ApplicationInstance = this;

                if (_context.TraceIsEnabled)
                    HttpRuntime.Profile.StartRequest(_context);

                // this will throw if config is invalid, so we do it after HttpContext.ApplicationInstance is set
                _context.SetImpersonationEnabled();
            }
        }

        internal IAsyncResult BeginProcessRequestNotification(HttpContext context, AsyncCallback cb) {
            Debug.Trace("PipelineRuntime", "BeginProcessRequestNotification");

            HttpAsyncResult result;

            if (_context == null) {
                // 
                AssignContext(context);
            }

            //
            // everytime initialization
            //

            context.CurrentModuleEventIndex = -1;

            // Create the async result
            result = new HttpAsyncResult(cb, context);
            context.NotificationContext.AsyncResult = result;

            // enter notification execution loop

            ResumeSteps(null);

            return result;
        }

        internal RequestNotificationStatus EndProcessRequestNotification(IAsyncResult result) {
            HttpAsyncResult ar = (HttpAsyncResult)result;
            if (ar.Error != null)
                throw ar.Error;

            return ar.Status;
        }

        internal void ReleaseAppInstance() {
            if (_context != null)
            {
                if (_context.TraceIsEnabled) {
                    HttpRuntime.Profile.EndRequest(_context);
                }
                _context.ClearReferences();
                if (_timeoutManagerInitialized) {
                    HttpRuntime.RequestTimeoutManager.Remove(_context);
                    _timeoutManagerInitialized = false;
                }

                if(HttpRuntime.EnablePrefetchOptimization && 
                   HttpRuntime.InitializationException == null && 
                   _context.FirstRequest && 
                   _context.Error == null) {
                       UnsafeNativeMethods.EndPrefetchActivity((uint)StringUtil.GetNonRandomizedHashCode(HttpRuntime.AppDomainAppId));
                }
            }
            RecycleHandlers();
            if (AsyncResult != null) {
                AsyncResult = null;
            }
            _context = null;
            RaiseOnRequestCompleted();
            AppEvent = null;

            if (ApplicationInstanceConsumersCounter != null) {
                ApplicationInstanceConsumersCounter.MarkOperationCompleted(); // ReleaseAppInstance call complete
            }
            else {
                HttpApplicationFactory.RecycleApplicationInstance(this);
            }
        }

        private void AddEventMapping(string moduleName,
                                      RequestNotification requestNotification,
                                      bool isPostNotification,
                                      IExecutionStep step) {

            ThrowIfEventBindingDisallowed();

            // Add events to the IExecutionStep containers only if
            // InitSpecial has completed and InitInternal has not completed.
            if (!IsContainerInitalizationAllowed) {
                return;
            }

            Debug.Assert(!String.IsNullOrEmpty(moduleName), "!String.IsNullOrEmpty(moduleName)");
            Debug.Trace("PipelineRuntime", "AddEventMapping: for " + moduleName +
                        " for " + requestNotification + "\r\n" );


            PipelineModuleStepContainer container = GetModuleContainer(moduleName);
            //WOS 1985878: HttpModule unsubscribing an event handler causes AV in Integrated Mode
            if (container != null) {
#if DBG
                container.DebugModuleName = moduleName;
#endif
                container.AddEvent(requestNotification, isPostNotification, step);
            }
        }

        static internal List<ModuleConfigurationInfo> IntegratedModuleList {
            get {
                return _moduleConfigInfo;
            }
        }

        private HttpModuleCollection GetModuleCollection(IntPtr appContext) {
            if (_moduleConfigInfo != null) {
                return BuildIntegratedModuleCollection(_moduleConfigInfo);
            }

            List<ModuleConfigurationInfo> moduleList = null;

            IntPtr pModuleCollection = IntPtr.Zero;
            IntPtr pBstrModuleName = IntPtr.Zero;
            int cBstrModuleName = 0;
            IntPtr pBstrModuleType = IntPtr.Zero;
            int cBstrModuleType = 0;
            IntPtr pBstrModulePrecondition = IntPtr.Zero;
            int cBstrModulePrecondition = 0;
            try {
                int count = 0;
                int result = UnsafeIISMethods.MgdGetModuleCollection(IntPtr.Zero, appContext, out pModuleCollection, out count);
                if (result < 0) {
                    throw new HttpException(SR.GetString(SR.Cant_Read_Native_Modules, result.ToString("X8", CultureInfo.InvariantCulture)));
                }
                moduleList = new List<ModuleConfigurationInfo>(count);

                for (uint index = 0; index < count; index++) {
                    result = UnsafeIISMethods.MgdGetNextModule(pModuleCollection, ref index,
                                                               out pBstrModuleName, out cBstrModuleName,
                                                               out pBstrModuleType, out cBstrModuleType,
                                                               out pBstrModulePrecondition, out cBstrModulePrecondition);
                    if (result < 0) {
                        throw new HttpException(SR.GetString(SR.Cant_Read_Native_Modules, result.ToString("X8", CultureInfo.InvariantCulture)));
                    }
                    string moduleName = (cBstrModuleName > 0) ? StringUtil.StringFromWCharPtr(pBstrModuleName, cBstrModuleName) : null;
                    string moduleType = (cBstrModuleType > 0) ? StringUtil.StringFromWCharPtr(pBstrModuleType, cBstrModuleType) : null;
                    string modulePrecondition = (cBstrModulePrecondition > 0) ? StringUtil.StringFromWCharPtr(pBstrModulePrecondition, cBstrModulePrecondition) : String.Empty;
                    Marshal.FreeBSTR(pBstrModuleName);
                    pBstrModuleName = IntPtr.Zero;
                    cBstrModuleName = 0;
                    Marshal.FreeBSTR(pBstrModuleType);
                    pBstrModuleType = IntPtr.Zero;
                    cBstrModuleType = 0;
                    Marshal.FreeBSTR(pBstrModulePrecondition);
                    pBstrModulePrecondition = IntPtr.Zero;
                    cBstrModulePrecondition = 0;

                    if (!String.IsNullOrEmpty(moduleName) && !String.IsNullOrEmpty(moduleType)) {
                        moduleList.Add(new ModuleConfigurationInfo(moduleName, moduleType, modulePrecondition));
                    }
                }
            }
            finally {
                if (pModuleCollection != IntPtr.Zero) {
                    Marshal.Release(pModuleCollection);
                    pModuleCollection = IntPtr.Zero;
                }
                if (pBstrModuleName != IntPtr.Zero) {
                    Marshal.FreeBSTR(pBstrModuleName);
                    pBstrModuleName = IntPtr.Zero;
                }
                if (pBstrModuleType != IntPtr.Zero) {
                    Marshal.FreeBSTR(pBstrModuleType);
                    pBstrModuleType = IntPtr.Zero;
                }
                if (pBstrModulePrecondition != IntPtr.Zero) {
                    Marshal.FreeBSTR(pBstrModulePrecondition);
                    pBstrModulePrecondition = IntPtr.Zero;
                }
            }

            // now that the static list has been processed, add in the dynamic module list
            moduleList.AddRange(GetConfigInfoForDynamicModules());
            _moduleConfigInfo = moduleList;

            return BuildIntegratedModuleCollection(_moduleConfigInfo);
        }

        // gets configuration for modules that have been added to the dynamic registry (integrated pipeline)
        private IEnumerable<ModuleConfigurationInfo> GetConfigInfoForDynamicModules() {
            return from entry in _dynamicModuleRegistry.LockAndFetchList()
                   select new ModuleConfigurationInfo(entry.Name, entry.Type, "managedHandler" /* condition */);
        }

        HttpModuleCollection BuildIntegratedModuleCollection(List<ModuleConfigurationInfo> moduleList) {
            HttpModuleCollection modules = new HttpModuleCollection();

            foreach(ModuleConfigurationInfo mod in moduleList) {
#if DBG
                Debug.Trace("NativeConfig", "Runtime module: " + mod.Name + " of type " + mod.Type + "\n");
#endif
                ModulesEntry currentModule = new ModulesEntry(mod.Name, mod.Type, "type", null);

                modules.AddModule(currentModule.ModuleName, currentModule.Create());
            }

            return modules;
        }

        //
        // Internal classes to support [asynchronous] app execution logic
        //

        internal class AsyncAppEventHandler {
            int _count;
            ArrayList _beginHandlers;
            ArrayList _endHandlers;
            ArrayList _stateObjects;

            internal AsyncAppEventHandler() {
                _count = 0;
                _beginHandlers = new ArrayList();
                _endHandlers   = new ArrayList();
                _stateObjects  = new ArrayList();
            }

            internal void Reset() {
                _count = 0;
                _beginHandlers.Clear();
                _endHandlers.Clear();
                _stateObjects.Clear();
            }

            internal int Count {
                get {
                    return _count;
                }
            }

            internal void Add(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
                _beginHandlers.Add(beginHandler);
                _endHandlers.Add(endHandler);
                _stateObjects.Add(state);
                _count++;
            }

            internal void CreateExecutionSteps(HttpApplication app, ArrayList steps) {
                for (int i = 0; i < _count; i++) {
                    steps.Add(new AsyncEventExecutionStep(
                        app,
                        (BeginEventHandler)_beginHandlers[i],
                        (EndEventHandler)_endHandlers[i],
                        _stateObjects[i]));
                }
            }
        }

        internal class AsyncAppEventHandlersTable {
            private Hashtable _table;

            internal void AddHandler(Object eventId, BeginEventHandler beginHandler,
                                     EndEventHandler endHandler, Object state,
                                     RequestNotification requestNotification,
                                     bool isPost, HttpApplication app) {
                if (_table == null)
                    _table = new Hashtable();

                AsyncAppEventHandler asyncHandler = (AsyncAppEventHandler)_table[eventId];

                if (asyncHandler == null) {
                    asyncHandler = new AsyncAppEventHandler();
                    _table[eventId] = asyncHandler;
                }

                asyncHandler.Add(beginHandler, endHandler, state);

                if (HttpRuntime.UseIntegratedPipeline) {
                    AsyncEventExecutionStep step =
                        new AsyncEventExecutionStep(app,
                                                    beginHandler,
                                                    endHandler,
                                                    state);

                    app.AddEventMapping(app.CurrentModuleCollectionKey, requestNotification, isPost, step);
                }
            }

            internal AsyncAppEventHandler this[Object eventId] {
                get {
                    if (_table == null)
                        return null;
                    return (AsyncAppEventHandler)_table[eventId];
                }
            }
        }

        // interface to represent one execution step
        internal interface IExecutionStep {
            void Execute();
            bool CompletedSynchronously { get;}
            bool IsCancellable { get; }
        }

        // execution step -- stub
        internal class NoopExecutionStep : IExecutionStep {
            internal NoopExecutionStep() {
            }

            void IExecutionStep.Execute() {
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }

        // execution step -- call synchronous event
        internal class SyncEventExecutionStep : IExecutionStep {
            private HttpApplication _application;
            private EventHandler    _handler;

            internal SyncEventExecutionStep(HttpApplication app, EventHandler handler) {
                _application = app;
                _handler = handler;
            }

            internal EventHandler Handler {
                get {
                    return _handler;
                }
            }

            void IExecutionStep.Execute() {
                string targetTypeStr = null;

                if (_handler != null) {
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) {
                        targetTypeStr = _handler.Method.ReflectedType.ToString();

                        EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_ENTER, _application.Context.WorkerRequest, targetTypeStr);
                    }
                    _handler(_application, _application.AppEvent);
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_LEAVE, _application.Context.WorkerRequest, targetTypeStr);
                }
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return true; }
            }
        }

        // execution step -- call asynchronous event
        internal class AsyncEventExecutionStep : IExecutionStep {
            private HttpApplication     _application;
            private BeginEventHandler   _beginHandler;
            private EndEventHandler     _endHandler;
            private Object              _state;
            private AsyncCallback       _completionCallback;
            private AsyncStepCompletionInfo _asyncStepCompletionInfo; // per call
            private bool                _sync;          // per call
            private string              _targetTypeStr;

            internal AsyncEventExecutionStep(HttpApplication app, BeginEventHandler beginHandler, EndEventHandler endHandler, Object state)
                :this(app, beginHandler, endHandler, state, HttpRuntime.UseIntegratedPipeline)
                {
                }

            internal AsyncEventExecutionStep(HttpApplication app, BeginEventHandler beginHandler, EndEventHandler endHandler, Object state, bool useIntegratedPipeline) {

                _application = app;
                // Instrument the beginHandler method if AppVerifier is enabled.
                // If AppVerifier not enabled, we just get back the original delegate to beginHandler uninstrumented.
                _beginHandler = AppVerifier.WrapBeginMethod(_application, beginHandler);
                _endHandler = endHandler;
                _state = state;
                _completionCallback = new AsyncCallback(this.OnAsyncEventCompletion);
            }

            private void OnAsyncEventCompletion(IAsyncResult ar) {
                if (ar.CompletedSynchronously) {
                    // Synchronous completions will be handled by IExecutionStep.Execute.
                    return;
                }

                // This IAsyncResult may actually have completed synchronously (we might be on the same thread
                // which called IExecutionStep.Execute) even if CompletedSynchronously = false. Regardless,
                // we should invoke the End* method on the same thread that invoked this callback, as some
                // applications use TLS instead of the IAsyncResult object itself to convey state information.

                Debug.Trace("PipelineRuntime", "AsyncStep.OnAsyncEventCompletion");
                HttpContext context = _application.Context;
                Exception error = null;

                // The asynchronous step has completed, so we should disallow further
                // async operations until the next step.
                context.SyncContext.ProhibitVoidAsyncOperations();

                try {
                    InvokeEndHandler(ar);
                } catch (Exception e) {
                    error = e;
                }

                bool shouldCallResumeSteps = _asyncStepCompletionInfo.RegisterAsyncCompletion(error);
                if (!shouldCallResumeSteps) {
                    return;
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_LEAVE, context.WorkerRequest, _targetTypeStr);

                // re-set start time after an async completion (see VSWhidbey 231010)
                context.SetStartTime();

                // Assert to disregard the user code up the stack
                if (HttpRuntime.IsLegacyCas) {
                    ResumeStepsWithAssert(error);
                }
                else {
                    ResumeSteps(error);
                }
            }

            private void InvokeEndHandler(IAsyncResult ar) {
                if (_application._stepInvoker != null) {
                    bool stepCalled = false;

                    _application._stepInvoker.Invoke(() => {
                        if (!stepCalled) {
                            stepCalled = true;
                            _endHandler(ar);
                        }
                    });

                    if (!stepCalled) {
                        _endHandler(ar);
                    }
                } else {
                    _endHandler(ar);
                }
            }

            [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
            void ResumeStepsWithAssert(Exception error) {
                ResumeSteps(error);
            }

            void ResumeSteps(Exception error) {
                _application.ResumeStepsFromThreadPoolThread(error);
            }

            void IExecutionStep.Execute() {
                _sync = false;

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) {
                    _targetTypeStr = _beginHandler.Method.ReflectedType.ToString();
                    EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_ENTER, _application.Context.WorkerRequest, _targetTypeStr);
                }

                HttpContext context = _application.Context;

                _asyncStepCompletionInfo.Reset();
                context.SyncContext.AllowVoidAsyncOperations();
                IAsyncResult ar;
                try {
                    ar = _beginHandler(_application, _application.AppEvent, _completionCallback, _state);
                }
                catch {
                    // The asynchronous step has completed, so we should disallow further
                    // async operations until the next step.
                    context.SyncContext.ProhibitVoidAsyncOperations();
                    throw;
                }

                bool operationCompleted;
                bool mustCallEndHandler;
                _asyncStepCompletionInfo.RegisterBeginUnwound(ar, out operationCompleted, out mustCallEndHandler);

                if (operationCompleted) {
                    _sync = true;

                    if (mustCallEndHandler) {
                        // The asynchronous step has completed, so we should disallow further
                        // async operations until the next step.
                        context.SyncContext.ProhibitVoidAsyncOperations();
                        _endHandler(ar);
                    }

                    _asyncStepCompletionInfo.ReportError();

                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_LEAVE, _application.Context.WorkerRequest, _targetTypeStr);
                }
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return _sync;}
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }

        // execution step -- validate the path for canonicalization issues
        internal class ValidatePathExecutionStep : IExecutionStep {
            private HttpApplication _application;

            internal ValidatePathExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                _application.Context.ValidatePath();
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true; }
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }

        // execution step -- validate request (virtual path, query string, entity body, etc)
        internal class ValidateRequestExecutionStep : IExecutionStep {
            private HttpApplication _application;

            internal ValidateRequestExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                _application.Context.Request.ValidateInputIfRequiredByConfig();
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true; }
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }

        // materialize handler for integrated pipeline
        // this does not map handler, rather that's done by the core
        // this does instantiate the managed type so that things that need to
        // look at it can
        internal class MaterializeHandlerExecutionStep : IExecutionStep {
            private HttpApplication _application;

            internal MaterializeHandlerExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                HttpContext context = _application.Context;
                HttpRequest request = context.Request;
                IHttpHandler handler = null;
                string configType = null;

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_ENTER, context.WorkerRequest);

                IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;

                // Get handler
                if (context.RemapHandlerInstance != null){
                    //RemapHandler overrides all
                    wr.SetScriptMapForRemapHandler();
                    context.Handler = context.RemapHandlerInstance;
                }
                else if (request.RewrittenUrl != null) {
                    // RewritePath, we need to re-map the handler
                    bool handlerExists;
                    configType = wr.ReMapHandlerAndGetHandlerTypeString(context, request.Path, out handlerExists);
                    if (!handlerExists) {
                        // WOS 1973590: When RewritePath is used with missing handler in Integrated Mode,an empty response 200 is returned instead of 404
                        throw new HttpException(404, SR.GetString(SR.Http_handler_not_found_for_request_type, request.RequestType));
                    }
                }
                else {
                    configType = wr.GetManagedHandlerType();
                }

                if (!String.IsNullOrEmpty(configType)) {
                    IHttpHandlerFactory factory = _application.GetFactory(configType);
                    string pathTranslated = request.PhysicalPathInternal;

                    try {
                        handler = factory.GetHandler(context, request.RequestType, request.FilePath, pathTranslated);
                    }
                    catch (FileNotFoundException e) {
                        if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                            throw new HttpException(404, null, e);
                        else
                            throw new HttpException(404, null);
                    }
                    catch (DirectoryNotFoundException e) {
                        if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                            throw new HttpException(404, null, e);
                        else
                            throw new HttpException(404, null);
                    }
                    catch (PathTooLongException e) {
                        if (HttpRuntime.HasPathDiscoveryPermission(pathTranslated))
                            throw new HttpException(414, null, e);
                        else
                            throw new HttpException(414, null);
                    }

                    context.Handler = handler;

                    // Remember for recycling
                    if (_application._handlerRecycleList == null)
                        _application._handlerRecycleList = new ArrayList();
                    _application._handlerRecycleList.Add(new HandlerWithFactory(handler, factory));
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_LEAVE, context.WorkerRequest);
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }


        // execution step -- map HTTP handler (used to be a separate module)
        internal class MapHandlerExecutionStep : IExecutionStep {
            private HttpApplication _application;

            internal MapHandlerExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                HttpContext context = _application.Context;
                HttpRequest request = context.Request;

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_ENTER, context.WorkerRequest);

                context.Handler = _application.MapHttpHandler(
                    context,
                    request.RequestType,
                    request.FilePathObject,
                    request.PhysicalPathInternal,
                    false /*useAppConfig*/);
                Debug.Assert(context.ConfigurationPath == context.Request.FilePathObject, "context.ConfigurationPath (" +
                             context.ConfigurationPath + ") != context.Request.FilePath (" + context.Request.FilePath + ")");

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_MAPHANDLER_LEAVE, context.WorkerRequest);
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }

        // execution step -- call HTTP handler (used to be a separate module)
        internal class CallHandlerExecutionStep : IExecutionStep {
            private HttpApplication   _application;
            private AsyncCallback     _completionCallback;
            private IHttpAsyncHandler _handler;       // per call
            private AsyncStepCompletionInfo _asyncStepCompletionInfo; // per call
            private bool              _sync;          // per call

            internal CallHandlerExecutionStep(HttpApplication app) {
                _application = app;
                _completionCallback = new AsyncCallback(this.OnAsyncHandlerCompletion);
            }

            private void OnAsyncHandlerCompletion(IAsyncResult ar) {
                if (ar.CompletedSynchronously) {
                    // Synchronous completions will be handled by IExecutionStep.Execute.
                    return;
                }

                // This IAsyncResult may actually have completed synchronously (we might be on the same thread
                // which called IExecutionStep.Execute) even if CompletedSynchronously = false. Regardless,
                // we should invoke the End* method on the same thread that invoked this callback, as some
                // applications use TLS instead of the IAsyncResult object itself to convey state information.

                HttpContext context = _application.Context;
                Exception error = null;

                // The asynchronous step has completed, so we should disallow further
                // async operations until the next step.
                context.SyncContext.ProhibitVoidAsyncOperations();

                try {
                    try {
                        InvokeEndHandler(ar);
                    } finally {
                        SuppressPostEndRequestIfNecessary(context);

                        // In Integrated mode, generate the necessary response headers
                        // after the ASP.NET handler runs.  If EndProcessRequest throws,
                        // the headers will be generated by ReportRuntimeError
                        context.Response.GenerateResponseHeadersForHandler();
                    }
                }
                catch (Exception e) {
                    if (e is ThreadAbortException || e.InnerException != null && e.InnerException is ThreadAbortException) {
                        // Response.End happened during async operation
                        _application.CompleteRequest();
                    }
                    else {
                        error = e;
                    }
                }

                bool shouldCallResumeSteps = _asyncStepCompletionInfo.RegisterAsyncCompletion(error);
                if (!shouldCallResumeSteps) {
                    return;
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);

                _handler = null; // not to remember

                // re-set start time after an async completion (see VSWhidbey 231010)
                context.SetStartTime();

                // Assert to disregard the user code up the stack
                if (HttpRuntime.IsLegacyCas) {
                    ResumeStepsWithAssert(error);
                }
                else {
                    ResumeSteps(error);
                }
            }

            private void InvokeEndHandler(IAsyncResult ar) {
                if (_application._stepInvoker != null) {
                    bool stepCalled = false;

                    _application._stepInvoker.Invoke(() => {
                        if (!stepCalled) {
                            stepCalled = true;
                            _handler.EndProcessRequest(ar);
                        }
                    });

                    if (!stepCalled) {
                        _handler.EndProcessRequest(ar);
                    }
                } else {
                    _handler.EndProcessRequest(ar);
                }
            }

            [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
            void ResumeStepsWithAssert(Exception error) {
                ResumeSteps(error);
            }

            void ResumeSteps(Exception error) {
                _application.ResumeStepsFromThreadPoolThread(error);
            }

            private static void SuppressPostEndRequestIfNecessary(HttpContext context) {
                // DevDiv #245124 - ASP.NET now hooks PostEndRequest in order to kick off the WebSocket pipeline.
                // If this is not a WebSocket request or the handshake was not completed, then we can suppress
                // this pipeline event. This allows us to send the appropriate cache headers to the client,
                // and it also gives a small perf boost.

                if (!context.IsWebSocketRequestUpgrading) {
                    IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
                    if (wr != null) {
                        wr.DisableNotifications(notifications: 0, postNotifications: RequestNotification.EndRequest);
                    }
                }
            }

            void IExecutionStep.Execute() {
                HttpContext context = _application.Context;
                IHttpHandler handler = context.Handler;

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_ENTER, context.WorkerRequest);

                if (handler != null && HttpRuntime.UseIntegratedPipeline) {
                    IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
                    if (wr != null && wr.IsHandlerExecutionDenied()) {
                        _sync = true;
                        HttpException error = new HttpException(403, SR.GetString(SR.Handler_access_denied));
                        error.SetFormatter(new PageForbiddenErrorFormatter(context.Request.Path, SR.GetString(SR.Handler_access_denied)));
                        throw error;
                    }
                }

                if (handler == null) {
                    _sync = true;
                }
                else if (handler is IHttpAsyncHandler) {
                    // asynchronous handler
                    IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler)handler;

                    _sync = false;
                    _handler = asyncHandler;

                    // Instrument the BeginProcessRequest method if AppVerifier is enabled.
                    // If AppVerifier not enabled, we just get back the original delegate to BeginProcessRequest uninstrumented.
                    var beginProcessRequestDelegate = AppVerifier.WrapBeginMethod<HttpContext>(_application, asyncHandler.BeginProcessRequest);

                    _asyncStepCompletionInfo.Reset();
                    context.SyncContext.AllowVoidAsyncOperations();
                    IAsyncResult ar;
                    try {
                        ar = beginProcessRequestDelegate(context, _completionCallback, null);
                    }
                    catch {
                        // The asynchronous step has completed, so we should disallow further
                        // async operations until the next step.
                        context.SyncContext.ProhibitVoidAsyncOperations();
                        throw;
                    }

                    bool operationCompleted;
                    bool mustCallEndHandler;
                    _asyncStepCompletionInfo.RegisterBeginUnwound(ar, out operationCompleted, out mustCallEndHandler);

                    if (operationCompleted) {
                        _sync = true;
                        _handler = null; // not to remember

                        // The asynchronous step has completed, so we should disallow further
                        // async operations until the next step.
                        context.SyncContext.ProhibitVoidAsyncOperations();

                        try {
                            if (mustCallEndHandler) {
                                asyncHandler.EndProcessRequest(ar);
                            }

                            _asyncStepCompletionInfo.ReportError();
                        }
                        finally {
                            SuppressPostEndRequestIfNecessary(context);

                            //  In Integrated mode, generate the necessary response headers
                            //  after the ASP.NET handler runs
                            context.Response.GenerateResponseHeadersForHandler();
                        }

                        if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);
                    }
                }
                else {
                    // synchronous handler
                    _sync = true;

                    // disable async operations
                    //_application.SyncContext.Disable();

                    // VSWhidbey 268772 - If a synchronous handler internally kicks off an asynchronous operation and waits (blocking) for that
                    // operation to complete, the handler will deadlock since the asynchronous operation can't come back to the appropriate
                    // thread to perform the completion. The solution below was only meant to be temporary but was accidentally left in the product
                    // for v2.0 RTM, so it's now legacy behavior and cannot be changed.
                    context.SyncContext.SetSyncCaller();

                    try {
                        handler.ProcessRequest(context);
                    }
                    finally {
                        context.SyncContext.ResetSyncCaller();
                        if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_HTTPHANDLER_LEAVE, context.WorkerRequest);

                        SuppressPostEndRequestIfNecessary(context);

                        // In Integrated mode, generate the necessary response headers
                        // after the ASP.NET handler runs
                        context.Response.GenerateResponseHeadersForHandler();
                    }
                }
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return _sync;}
            }

            bool IExecutionStep.IsCancellable {
                // launching of async handler should not be cancellable
                get { return (_application.Context.Handler is IHttpAsyncHandler) ? false : true; }
            }
        }

        // execution step -- initiate the transition to a WebSocket request
        internal class TransitionToWebSocketsExecutionStep : IExecutionStep {
            private readonly HttpApplication _application;

            internal TransitionToWebSocketsExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                HttpContext context = _application.Context;

                if (context.RootedObjects == null
                    || context.RootedObjects.WebSocketPipeline == null
                    || context.Response.StatusCode != (int)HttpStatusCode.SwitchingProtocols) {

                    // If this isn't a WebSocket request or something has caused the status code
                    // not to be HTTP 101 (such as an error, redirect, or something else), no-op.
                    CompletedSynchronously = true;
                }
                else {
                    // DevDiv #273639: Let the HttpRequest instance maintain a reference to the response
                    // cookie collection, as the HttpResponse instance won't be available after the transition.
                    context.Request.StoreReferenceToResponseCookies(context.Response.GetCookiesNoCreate());

                    // If this is a WebSocket request, mark as transitioned so that asynchronous events (like SendRequest)
                    // don't execute. We also need to mark ourselves as not having completed synchronously so that the
                    // pipeline unwinds back to ProcessRequestNotification. That method special-cases WebSocket handlers
                    // and cleans up the HttpContext / HttpApplication eagerly.

                    // transition: AcceptWebSocketRequestCalled -> TransitionStarted
                    context.TransitionToWebSocketState(WebSocketTransitionState.TransitionStarted);
                    CompletedSynchronously = false;
                }
            }

            public bool CompletedSynchronously {
                get;
                private set;
            }

            public bool IsCancellable {
                // launching of async operation should not be cancellable
                get { return false; }
            }
        }

        // execution step -- call response filter
        internal class CallFilterExecutionStep : IExecutionStep {
            private HttpApplication _application;

            internal CallFilterExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                try {
                    _application.Context.Response.FilterOutput();
                }
                finally {
                    // if this is the UpdateCache notification, then disable the LogRequest notification (which handles the error case)
                    if (HttpRuntime.UseIntegratedPipeline && (_application.Context.CurrentNotification == RequestNotification.UpdateRequestCache)) {
                        _application.Context.DisableNotifications(RequestNotification.LogRequest, 0 /*postNotifications*/);
                    }
                }
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return true; }
            }
        }

        // integrated pipeline execution step for RaiseOnPreSendRequestHeaders and RaiseOnPreSendRequestContent
        internal class SendResponseExecutionStep : IExecutionStep {
            private HttpApplication _application;
            private EventHandler _handler;
            private bool _isHeaders;

            internal SendResponseExecutionStep(HttpApplication app, EventHandler handler, bool isHeaders) {
                _application = app;
                _handler = handler;
                _isHeaders = isHeaders;
            }

            void IExecutionStep.Execute() {

                // IIS only has a SendResponse notification, so we check the flags
                // to determine whether this notification is for headers or content.
                // The step uses _isHeaders to keep track of whether this is for headers or content.
                if (_application.Context.IsSendResponseHeaders && _isHeaders
                    || !_isHeaders) {

                    string targetTypeStr = null;

                    if (_handler != null) {
                        if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) {
                            targetTypeStr = _handler.Method.ReflectedType.ToString();

                            EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_ENTER, _application.Context.WorkerRequest, targetTypeStr);
                        }
                        _handler(_application, _application.AppEvent);
                        if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Module)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PIPELINE_LEAVE, _application.Context.WorkerRequest, targetTypeStr);
                    }
                }
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return true; }
            }
        }

        internal class UrlMappingsExecutionStep : IExecutionStep {
            private HttpApplication _application;


            internal UrlMappingsExecutionStep(HttpApplication app) {
                _application = app;
            }

            void IExecutionStep.Execute() {
                HttpContext context = _application.Context;
                UrlMappingsModule.UrlMappingRewritePath(context);
            }

            bool IExecutionStep.CompletedSynchronously {
                get { return true;}
            }

            bool IExecutionStep.IsCancellable {
                get { return false; }
            }
        }

        internal abstract class StepManager {
            protected HttpApplication _application;
            protected bool _requestCompleted;

            internal StepManager(HttpApplication application) {
                _application = application;
            }

            internal bool IsCompleted { get { return _requestCompleted; } }

            internal abstract void BuildSteps(WaitCallback stepCallback);

            internal void CompleteRequest() {
                _requestCompleted = true;
                if (HttpRuntime.UseIntegratedPipeline) {
                    HttpContext context = _application.Context;
                    if (context != null && context.NotificationContext != null) {
                        context.NotificationContext.RequestCompleted = true;
                    }
                }
            }

            internal abstract void InitRequest();

            internal abstract void ResumeSteps(Exception error);
        }

        internal class ApplicationStepManager : StepManager {
            private IExecutionStep[] _execSteps;
            private WaitCallback _resumeStepsWaitCallback;
            private int _currentStepIndex;
            private int _numStepCalls;
            private int _numSyncStepCalls;
            private int _endRequestStepIndex;

            internal ApplicationStepManager(HttpApplication app): base(app) {
            }

            internal override void BuildSteps(WaitCallback stepCallback ) {
                ArrayList steps = new ArrayList();
                HttpApplication app = _application;

                bool urlMappingsEnabled = false;
                UrlMappingsSection urlMappings = RuntimeConfig.GetConfig().UrlMappings;
                urlMappingsEnabled = urlMappings.IsEnabled && ( urlMappings.UrlMappings.Count > 0 );

                steps.Add(new ValidateRequestExecutionStep(app));
                steps.Add(new ValidatePathExecutionStep(app));

                if (urlMappingsEnabled)
                    steps.Add(new UrlMappingsExecutionStep(app)); // url mappings

                app.CreateEventExecutionSteps(HttpApplication.EventBeginRequest, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventAuthenticateRequest, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventDefaultAuthentication, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPostAuthenticateRequest, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventAuthorizeRequest, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPostAuthorizeRequest, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventResolveRequestCache, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPostResolveRequestCache, steps);
                steps.Add(new MapHandlerExecutionStep(app));     // map handler
                app.CreateEventExecutionSteps(HttpApplication.EventPostMapRequestHandler, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventAcquireRequestState, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPostAcquireRequestState, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPreRequestHandlerExecute, steps);
                steps.Add(app.CreateImplicitAsyncPreloadExecutionStep()); // implict async preload step
                steps.Add(new CallHandlerExecutionStep(app));  // execute handler
                app.CreateEventExecutionSteps(HttpApplication.EventPostRequestHandlerExecute, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventReleaseRequestState, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPostReleaseRequestState, steps);
                steps.Add(new CallFilterExecutionStep(app));  // filtering
                app.CreateEventExecutionSteps(HttpApplication.EventUpdateRequestCache, steps);
                app.CreateEventExecutionSteps(HttpApplication.EventPostUpdateRequestCache, steps);
                _endRequestStepIndex = steps.Count;
                app.CreateEventExecutionSteps(HttpApplication.EventEndRequest, steps);
                steps.Add(new NoopExecutionStep()); // the last is always there

                _execSteps = new IExecutionStep[steps.Count];
                steps.CopyTo(_execSteps);

                // callback for async completion when reposting to threadpool thread
                _resumeStepsWaitCallback = stepCallback;
            }

            internal override void InitRequest() {
                _currentStepIndex   = -1;
                _numStepCalls       = 0;
                _numSyncStepCalls   = 0;
                _requestCompleted   = false;
            }

            // This attribute prevents undesirable 'just-my-code' debugging behavior (VSWhidbey 404406/VSWhidbey 609188)
            [System.Diagnostics.DebuggerStepperBoundaryAttribute]
            internal override void ResumeSteps(Exception error) {
                bool appCompleted = false;
                bool stepCompletedSynchronously = true;
                HttpApplication app = _application;
                CountdownTask appInstanceConsumersCounter = app.ApplicationInstanceConsumersCounter;
                HttpContext context = app.Context;
                ThreadContext threadContext = null;
                AspNetSynchronizationContextBase syncContext = context.SyncContext;

                Debug.Trace("Async", "HttpApplication.ResumeSteps");

                try {
                    if (appInstanceConsumersCounter != null) {
                        appInstanceConsumersCounter.MarkOperationPending(); // ResumeSteps call started
                    }

                    using (syncContext.AcquireThreadLock()) {
                        // avoid ---- between the app code and fast async completion from a module


                        try {
                            threadContext = app.OnThreadEnter();
                        }
                        catch (Exception e) {
                            if (error == null)
                                error = e;
                        }

                        try {
                            try {
                                for (; ; ) {
                                    // record error

                                    if (syncContext.Error != null) {
                                        error = syncContext.Error;
                                        syncContext.ClearError();
                                    }

                                    if (error != null) {
                                        app.RecordError(error);
                                        error = null;
                                    }

                                    // check for any outstanding async operations

                                    if (syncContext.PendingCompletion(_resumeStepsWaitCallback)) {
                                        // wait until all pending async operations complete
                                        break;
                                    }

                                    // advance to next step

                                    if (_currentStepIndex < _endRequestStepIndex && (context.Error != null || _requestCompleted)) {
                                        // end request
                                        context.Response.FilterOutput();
                                        _currentStepIndex = _endRequestStepIndex;
                                    }
                                    else {
                                        _currentStepIndex++;
                                    }

                                    if (_currentStepIndex >= _execSteps.Length) {
                                        appCompleted = true;
                                        break;
                                    }

                                    // execute the current step

                                    _numStepCalls++;          // count all calls

                                    // enable launching async operations before each new step
                                    syncContext.Enable();

                                    // call to execute current step catching thread abort exception
                                    error = app.ExecuteStep(_execSteps[_currentStepIndex], ref stepCompletedSynchronously);

                                    // unwind the stack in the async case
                                    if (!stepCompletedSynchronously)
                                        break;

                                    _numSyncStepCalls++;      // count synchronous calls
                                }
                            }
                            finally {
                                if (appCompleted) {
                                    // need to raise OnRequestCompleted while within the ThreadContext so that things like User, CurrentCulture, etc. are available
                                    context.RaiseOnRequestCompleted();
                                }

                                if (threadContext != null) {
                                    try {
                                        threadContext.DisassociateFromCurrentThread();
                                    }
                                    catch {
                                    }
                                }
                            }
                        }
                        catch { // Protect against exception filters
                            throw;
                        }

                    }   // using

                    if (appCompleted) {
                        // need to raise OnPipelineCompleted outside of the ThreadContext so that HttpContext.Current, User, etc. are unavailable
                        context.RaiseOnPipelineCompleted();

                        // unroot context (async app operations ended)
                        context.Unroot();

                        // async completion
                        app.AsyncResult.Complete((_numStepCalls == _numSyncStepCalls), null, null);
                        app.ReleaseAppInstance();
                    }
                }
                finally {
                    if (appInstanceConsumersCounter != null) {
                        appInstanceConsumersCounter.MarkOperationCompleted(); // ResumeSteps call complete
                    }
                }
            }
        }

        internal class PipelineStepManager : StepManager {

            WaitCallback _resumeStepsWaitCallback;
            bool _validatePathCalled;
            bool _validateInputCalled;

            internal PipelineStepManager(HttpApplication app): base(app) {
            }

            internal override void BuildSteps(WaitCallback stepCallback) {
                Debug.Trace("PipelineRuntime", "BuildSteps");
                //ArrayList steps = new ArrayList();
                HttpApplication app = _application;

                // add special steps that don't currently
                // correspond to a configured handler

                IExecutionStep materializeStep = new MaterializeHandlerExecutionStep(app);

                // implicit map step
                app.AddEventMapping(
                    HttpApplication.IMPLICIT_HANDLER,
                    RequestNotification.MapRequestHandler,
                    false, materializeStep);

                // implicit async preload step
                app.AddEventMapping(
                    HttpApplication.IMPLICIT_HANDLER,
                    RequestNotification.ExecuteRequestHandler,
                    false, app.CreateImplicitAsyncPreloadExecutionStep());

                // implicit handler routing step
                IExecutionStep handlerStep = new CallHandlerExecutionStep(app);

                app.AddEventMapping(
                    HttpApplication.IMPLICIT_HANDLER,
                    RequestNotification.ExecuteRequestHandler,
                    false, handlerStep);

                // implicit handler WebSockets step
                IExecutionStep webSocketsStep = new TransitionToWebSocketsExecutionStep(app);

                app.AddEventMapping(
                    HttpApplication.IMPLICIT_HANDLER,
                    RequestNotification.EndRequest,
                    true /* isPostNotification */, webSocketsStep);

                // add implicit request filtering step
                IExecutionStep filterStep = new CallFilterExecutionStep(app);

                // normally, this executes during UpdateRequestCache as a high priority module
                app.AddEventMapping(
                    HttpApplication.IMPLICIT_FILTER_MODULE,
                    RequestNotification.UpdateRequestCache,
                    false, filterStep);

                // for error conditions, this executes during LogRequest as a high priority module
                app.AddEventMapping(
                    HttpApplication.IMPLICIT_FILTER_MODULE,
                    RequestNotification.LogRequest,
                    false, filterStep);

                _resumeStepsWaitCallback = stepCallback;
            }

            internal override void InitRequest() {
                _requestCompleted = false;
                _validatePathCalled = false;
                _validateInputCalled = false;
            }

            // PipelineStepManager::ResumeSteps
            // called from IIS7 (on IIS thread) via BeginProcessRequestNotification
            // or from an async completion (on CLR thread) via HttpApplication::ResumeStepsFromThreadPoolThread
            // This attribute prevents undesirable 'just-my-code' debugging behavior (VSWhidbey 404406/VSWhidbey 609188)
            [System.Diagnostics.DebuggerStepperBoundaryAttribute]
            internal override void ResumeSteps(Exception error) {
                HttpContext context = _application.Context;
                IIS7WorkerRequest wr = context.WorkerRequest as IIS7WorkerRequest;
                AspNetSynchronizationContextBase syncContext = context.SyncContext;

                RequestNotificationStatus status = RequestNotificationStatus.Continue;
                ThreadContext threadContext = null;
                bool needToDisassociateThreadContext = false;
                bool isSynchronousCompletion = false;
                bool needToComplete = false;
                bool stepCompletedSynchronously = false;
                bool isReEntry = false;
                int currentModuleLastEventIndex = -1;
                _application.GetNotifcationContextProperties(ref isReEntry, ref currentModuleLastEventIndex);

                CountdownTask appInstanceConsumersCounter = _application.ApplicationInstanceConsumersCounter;

                using (context.RootedObjects.WithinTraceBlock()) {
                    // DevDiv Bugs 187441: IIS7 Integrated Mode: Problem flushing Response from background threads in IIS7 integrated mode
                    if (!isReEntry) // currently we only re-enter for SendResponse
                    {
                        syncContext.AssociateWithCurrentThread();
                    }
                    try {
                        if (appInstanceConsumersCounter != null) {
                            appInstanceConsumersCounter.MarkOperationPending(); // ResumeSteps call started
                        }

                        bool locked = false;
                        try {
                            // As a performance optimization, ASP.NET uses the IIS IHttpContext::IndicateCompletion function to continue executing notifications
                            // on a thread that is associated with the AppDomain.  This is done by calling IndicateCompletion from within the AppDomain, instead
                            // of returning to native code.  This technique can only be used for notifications that complete synchronously.

                            // There are two cases where notifications happen on a thread that has an initialized ThreadContext, and therefore does not need
                            // to call ThreadContext.OnThreadEnter.  These include SendResponse notifications and notifications that occur within a call to
                            // IndicateCompletion.  Note that SendResponse notifications occur on-demand, i.e., they happen when another notification triggers
                            // a SendResponse, at which point it blocks until the SendResponse notification completes.

                            if (!isReEntry) { // currently we only re-enter for SendResponse
                                // DevDiv 482614 (Sharepoint Bug 3137123)
                                // Async completion or SendResponse can happen on a background thread while the thread that called IndicateCompletion has not unwound yet
                                // Therefore (InIndicateCompletion == true) is not a sufficient evidence that we can use the ThreadContext stored in IndicateCompletionContext
                                // To avoid using other thread's ThreadContext we use IndicateCompletionContext only if ThreadInsideIndicateCompletion is indeed our thread
                                if (context.InIndicateCompletion && context.ThreadInsideIndicateCompletion == Thread.CurrentThread) {
                                    // we already have a ThreadContext
                                    threadContext = context.IndicateCompletionContext;
                                    if (context.UsesImpersonation) {
                                        // UsesImpersonation is set to true after RQ_AUTHENTICATE_REQUEST
                                        threadContext.SetImpersonationContext();
                                    }
                                }
                                else {
                                    // we need to create a new ThreadContext
                                    threadContext = _application.OnThreadEnter(context.UsesImpersonation);
                                    // keep track if we need to disassociate it later
                                    needToDisassociateThreadContext = true;
                                }
                            }

                            for (; ; ) {
#if DBG
                                Debug.Trace("PipelineRuntime", "ResumeSteps: CurrentModuleEventIndex=" + context.CurrentModuleEventIndex);
#endif

                                // check and record errors into the HttpContext
                                if (syncContext.Error != null) {
                                    error = syncContext.Error;
                                    syncContext.ClearError();
                                }
                                if (error != null) {
                                    // the error can be cleared by the user
                                    _application.RecordError(error);
                                    error = null;
                                }

                                if (!_validateInputCalled || !_validatePathCalled) {
                                    error = ValidateHelper(context);
                                    if (error != null) {
                                        continue;
                                    }
                                }

                                // check for any outstanding async operations
                                // DevDiv 1020085: User code may leave pending async completions on the synchronization context
                                // while processing nested (isReEntry == true) and not nested (isReEntry == false) notifications.
                                // In both cases only the non nested notification which has proper synchronization should handle it.
                                if (!isReEntry && syncContext.PendingCompletion(_resumeStepsWaitCallback)) {
                                    // Background flushes may trigger RQ_SEND_RESPONSE notifications which will set new context.NotificationContext
                                    // Synchronize access to context.NotificationContext to make sure we update the correct NotificationContext instance
                                    _application.AcquireNotifcationContextLock(ref locked);

                                    // Since the step completed asynchronously, this thread must return RequestNotificationStatus.Pending to IIS,
                                    // and the async completion of this step must call IIS7WorkerRequest::PostCompletion.  The async completion of
                                    // this step will call ResumeSteps again.
                                    context.NotificationContext.PendingAsyncCompletion = true;
                                    break;
                                }

                                // LogRequest and EndRequest never report errors, and never return a status of FinishRequest.
                                bool needToFinishRequest = (context.NotificationContext.Error != null || context.NotificationContext.RequestCompleted)
                                    && context.CurrentNotification != RequestNotification.LogRequest
                                    && context.CurrentNotification != RequestNotification.EndRequest;

                                if (needToFinishRequest || context.CurrentModuleEventIndex == currentModuleLastEventIndex) {

                                    // if an error occured or someone completed the request, set the status to FinishRequest
                                    status = needToFinishRequest ? RequestNotificationStatus.FinishRequest : RequestNotificationStatus.Continue;

                                    // async case
                                    if (context.NotificationContext.PendingAsyncCompletion) {
                                        context.Response.SyncStatusIntegrated();
                                        context.NotificationContext.PendingAsyncCompletion = false;
                                        isSynchronousCompletion = false;
                                        needToComplete = true;
                                        break;
                                    }

                                    // sync case (we might be able to stay in managed code and execute another notification)
                                    if (needToFinishRequest || UnsafeIISMethods.MgdGetNextNotification(wr.RequestContext, RequestNotificationStatus.Continue) != 1) {
                                        isSynchronousCompletion = true;
                                        needToComplete = true;
                                        break;
                                    }

                                    int currentModuleIndex = 0;
                                    bool isPostNotification = false;
                                    int currentNotification = 0;

                                    UnsafeIISMethods.MgdGetCurrentNotificationInfo(wr.RequestContext, out currentModuleIndex, out isPostNotification, out currentNotification);

                                    // setup the HttpContext for this event/module combo
                                    context.CurrentModuleIndex = currentModuleIndex;
                                    context.IsPostNotification = isPostNotification;
                                    context.CurrentNotification = (RequestNotification)currentNotification;
                                    context.CurrentModuleEventIndex = -1;
                                    currentModuleLastEventIndex = _application.CurrentModuleContainer.GetEventCount(context.CurrentNotification, context.IsPostNotification) - 1;
                                }

                                context.CurrentModuleEventIndex++;

                                IExecutionStep step = _application.CurrentModuleContainer.GetNextEvent(context.CurrentNotification, context.IsPostNotification,
                                                                                                       context.CurrentModuleEventIndex);

                                // enable launching async operations before each new step
                                context.SyncContext.Enable();

                                stepCompletedSynchronously = false;
                                error = _application.ExecuteStep(step, ref stepCompletedSynchronously);

#if DBG
                                Debug.Trace("PipelineRuntime", "ResumeSteps: notification=" + context.CurrentNotification.ToString()
                                            + ", isPost=" + context.IsPostNotification
                                            + ", step=" + step.GetType().FullName
                                            + ", completedSync=" + stepCompletedSynchronously
                                            + ", moduleName=" + _application.CurrentModuleContainer.DebugModuleName
                                            + ", moduleIndex=" + context.CurrentModuleIndex
                                            + ", eventIndex=" + context.CurrentModuleEventIndex);
#endif


                                if (!stepCompletedSynchronously) {
                                    // Since the step completed asynchronously, this thread must return RequestNotificationStatus.Pending to IIS,
                                    // and the async completion of this step must call IIS7WorkerRequest::PostCompletion.  The async completion of
                                    // this step will call ResumeSteps again.
                                    //context.AcquireNotifcationContextLockBeforeUnwind();
                                    _application.AcquireNotifcationContextLock(ref locked);
                                    context.NotificationContext.PendingAsyncCompletion = true;
                                    break;
                                }
                                else {
                                    context.Response.SyncStatusIntegrated();
                                }
                            }
                        }
                        finally {
                            if (locked) {
                                _application.ReleaseNotifcationContextLock();
                            }
                            if (threadContext != null) {
                                if (context.InIndicateCompletion) {
                                    if (isSynchronousCompletion) {
                                        // this is a sync completion on an IIS thread
                                        threadContext.Synchronize();
                                        // Note for DevDiv 482614 fix:
                                        // If this threadContext is from IndicateCompletionContext (e.g. this thread called IndicateCompletion)
                                        // then we continue reusing this thread and only undo impersonation before unwinding back to IIS.
                                        //
                                        // If this threadContext was created while another thread was and still is in IndicateCompletion call
                                        // (e.g. sync or async flush on a background thread from native code, not managed since isReEnty==false)
                                        // then we can not reuse this thread and this threadContext will be cleaned before we leave ResumeSteps
                                        // (because needToDisassociateThreadContext was set to true when we created this threadContext)

                                        //always undo impersonation so that the token is removed before returning to IIS (DDB 156421)
                                        threadContext.UndoImpersonationContext();
                                    }
                                    else {
                                        // We're returning pending on an IIS thread in a call to IndicateCompletion.
                                        // Leave the thread context now while we're still under the lock so that the
                                        // async completion does not corrupt the state of HttpContext or IndicateCompletionContext.
                                        if (!threadContext.HasBeenDisassociatedFromThread) {
                                            lock (threadContext) {
                                                if (!threadContext.HasBeenDisassociatedFromThread) {
                                                    threadContext.DisassociateFromCurrentThread();
                                                    // remember to not disassociate again
                                                    needToDisassociateThreadContext = false;
                                                    // DevDiv 482614:
                                                    // Async steps or completions may happen while another thread is inside IndicateCompletion
                                                    // We do not clear IndicateCompletionContext if it belongs to another thread
                                                    // (otherwise future notifications on the thread that called IndicateCompletion won't have
                                                    // context.IndicateCompletionContext pointing to their not yet disassociated ThreadContext)
                                                    if (context.ThreadInsideIndicateCompletion == Thread.CurrentThread) {
                                                        context.IndicateCompletionContext = null;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                else if (isSynchronousCompletion) {
                                    Debug.Assert(needToDisassociateThreadContext == true, "needToDisassociateThreadContext MUST BE true");
                                    // this is a sync completion on an IIS thread
                                    threadContext.Synchronize();
                                    // get ready to call IndicateCompletion
                                    context.IndicateCompletionContext = threadContext;
                                    // Note for DevDiv 482614 fix:
                                    // This thread created a new ThreadContext if it did not call IndicateCompletion yet or if there was 
                                    // another thread already in IndicateCompletion (a background flush from native code or a completion 
                                    // on another thread). In either case if currently there is no thread in IndicateCompletion 
                                    // then we can reuse this thread and its threadContext and call IndicateCompletion on the current thread.
                                    // In this case we will not disassociate this threadContext now
                                    needToDisassociateThreadContext = false;
                                    //always undo impersonation so that the token is removed before returning to IIS (DDB 156421)
                                    threadContext.UndoImpersonationContext();
                                }
                                else {
                                    Debug.Assert(needToDisassociateThreadContext == true, "needToDisassociateThreadContext MUST BE true");
                                    // We're not in a call to IndicateCompletion.  We're either returning pending or
                                    // we're in an async completion, and therefore we must clean-up the thread state. Impersonation is reverted
                                    threadContext.DisassociateFromCurrentThread();
                                    // remember to not disassociate again
                                    needToDisassociateThreadContext = false;
                                }

                                // Cleanup the thread state unless we prepared to call IndicateCompletion or already cleaned up
                                if (needToDisassociateThreadContext) {
                                    threadContext.DisassociateFromCurrentThread();
                                }
                            }
                        }

                        // WOS #1703315: we cannot complete until after OnThreadLeave is called.
                        if (needToComplete) {
                            // call HttpRuntime::OnRequestNotificationCompletion
                            _application.AsyncResult.Complete(isSynchronousCompletion, null /*result*/, null /*error*/, status);
                        }
                    } // end of try statement that begins after AssociateWithCurrentThread
                    finally {
                        if (!isReEntry) {
                            syncContext.DisassociateFromCurrentThread();
                        }
                        if (appInstanceConsumersCounter != null) {
                            appInstanceConsumersCounter.MarkOperationCompleted(); // ResumeSteps call completed
                        }
                    }
                }
            }
            
            private Exception ValidateHelper(HttpContext context) {
                if (!_validateInputCalled) {
                    _validateInputCalled = true;
                    try {
                        context.Request.ValidateInputIfRequiredByConfig();
                    }
                    catch(Exception e) {
                        return e;
                    }
                }
                if (!_validatePathCalled) {
                    _validatePathCalled = true;
                    try {
                        context.ValidatePath();
                    }
                    catch(Exception e) {
                        return e;
                    }
                }
                return null;
            }
        }

        // WARNING: Mutable struct for performance reasons; exercise caution when using this type.
        private struct AsyncStepCompletionInfo {
#pragma warning disable 420 // volatile passed by reference; our uses are safe
            // state for async execution steps
            private const int ASYNC_STATE_NONE = 0;
            private const int ASYNC_STATE_BEGIN_UNWOUND = 1;
            private const int ASYNC_STATE_CALLBACK_COMPLETED = 2;

            private volatile int _asyncState;
            private ExceptionDispatchInfo _error;

            // Invoked from the callback to signal that the End* method has run to completion.
            // Returns 'true' if the current thread should call ResumeSteps, 'false' if not.
            public bool RegisterAsyncCompletion(Exception error) {
                // Before the call to Exchange below, the _asyncCompletionInfo field will have the value
                // ASYNC_STATE_NONE or ASYNC_STATE_BEGIN_UNWOUND. If it's the former, then the Begin* method
                // hasn't yet returned control to IExecutionStep.Execute. From this step's point of view,
                // this can be treated as a synchronous completion, which will allow us to call ResumeSteps
                // on the original thread and save the cost of destroying  the existing ThreadContext and
                // creating a new one. If the original value is instead ASYNC_STATE_BEGIN_UNWOUND, then
                // the Begin* method already returned control to IExecutionStep.Execute and this step was
                // marked as having an asynchronous completion. The original thread will tear down the
                // ThreadContext, so the current thread should call back into ResumeSteps to resurrect it.
                //
                // If there was an error, we'll use the _error field to store it so that IExecutionStep.Execute
                // can rethrow it as it's unwinding.

                // Interlocked performs a volatile write; all processors will see the write to _error as being
                // no later than the write to _asyncState.
                _error = (error != null) ? ExceptionDispatchInfo.Capture(error) : null;
                int originalState = Interlocked.Exchange(ref _asyncState, ASYNC_STATE_CALLBACK_COMPLETED);
                if (originalState == ASYNC_STATE_NONE) {
                    return false; // IExecutionStep.Execute should call ResumeSteps
                }

                Debug.Assert(originalState == ASYNC_STATE_BEGIN_UNWOUND, "Unexpected state.");
                _error = null; // to prevent long-lived exception object; write doesn't need to be volatile since nobody reads this field anyway in this case
                return true; // this thread should call ResumeSteps
            }

            public void RegisterBeginUnwound(IAsyncResult asyncResult, out bool operationCompleted, out bool mustCallEndHandler) {
                operationCompleted = false;
                mustCallEndHandler = false;

                int originalState = Interlocked.Exchange(ref _asyncState, ASYNC_STATE_BEGIN_UNWOUND);
                if (originalState == ASYNC_STATE_NONE) {
                    if (asyncResult.CompletedSynchronously) {
                        // Synchronous completion; the callback either wasn't called or was a no-op.
                        // In either case, we should call the End* method from this thread.
                        operationCompleted = true;
                        mustCallEndHandler = true;
                    }

                    // Otherwise, this is an asynchronous completion, and the callback hasn't yet been invoked or hasn't fully completed.
                    // We'll let the thread that invokes the callback call the End* method.
                }
                else {
                    Debug.Assert(originalState == ASYNC_STATE_CALLBACK_COMPLETED, "Unexpected state.");

                    // The operation completed, and the callback already invoked the End* method.
                    // The only thing we need to do is to report to our caller that the operation completed synchronously
                    // (so that ResumeSteps runs on this thread) and to observe any exceptions that occurred.
                    operationCompleted = true;
                }

                // Interlocked performs a volatile read; if RethrowExceptionIfNecessary() is called after RegisterBeginUnwound(),
                // the thread will see the correct value for the _error field.
            }

            public void ReportError() {
                // Using ExceptionDispatchInfo preserves the Exception's stack trace when rethrowing.
                ExceptionDispatchInfo error = _error;
                if (error != null) {
                    _error = null; // prevent long-lived Exception objects on the heap
                    error.Throw();
                }
            }

            public void Reset() {
                // All processors see the _error field write as being no later than the _asyncState field write.
                _error = null;
                _asyncState = ASYNC_STATE_NONE;
            }
#pragma warning restore 420 // volatile passed by reference
        }

        private class StepInvoker {
            private Action<Action> _action;
            private StepInvoker _nextStep;

            public StepInvoker() { }

            public StepInvoker(Action<Action> action, StepInvoker step) {
                _action = action;
                _nextStep = step;
            }

            public void Invoke(Action executionStep) {
                Debug.Assert(executionStep != null);

                // Call the chained nextStep.
                // The ExecutionStep is garuanteed to execute in HttpApplication,
                // since ExecutionStep could cause reEntry to the pipeline and
                // there is only one StepInvoker instance per HttpApplication instance.
                if (_action != null) {
                    _action(() => _nextStep.Invoke(executionStep));
                } else {
                    executionStep();
                }
            }
        }
    }
}