private void OnAsyncCompletion(IAsyncResult readAsyncResult)
        {
            if (readAsyncResult.CompletedSynchronously)
            {
                return;
            }
            HttpAsyncResult httpAsyncResult = readAsyncResult.AsyncState as HttpAsyncResult;
            Exception       error           = null;

            try {
                int    bytesRead = _inputStream.EndRead(readAsyncResult);
                byte[] buffer    = _app.EntityBuffer;
                // loop to prevent recursive calls and potential stack overflow when it completes synchronously
                while (bytesRead != 0)
                {
                    readAsyncResult = _inputStream.BeginRead(buffer, 0, buffer.Length, _callback, httpAsyncResult);
                    if (!readAsyncResult.CompletedSynchronously)
                    {
                        return;
                    }
                    bytesRead = _inputStream.EndRead(readAsyncResult);
                }
            }
            catch (Exception e) {
                error = e;
            }
            httpAsyncResult.Complete(false, null, error);
        }
 internal override IAsyncResult BeginExecuteUrl(string url, string method, string childHeaders, bool sendHeaders, bool addUserIndo, IntPtr token, string name, string authType, byte[] entity, AsyncCallback cb, object state)
 {
     if (((base._ecb == IntPtr.Zero) || (this._asyncResultOfExecuteUrl != null)) || (sendHeaders && this.HeadersSent()))
     {
         throw new InvalidOperationException(System.Web.SR.GetString("Cannot_execute_url_in_this_context"));
     }
     if (((entity != null) && (entity.Length > 0)) && (UnsafeNativeMethods.EcbGetExecUrlEntityInfo(entity.Length, entity, out this._entity) != 1))
     {
         throw new HttpException(System.Web.SR.GetString("Failed_to_execute_url"));
     }
     HttpAsyncResult result = new HttpAsyncResult(cb, state);
     this._asyncResultOfExecuteUrl = result;
     this._executeUrlCompletionCallback = new ISAPIAsyncCompletionCallback(this.OnExecuteUrlCompletion);
     this._rootedThis = GCHandle.Alloc(this);
     if (UnsafeNativeMethods.EcbExecuteUrlUnicode(base._ecb, url, method, childHeaders, sendHeaders, addUserIndo, token, name, authType, this._entity, this._executeUrlCompletionCallback) != 1)
     {
         if (this._entity != IntPtr.Zero)
         {
             UnsafeNativeMethods.EcbFreeExecUrlEntityInfo(this._entity);
         }
         this._rootedThis.Free();
         this._asyncResultOfExecuteUrl = null;
         throw new HttpException(System.Web.SR.GetString("Failed_to_execute_url"));
     }
     if (sendHeaders)
     {
         this._headersSentFromExecuteUrl = true;
     }
     return result;
 }
        private IAsyncResult OnEnter(Object sender, EventArgs e, AsyncCallback cb, Object state) {
            Debug.Assert(_inputStream == null);
            _app = (HttpApplication)sender;
            HttpContext context = _app.Context;
            HttpRequest request = context.Request;
            HttpWorkerRequest wr = context.WorkerRequest;
            HttpAsyncResult httpAsyncResult = new HttpAsyncResult(cb, state);
            AsyncPreloadModeFlags asyncPreloadMode = context.AsyncPreloadMode;
            int contentLength;
            bool isForm = false;
            bool isFormMultiPart = false;

            if (asyncPreloadMode == AsyncPreloadModeFlags.None
                || request.ReadEntityBodyMode != ReadEntityBodyMode.None
                || wr == null
                || !wr.SupportsAsyncRead
                || !wr.HasEntityBody()
                || wr.IsEntireEntityBodyIsPreloaded()
                || context.Handler == null
                || context.Handler is TransferRequestHandler
                || context.Handler is DefaultHttpHandler
                || (contentLength = request.ContentLength) > RuntimeConfig.GetConfig(context).HttpRuntime.MaxRequestLengthBytes
                || ((isForm = StringUtil.StringStartsWithIgnoreCase(request.ContentType, "application/x-www-form-urlencoded"))
                    && (asyncPreloadMode & AsyncPreloadModeFlags.Form) != AsyncPreloadModeFlags.Form)
                || ((isFormMultiPart = StringUtil.StringStartsWithIgnoreCase(request.ContentType, "multipart/form-data"))
                    && (asyncPreloadMode & AsyncPreloadModeFlags.FormMultiPart) != AsyncPreloadModeFlags.FormMultiPart)
                || !isForm && !isFormMultiPart && (asyncPreloadMode & AsyncPreloadModeFlags.NonForm) != AsyncPreloadModeFlags.NonForm
                ) {
                Debug.Trace("AsyncPreload", " *** AsyncPreload skipped *** ");
                httpAsyncResult.Complete(true, null, null);
                return httpAsyncResult;
            }

            Debug.Trace("AsyncPreload", " *** AsyncPreload started *** ");
            try {
                if (_callback == null) {
                    _callback = new AsyncCallback(OnAsyncCompletion);
                }
                _inputStream = request.GetBufferedInputStream();
                byte[] buffer = _app.EntityBuffer;
                int bytesRead = 0;
                // loop to prevent recursive calls and potential stack overflow if/when it completes synchronously
                do {
                    IAsyncResult readAsyncResult = _inputStream.BeginRead(buffer, 0, buffer.Length, _callback, httpAsyncResult);
                    if (!readAsyncResult.CompletedSynchronously) {
                        return httpAsyncResult;
                    }
                    bytesRead = _inputStream.EndRead(readAsyncResult);
                } while (bytesRead != 0);
            }
            catch {
                Reset();
                throw;
            }
            httpAsyncResult.Complete(true, null, null);
            return httpAsyncResult;
        }
 internal HttpAsyncResult ExecuteTasks(AsyncCallback callback, object extraData)
 {
     this._failedToStart = false;
     this._timeoutEnd = DateTime.UtcNow + this._page.AsyncTimeout;
     this._timeoutEndReached = false;
     this._tasksStarted = 0;
     this._tasksCompleted = 0;
     this._asyncResult = new HttpAsyncResult(callback, extraData);
     bool waitUntilDone = callback == null;
     if (waitUntilDone)
     {
         try
         {
         }
         finally
         {
             try
             {
                 Monitor.Exit(this._app);
                 Monitor.Enter(this._app);
             }
             catch (SynchronizationLockException)
             {
                 this._failedToStart = true;
                 throw new InvalidOperationException(System.Web.SR.GetString("Async_tasks_wrong_thread"));
             }
         }
     }
     this._inProgress = true;
     try
     {
         this.ResumeTasks(waitUntilDone, true);
     }
     finally
     {
         if (waitUntilDone)
         {
             this._inProgress = false;
         }
     }
     return this._asyncResult;
 }
 internal IAsyncResult BeginAspCompatExecution(AsyncCallback cb, object extraData)
 {
     if (IsInAspCompatMode)
     {
         bool completedSynchronously = true;
         Exception error = this._app.ExecuteStep(this, ref completedSynchronously);
         this._ar = new HttpAsyncResult(cb, extraData, true, null, error);
         this._syncCaller = true;
     }
     else
     {
         this._ar = new HttpAsyncResult(cb, extraData);
         this._syncCaller = cb == null;
         this._rootedThis = GCHandle.Alloc(this);
         bool sharedActivity = this._sessionId != null;
         int activityHash = sharedActivity ? this._sessionId.GetHashCode() : 0;
         if (System.Web.UnsafeNativeMethods.AspCompatProcessRequest(this._execCallback, this, sharedActivity, activityHash) != 1)
         {
             this._rootedThis.Free();
             this._ar.Complete(true, null, new HttpException(System.Web.SR.GetString("Cannot_access_AspCompat")));
         }
     }
     return this._ar;
 }
		IAsyncResult IHttpAsyncHandler.BeginProcessRequest (HttpContext context,
								    AsyncCallback cb,
								    object extraData)
		{
			_Context = context;
			_Context.ApplicationInstance = this;
			_CompleteRequest = false;

			_asyncWebResult = new HttpAsyncResult (cb, extraData);

			_state.Start ();

			return _asyncWebResult;
		}
    internal HttpAsyncResult ExecuteTasks(AsyncCallback callback, Object extraData) {
        _failedToStart = false;
        _timeoutEnd = DateTime.UtcNow + _page.AsyncTimeout;
        _timeoutEndReached = false;
        _tasksStarted = 0;
        _tasksCompleted = 0;

        _asyncResult = new HttpAsyncResult(callback, extraData);

        bool waitUntilDone = (callback == null);

        if (waitUntilDone) {
            // when requested to wait for tasks, before starting tasks
            // make sure that the lock can be suspended.
            try {} finally {
                try {
                    // disassociating allows other pending work to take place, and associating will block until that work is complete
                    _app.Context.SyncContext.DisassociateFromCurrentThread();
                    _app.Context.SyncContext.AssociateWithCurrentThread();
                }
                catch (SynchronizationLockException) {
                    _failedToStart = true;
                    throw new InvalidOperationException(SR.GetString(SR.Async_tasks_wrong_thread));
                }
            }
        }

        _inProgress = true;

        try {
            // all work done here:
            ResumeTasks(waitUntilDone, true /*onCallerThread*/);
        }
        finally {
            if (waitUntilDone) {
                _inProgress = false;
            }
        }

        return _asyncResult;
    }
    private void OnExecuteUrlCompletion(IntPtr ecb, int byteCount, int error) {
        if (_entity != IntPtr.Zero) {
            UnsafeNativeMethods.EcbFreeExecUrlEntityInfo(_entity);
        }

        _rootedThis.Free();

        Debug.Trace("ExecuteUrl", "ISAPIWorkerRequestInProcForIIS6.OnExecuteUrlCompletion");

        // signal async caller to resume work
        HttpAsyncResult asyncResult = _asyncResultOfExecuteUrl;
        _asyncResultOfExecuteUrl = null;
        asyncResult.Complete(false, null, null);
    }
    internal override IAsyncResult BeginExecuteUrl(
                                        String url, String method, String childHeaders,
                                        bool sendHeaders,
                                        bool addUserIndo, IntPtr token, String name, String authType,
                                        byte[] entity,
                                        AsyncCallback cb, Object state) {

        if (_ecb == IntPtr.Zero ||              // after done with session
            _asyncResultOfExecuteUrl != null || // another ExecuteUrl in progress
            (sendHeaders && HeadersSent()))     // asked to send headers, but already sent them
        {
            throw new InvalidOperationException(SR.GetString(SR.Cannot_execute_url_in_this_context));
        }

        if (entity != null && entity.Length > 0) {
            int ret = UnsafeNativeMethods.EcbGetExecUrlEntityInfo(entity.Length, entity, out _entity);
            if (ret != 1) {
                throw new HttpException(SR.GetString(SR.Failed_to_execute_url));
            }
        }

        Debug.Trace("ExecuteUrl", "ISAPIWorkerRequestInProcForIIS6.BeginExecuteUrl: url=\"" + url + "\".");


        HttpAsyncResult ar = new HttpAsyncResult(cb, state);
        _asyncResultOfExecuteUrl = ar;

        _executeUrlCompletionCallback = new ISAPIAsyncCompletionCallback(OnExecuteUrlCompletion);
        _rootedThis = GCHandle.Alloc(this); // root for the duration of ExecuteUrl

        int rc;
        try {
            ar.MarkCallToBeginMethodStarted();
            rc = UnsafeNativeMethods.EcbExecuteUrlUnicode(_ecb,
                                        url, method, childHeaders,
                                        sendHeaders,
                                        addUserIndo, token, name, authType,
                                        _entity,
                                        _executeUrlCompletionCallback);
        }
        finally {
            ar.MarkCallToBeginMethodCompleted();
        }

        if (rc != 1) {
            if (_entity != IntPtr.Zero) {
                UnsafeNativeMethods.EcbFreeExecUrlEntityInfo(_entity);
            }
            _rootedThis.Free();
            _asyncResultOfExecuteUrl = null;

            Debug.Trace("ExecuteUrl", "ISAPIWorkerRequestInProcForIIS6.BeginExecuteUrl: failed!");

            throw new HttpException(SR.GetString(SR.Failed_to_execute_url));
        }

        if (sendHeaders) {
            // ExecuteUrl will send headers, worker request should not
            _headersSentFromExecuteUrl = true;
        }

        return ar;
    }
		IAsyncResult OnBeginRequestCache (object o, EventArgs args, AsyncCallback cb, object data)
		{
			HttpApplication app = (HttpApplication) o;
			HttpContext context = app.Context;
			
			string vary_key = context.Request.FilePath;
			CachedVaryBy varyby = context.Cache [vary_key] as CachedVaryBy;
			string key;
			CachedRawResponse c;

			if (varyby == null)
				goto leave;

			key = varyby.CreateKey (vary_key, context);
			c = context.Cache [key] as CachedRawResponse;
			
			if (c != null) {
				
				context.Response.ClearContent ();
				context.Response.BinaryWrite (c.GetData (), 0, c.ContentLength);

				context.Response.ClearHeaders ();
				c.DateHeader.Value = TimeUtil.ToUtcTimeString (DateTime.Now);
				context.Response.SetCachedHeaders (c.Headers);

				context.Response.StatusCode = c.StatusCode;
				context.Response.StatusDescription = c.StatusDescription;
				
				app.CompleteRequest ();
			} 

		leave:
			HttpAsyncResult result = new HttpAsyncResult (cb,this);
			result.Complete (true, o, null);
			
			return result;
		}
		IAsyncResult OnBeginUpdateCache (object o, EventArgs args, AsyncCallback cb, object data)
		{
			HttpApplication app = (HttpApplication) o;
			HttpContext context = app.Context;
			HttpAsyncResult result;

			if (context.Response.IsCached && context.Response.StatusCode == 200 && 
			    !context.Trace.IsEnabled)
				DoCacheInsert (context);

			result = new HttpAsyncResult (cb, this);
			result.Complete (true, o, null);
			return result;
		}
 internal IAsyncResult BeginProcessRequestNotification(HttpContext context, AsyncCallback cb)
 {
     if (this._context == null)
     {
         this.AssignContext(context);
     }
     context.CurrentModuleEventIndex = -1;
     HttpAsyncResult result = new HttpAsyncResult(cb, context);
     context.NotificationContext.AsyncResult = result;
     this.ResumeSteps(null);
     return result;
 }
        //
        // 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;
        }
    internal /*public*/ IAsyncResult BeginAspCompatExecution(AsyncCallback cb, object extraData) {
        SynchronizationContextUtil.ValidateModeForAspCompat();

        if (IsInAspCompatMode) {
            // already in AspCompatMode -- execute synchronously
            bool sync = true;
            Exception error = _app.ExecuteStep(this, ref sync);
            _ar = new HttpAsyncResult(cb, extraData, true, null, error);
            _syncCaller = true;
        }
        else {
            _ar = new HttpAsyncResult(cb, extraData);
            _syncCaller = (cb == null);
            _rootedThis = GCHandle.Alloc(this);

            // send requests from the same session to the same STA thread
            bool sharedActivity = (_sessionId != null);
            int    activityHash = sharedActivity ? _sessionId.GetHashCode() : 0;

            if (UnsafeNativeMethods.AspCompatProcessRequest(_execCallback, this, sharedActivity, activityHash) != 1) {
                // failed to queue up the execution in ASP compat mode
                _rootedThis.Free();
                _ar.Complete(true, null, new HttpException(SR.GetString(SR.Cannot_access_AspCompat)));
            }
        }

        return _ar;
    }
 private void ResetPerRequestFields()
 {
     this._rqSessionState = null;
     this._rqId = null;
     this._rqSessionItems = null;
     this._rqStaticObjects = null;
     this._rqIsNewSession = false;
     this._rqSessionStateNotFound = true;
     this._rqReadonly = false;
     this._rqItem = null;
     this._rqContext = null;
     this._rqAr = null;
     this._rqLockId = null;
     this._rqInCallback = 0;
     this._rqLastPollCompleted = DateTime.MinValue;
     this._rqExecutionTimeout = TimeSpan.Zero;
     this._rqAddedCookie = false;
     this._rqIdNew = false;
     this._rqActionFlags = SessionStateActions.None;
     this._rqIctx = null;
     this._rqChangeImpersonationRefCount = 0;
     this._rqTimerThreadImpersonationIctx = null;
     this._rqSupportSessionIdReissue = false;
 }
 private IAsyncResult BeginAcquireState(object source, EventArgs e, AsyncCallback cb, object extraData)
 {
     IAsyncResult result;
     bool sessionStateItem = true;
     bool flag3 = false;
     this._acquireCalled = true;
     this._releaseCalled = false;
     this.ResetPerRequestFields();
     this._rqContext = ((HttpApplication) source).Context;
     this._rqAr = new HttpAsyncResult(cb, extraData);
     this.ChangeImpersonation(this._rqContext, false);
     try
     {
         if (EtwTrace.IsTraceEnabled(4, 8))
         {
             EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_BEGIN, this._rqContext.WorkerRequest);
         }
         this._store.InitializeRequest(this._rqContext);
         bool requiresSessionState = this._rqContext.RequiresSessionState;
         if (this._idManager.InitializeRequest(this._rqContext, false, out this._rqSupportSessionIdReissue))
         {
             this._rqAr.Complete(true, null, null);
             if (EtwTrace.IsTraceEnabled(4, 8))
             {
                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, this._rqContext.WorkerRequest);
             }
             return this._rqAr;
         }
         if ((s_allowInProcOptimization && !s_sessionEverSet) && (!requiresSessionState || !((SessionIDManager) this._idManager).UseCookieless(this._rqContext)))
         {
             flag3 = true;
         }
         else
         {
             this._rqId = this._idManager.GetSessionID(this._rqContext);
         }
         if (!requiresSessionState)
         {
             if (this._rqId != null)
             {
                 this._store.ResetItemTimeout(this._rqContext, this._rqId);
             }
             this._rqAr.Complete(true, null, null);
             if (EtwTrace.IsTraceEnabled(4, 8))
             {
                 EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, this._rqContext.WorkerRequest);
             }
             return this._rqAr;
         }
         this._rqExecutionTimeout = this._rqContext.Timeout;
         if (this._rqExecutionTimeout == DEFAULT_DBG_EXECUTION_TIMEOUT)
         {
             this._rqExecutionTimeout = s_configExecutionTimeout;
         }
         this._rqReadonly = this._rqContext.ReadOnlySessionState;
         if (this._rqId != null)
         {
             sessionStateItem = this.GetSessionStateItem();
         }
         else if (!flag3)
         {
             bool flag4 = this.CreateSessionId();
             this._rqIdNew = true;
             if (flag4)
             {
                 if (s_configRegenerateExpiredSessionId)
                 {
                     this.CreateUninitializedSessionState();
                 }
                 this._rqAr.Complete(true, null, null);
                 if (EtwTrace.IsTraceEnabled(4, 8))
                 {
                     EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, this._rqContext.WorkerRequest);
                 }
                 return this._rqAr;
             }
         }
         if (sessionStateItem)
         {
             this.CompleteAcquireState();
             this._rqAr.Complete(true, null, null);
         }
         result = this._rqAr;
     }
     finally
     {
         this.RestoreImpersonation();
     }
     return result;
 }
        private IAsyncResult OnEnter(Object sender, EventArgs e, AsyncCallback cb, Object state)
        {
            Debug.Assert(_inputStream == null);
            _app = (HttpApplication)sender;
            HttpContext           context          = _app.Context;
            HttpRequest           request          = context.Request;
            HttpWorkerRequest     wr               = context.WorkerRequest;
            HttpAsyncResult       httpAsyncResult  = new HttpAsyncResult(cb, state);
            AsyncPreloadModeFlags asyncPreloadMode = context.AsyncPreloadMode;
            int  contentLength;
            bool isForm          = false;
            bool isFormMultiPart = false;

            if (asyncPreloadMode == AsyncPreloadModeFlags.None ||
                request.ReadEntityBodyMode != ReadEntityBodyMode.None ||
                wr == null ||
                !wr.SupportsAsyncRead ||
                !wr.HasEntityBody() ||
                wr.IsEntireEntityBodyIsPreloaded() ||
                context.Handler == null ||
                context.Handler is TransferRequestHandler ||
                context.Handler is DefaultHttpHandler ||
                (contentLength = request.ContentLength) > RuntimeConfig.GetConfig(context).HttpRuntime.MaxRequestLengthBytes ||
                ((isForm = StringUtil.StringStartsWithIgnoreCase(request.ContentType, "application/x-www-form-urlencoded")) &&
                 (asyncPreloadMode & AsyncPreloadModeFlags.Form) != AsyncPreloadModeFlags.Form) ||
                ((isFormMultiPart = StringUtil.StringStartsWithIgnoreCase(request.ContentType, "multipart/form-data")) &&
                 (asyncPreloadMode & AsyncPreloadModeFlags.FormMultiPart) != AsyncPreloadModeFlags.FormMultiPart) ||
                !isForm && !isFormMultiPart && (asyncPreloadMode & AsyncPreloadModeFlags.NonForm) != AsyncPreloadModeFlags.NonForm
                )
            {
                Debug.Trace("AsyncPreload", " *** AsyncPreload skipped *** ");
                httpAsyncResult.Complete(true, null, null);
                return(httpAsyncResult);
            }

            Debug.Trace("AsyncPreload", " *** AsyncPreload started *** ");
            try {
                if (_callback == null)
                {
                    _callback = new AsyncCallback(OnAsyncCompletion);
                }
                _inputStream = request.GetBufferedInputStream();
                byte[] buffer    = _app.EntityBuffer;
                int    bytesRead = 0;
                // loop to prevent recursive calls and potential stack overflow if/when it completes synchronously
                do
                {
                    IAsyncResult readAsyncResult = _inputStream.BeginRead(buffer, 0, buffer.Length, _callback, httpAsyncResult);
                    if (!readAsyncResult.CompletedSynchronously)
                    {
                        return(httpAsyncResult);
                    }
                    bytesRead = _inputStream.EndRead(readAsyncResult);
                } while (bytesRead != 0);
            }
            catch {
                Reset();
                throw;
            }
            httpAsyncResult.Complete(true, null, null);
            return(httpAsyncResult);
        }
		IAsyncResult OnBeginAcquireState (object o, EventArgs args, AsyncCallback cb, object data)
		{
			HttpApplication application = (HttpApplication) o;
			HttpContext context = application.Context;

			bool required = (context.Handler is IRequiresSessionState);
			
			// This is a hack. Sites that use Session in global.asax event handling code
			// are not supposed to get a Session object for static files, but seems that
			// IIS handles those files before getting there and thus they are served without
			// error.
			// As a workaround, setting MONO_XSP_STATIC_SESSION variable make this work
			// on mono, but you lose performance when serving static files.
			if (sessionForStaticFiles && context.Handler is StaticFileHandler)
				required = true;
			// hack end

			bool read_only = (context.Handler is IReadOnlySessionState);
			
			bool isNew = false;
			HttpSessionState session = null;
			if (handler != null)
				session = handler.UpdateContext (context, this, required, read_only, ref isNew);

			if (session != null) {
				if (isNew)
					session.SetNewSession (true);

				if (read_only)
					session = session.Clone ();
					
				context.SetSession (session);

				if (isNew && config.CookieLess) {
					string id = context.Session.SessionID;
					context.Request.SetHeader (HeaderName, id);
					context.Response.Redirect (UrlUtils.InsertSessionId (id,
								   context.Request.FilePath));
				} else if (isNew) {
					string id = context.Session.SessionID;
					HttpCookie cookie = new HttpCookie (CookieName, id);
					cookie.Path = UrlUtils.GetDirectory (context.Request.ApplicationPath);
					context.Response.AppendCookie (cookie);
				}
			}
			
			// In the future, we might want to move the Async stuff down to
			// the interface level, if we're going to support other than
			// InProc, we might actually want to do things async, now we
			// simply fake it.
			HttpAsyncResult result=new HttpAsyncResult (cb,this);
			result.Complete (true, o, null);
			if (isNew && Start != null)
				Start (this, args);

			return result;
		}
 private void OnExecuteUrlCompletion(IntPtr ecb, int byteCount, int error)
 {
     if (this._entity != IntPtr.Zero)
     {
         UnsafeNativeMethods.EcbFreeExecUrlEntityInfo(this._entity);
     }
     this._rootedThis.Free();
     HttpAsyncResult result = this._asyncResultOfExecuteUrl;
     this._asyncResultOfExecuteUrl = null;
     result.Complete(false, null, null);
 }
        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;
        }
 IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
 {
     this._context = context;
     this._context.ApplicationInstance = this;
     this._stepManager.InitRequest();
     this._context.Root();
     HttpAsyncResult result = new HttpAsyncResult(cb, extraData);
     this.AsyncResult = result;
     if (this._context.TraceIsEnabled)
     {
         HttpRuntime.Profile.StartRequest(this._context);
     }
     this.ResumeSteps(null);
     return result;
 }