path: root/mcs/class/referencesource/System.Web/UI/Page.cs

//------------------------------------------------------------------------------
// <copyright file="Page.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

// Uncomment out this line to display rare field statistics at the end of the page
//#define DISPLAYRAREFIELDSTATISTICS

/*
 * Page class definition
 *
 * Copyright (c) 1998 Microsoft Corporation
 */

namespace System.Web.UI {

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Configuration;
using System.EnterpriseServices;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Security;
using System.Security.Permissions;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Web.Caching;
using System.Web.Compilation;
using System.Web.Configuration;
using System.Web.Handlers;
using System.Web.Hosting;
using System.Web.Management;
using System.Web.RegularExpressions;
using System.Web.Security;
using System.Web.SessionState;
using System.Web.UI.Adapters;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.Util;
using System.Xml;
using System.Web.Routing;
using System.Web.ModelBinding;
using System.Web.Security.Cryptography;



/// <devdoc>
///    Default ControlBuilder used to parse page files.
/// </devdoc>
public class FileLevelPageControlBuilder: RootBuilder {

    private ArrayList _contentBuilderEntries;
    private ControlBuilder _firstControlBuilder;
    private int _firstLiteralLineNumber;
    private bool _containsContentPage;
    private string _firstLiteralText;

    internal ICollection ContentBuilderEntries {
        get {
            return _contentBuilderEntries;
        }
    }

    public override void AppendLiteralString(string text) {
        if (_firstLiteralText == null) {
            if (!Util.IsWhiteSpaceString(text)) {
                int iFirstNonWhiteSpace = Util.FirstNonWhiteSpaceIndex(text);
                if (iFirstNonWhiteSpace < 0) iFirstNonWhiteSpace = 0;
                _firstLiteralLineNumber = Parser._lineNumber - Util.LineCount(text, iFirstNonWhiteSpace, text.Length);
                _firstLiteralText = text;

                if (_containsContentPage) {
                    throw new HttpException(SR.GetString(SR.Only_Content_supported_on_content_page));
                }
            }
        }

        base.AppendLiteralString(text);
    }

    public override void AppendSubBuilder(ControlBuilder subBuilder) {
        // Tell the sub builder that it's about to be appended to its parent

        if (subBuilder is ContentBuilderInternal) {
            ContentBuilderInternal contentBuilder = (ContentBuilderInternal)subBuilder;

            _containsContentPage = true;

            if (_contentBuilderEntries == null) {
                _contentBuilderEntries = new ArrayList();
            }

            if (_firstLiteralText != null) {
                throw new HttpParseException(SR.GetString(SR.Only_Content_supported_on_content_page),
                    null, Parser.CurrentVirtualPath, _firstLiteralText, _firstLiteralLineNumber);
            }

            if (_firstControlBuilder != null) {
                Parser._lineNumber = _firstControlBuilder.Line;
                throw new HttpException(SR.GetString(SR.Only_Content_supported_on_content_page));
            }

            TemplatePropertyEntry entry = new TemplatePropertyEntry();
            entry.Filter = contentBuilder.ContentPlaceHolderFilter;
            entry.Name = contentBuilder.ContentPlaceHolder;
            entry.Builder = contentBuilder;

            _contentBuilderEntries.Add(entry);
        }
        else {
            if (_firstControlBuilder == null) {
                if (_containsContentPage) {
                    throw new HttpException(SR.GetString(SR.Only_Content_supported_on_content_page));
                }

                _firstControlBuilder = subBuilder;
            }
        }

        base.AppendSubBuilder(subBuilder);
    }

    internal override void InitObject(object obj) {
        base.InitObject(obj);

        if (_contentBuilderEntries == null)
            return;

        ICollection entries = GetFilteredPropertyEntrySet(_contentBuilderEntries);

        foreach(TemplatePropertyEntry entry in entries) {
            ContentBuilderInternal contentBuilder = (ContentBuilderInternal)entry.Builder;
            try {
                contentBuilder.SetServiceProvider(ServiceProvider);

                // Note that 'obj' can be either a Page or a MasterPage,
                // hence the need for this virtual method.
                AddContentTemplate(obj, contentBuilder.ContentPlaceHolder, contentBuilder.BuildObject() as ITemplate);
            }
            finally {
                contentBuilder.SetServiceProvider(null);
            }
        }
    }

    internal virtual void AddContentTemplate(object obj, string templateName, ITemplate template) {
        Page page = (Page)obj;
        page.AddContentTemplate(templateName, template);
    }

    internal override void SortEntries() {
        base.SortEntries();

        FilteredPropertyEntryComparer comparer = null;
        ProcessAndSortPropertyEntries(_contentBuilderEntries, ref comparer);
    }
}

/// <devdoc>
///    <para>
///       Defines the properties, methods, and events common to
///       all pages that are processed on the server by the Web Forms page framework.
///    <see langword='Page '/>
///    objects are compiled and cached in
///    memory when any ASP.NET page is
///    requested.</para>
///    <para>This class is not marked as abstract, because the VS designer
///          needs to instantiate it when opening .ascx files</para>
/// </devdoc>
[
DefaultEvent("Load"),
Designer("Microsoft.VisualStudio.Web.WebForms.WebFormDesigner, " + AssemblyRef.MicrosoftVisualStudioWeb, typeof(IRootDesigner)),
DesignerCategory("ASPXCodeBehind"),
DesignerSerializer("Microsoft.VisualStudio.Web.WebForms.WebFormCodeDomSerializer, " + AssemblyRef.MicrosoftVisualStudioWeb,  "System.ComponentModel.Design.Serialization.TypeCodeDomSerializer, " + AssemblyRef.SystemDesign),
ToolboxItem(false)
]
public class Page: TemplateControl, IHttpHandler {
    private const string HiddenClassName = "aspNetHidden";
    private const string PageID = "__Page";
    private const string PageScrollPositionScriptKey = "PageScrollPositionScript";
    private const string PageSubmitScriptKey = "PageSubmitScript";
    private const string PageReEnableControlsScriptKey = "PageReEnableControlsScript";

    // NOTE: Make sure this stays in sync with MobilePage.PageRegisteredControlsThatRequirePostBackKey
    // 
    private const string PageRegisteredControlsThatRequirePostBackKey = "__ControlsRequirePostBackKey__";

    private const string EnabledControlArray = "__enabledControlArray";

    //used by TemplateControl to hookup auto-events
    internal static readonly object EventPreRenderComplete = new Object();
    internal static readonly object EventPreLoad = new object();
    internal static readonly object EventLoadComplete = new object();
    internal static readonly object EventPreInit = new object();
    internal static readonly object EventInitComplete = new object();
    internal static readonly object EventSaveStateComplete = new object();

    private static readonly Version FocusMinimumEcmaVersion = new Version("1.4");
    private static readonly Version FocusMinimumJScriptVersion = new Version("3.0");
    private static readonly Version JavascriptMinimumVersion = new Version("1.0");
    private static readonly Version MSDomScrollMinimumVersion = new Version("4.0");

    // Review: this is consistent with MMIT legacy -do we prefer two underscores?
    private static readonly string     UniqueFilePathSuffixID = "__ufps";
    private string _uniqueFilePathSuffix;

    internal static readonly int DefaultMaxPageStateFieldLength = -1;
    internal static readonly int DefaultAsyncTimeoutSeconds = 45;

    private int _maxPageStateFieldLength = DefaultMaxPageStateFieldLength;
    private string _requestViewState;
    private bool _cachedRequestViewState;

    private PageAdapter _pageAdapter;

    // Has the page layout changed since last request
    private bool _fPageLayoutChanged;

    private bool _haveIdSeparator;
    private char _idSeparator;

    // Session state
    private bool                _sessionRetrieved;
    private HttpSessionState    _session;

    private int _transactionMode; /* 0 = TransactionOption.Disabled*/
    private bool _aspCompatMode;
    private bool _asyncMode;

    // Async related
    private static readonly TimeSpan _maxAsyncTimeout = TimeSpan.FromMilliseconds(Int32.MaxValue);
    private TimeSpan _asyncTimeout;
    private bool _asyncTimeoutSet;

    private PageAsyncTaskManager _asyncTaskManager;
    private LegacyPageAsyncTaskManager _legacyAsyncTaskManager;
    private LegacyPageAsyncInfo _legacyAsyncInfo;

    // Page culture and uiculture set dynamically
    private CultureInfo _dynamicCulture;
    private CultureInfo _dynamicUICulture;

    // ViewState
    private string _clientState;
    private PageStatePersister _persister;
    internal ControlSet _registeredControlsRequiringControlState;
    private StringSet _controlStateLoadedControlIds;
    internal HybridDictionary _registeredControlsRequiringClearChildControlState;
    internal const ViewStateEncryptionMode EncryptionModeDefault = ViewStateEncryptionMode.Auto;
    private ViewStateEncryptionMode _encryptionMode = EncryptionModeDefault;
    private bool _viewStateEncryptionRequested;

    private ArrayList _enabledControls;

    // Http Intrinsics
    internal HttpRequest _request;
    internal HttpResponse _response;
    internal HttpApplicationState _application;
    internal Cache _cache;

    internal string _errorPage;
    private string _clientTarget;

    // Form related fields
    private HtmlForm _form;
    private bool _inOnFormRender;
    private bool _fOnFormRenderCalled;
    private bool _fRequireWebFormsScript;
    private bool _fWebFormsScriptRendered;
    private bool _fRequirePostBackScript;
    private bool _fPostBackScriptRendered;
    private bool _containsCrossPagePost;
    private RenderMethod _postFormRenderDelegate;
    internal Dictionary<String, String> _hiddenFieldsToRender;

    private bool _requireFocusScript;

    private bool _profileTreeBuilt;

    internal const bool MaintainScrollPositionOnPostBackDefault = false;
    private bool _maintainScrollPosition = MaintainScrollPositionOnPostBackDefault;

    private ClientScriptManager _clientScriptManager;

    // Needed to support Validators in AJAX 1.0 (Windows OS Bugs 2015831)
    private static Type _scriptManagerType;

    internal const bool EnableViewStateMacDefault = true;
    internal const bool EnableEventValidationDefault = true;

    internal const string systemPostFieldPrefix = "__";

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public const string postEventSourceID = systemPostFieldPrefix + "EVENTTARGET";

    private const string lastFocusID = systemPostFieldPrefix + "LASTFOCUS";
    private const string _scrollPositionXID = systemPostFieldPrefix + "SCROLLPOSITIONX";
    private const string _scrollPositionYID = systemPostFieldPrefix + "SCROLLPOSITIONY";

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public const string postEventArgumentID = systemPostFieldPrefix + "EVENTARGUMENT";

    internal const string ViewStateFieldPrefixID = systemPostFieldPrefix + "VIEWSTATE";
    internal const string ViewStateFieldCountID = ViewStateFieldPrefixID + "FIELDCOUNT";
    internal const string ViewStateGeneratorFieldID = ViewStateFieldPrefixID + "GENERATOR";
    internal const string ViewStateEncryptionID = systemPostFieldPrefix + "VIEWSTATEENCRYPTED";
    internal const string EventValidationPrefixID = systemPostFieldPrefix + "EVENTVALIDATION";
    // Any change in this constant must be duplicated in DetermineIsExportingWebPart
    internal const string WebPartExportID = systemPostFieldPrefix + "WEBPARTEXPORT";

    private bool _requireScrollScript;
    private bool _isCallback;
    private bool _isCrossPagePostBack;
    private bool _containsEncryptedViewState;
    private bool _enableEventValidation = EnableEventValidationDefault;
    internal const string callbackID = systemPostFieldPrefix + "CALLBACKID";
    internal const string callbackParameterID = systemPostFieldPrefix + "CALLBACKPARAM";
    internal const string callbackLoadScriptID = systemPostFieldPrefix + "CALLBACKLOADSCRIPT";
    internal const string callbackIndexID = systemPostFieldPrefix + "CALLBACKINDEX";

    internal const string previousPageID = systemPostFieldPrefix + "PREVIOUSPAGE";

    // BasePartialCachingControl's currently on the stack
    private Stack _partialCachingControlStack;

    private ArrayList   _controlsRequiringPostBack;
    private ArrayList   _registeredControlsThatRequirePostBack;
    private NameValueCollection _leftoverPostData;
    private IPostBackEventHandler _registeredControlThatRequireRaiseEvent;
    private ArrayList _changedPostDataConsumers;

    private bool _needToPersistViewState;
    private bool _enableViewStateMac;
    private string _viewStateUserKey;

    private string _themeName;
    private PageTheme _theme;
    private string _styleSheetName;
    private PageTheme _styleSheet;

    private VirtualPath _masterPageFile;
    private MasterPage _master;
    private IDictionary _contentTemplateCollection;

    private SmartNavigationSupport _smartNavSupport;
    internal HttpContext _context;

    private ValidatorCollection _validators;
    private bool _validated;

    private HtmlHead _header;
    private int _supportsStyleSheets;

    private Control _autoPostBackControl;

    private string _focusedControlID;
    private Control _focusedControl;
    private string _validatorInvalidControl;

    private int _scrollPositionX;
    private int _scrollPositionY;

    private Page _previousPage;
    private VirtualPath _previousPagePath;

    private bool _preInitWorkComplete;

    private bool _clientSupportsJavaScriptChecked;
    private bool _clientSupportsJavaScript;

    private string _titleToBeSet;
    private string _descriptionToBeSet;
    private string _keywordsToBeSet;

    private ICallbackEventHandler _callbackControl;

    // DevDiv 33149, 43258: A backward compat. switch for Everett rendering,
    private bool _xhtmlConformanceModeSet;
    private XhtmlConformanceMode _xhtmlConformanceMode;

    // const masks into the BitVector32
    private const int styleSheetInitialized          = 0x00000001;
    private const int isExportingWebPart             = 0x00000002;
    private const int isExportingWebPartShared       = 0x00000004;
    private const int isCrossPagePostRequest         = 0x00000008;
    // Needed to support Validators in AJAX 1.0 (Windows OS Bugs 2015831)
    private const int isPartialRenderingSupported    = 0x00000010;
    private const int isPartialRenderingSupportedSet = 0x00000020;
    private const int skipFormActionValidation       = 0x00000040;
    private const int wasViewStateMacErrorSuppressed = 0x00000080;

    // Todo: Move boolean fields into _pageFlags.
    #pragma warning disable 0649
    private SimpleBitVector32 _pageFlags;
    #pragma warning restore 0649

    // Can be either Context.Request.Form or Context.Request.QueryString
    // depending on the method used.
    private NameValueCollection _requestValueCollection;
    // The unvalidated version of _requestValueCollection
    private NameValueCollection _unvalidatedRequestValueCollection;

    private ModelStateDictionary _modelState;
    private ModelBindingExecutionContext _modelBindingExecutionContext;

    private UnobtrusiveValidationMode? _unobtrusiveValidationMode;

    private bool _executingAsyncTasks = false;

    private static StringSet s_systemPostFields;
    static Page() {
        // Create a static hashtable with all the names that should be
        // ignored in ProcessPostData().
        s_systemPostFields = new StringSet();
        s_systemPostFields.Add(postEventSourceID);
        s_systemPostFields.Add(postEventArgumentID);
        s_systemPostFields.Add(ViewStateFieldCountID);
        s_systemPostFields.Add(ViewStateGeneratorFieldID);
        s_systemPostFields.Add(ViewStateFieldPrefixID);
        s_systemPostFields.Add(ViewStateEncryptionID);
        s_systemPostFields.Add(previousPageID);
        s_systemPostFields.Add(callbackID);
        s_systemPostFields.Add(callbackParameterID);
        s_systemPostFields.Add(lastFocusID);
        s_systemPostFields.Add(UniqueFilePathSuffixID);
        s_systemPostFields.Add(HttpResponse.RedirectQueryStringVariable);
        s_systemPostFields.Add(EventValidationPrefixID);
    }

    /// <devdoc>
    /// <para>Initializes a new instance of the <see cref='System.Web.UI.Page'/> class.</para>
    /// </devdoc>
    public Page() {
        _page = this;   // Set the page to ourselves

        _enableViewStateMac = EnableViewStateMacDefault;

        // Ensure that the page has an ID, for things like trace
        ID = PageID;

        _supportsStyleSheets = -1;

        // Set the default ValidateRequestMode of a page to Enabled since the value Inherit
        // does not make sense as the page has nobody to inherit from.
        // Also, since this is the default value for Page, we do not want this value to be
        // stored in ViewState , so we set the value here but do not set the property changed
        // flag so that it's not stored in ViewState by default.
        SetValidateRequestModeInternal(ValidateRequestMode.Enabled, setDirty: false);
    }

    public ModelStateDictionary ModelState {
        get {
            if (_modelState == null) {
                _modelState = new ModelStateDictionary();
            }
            return _modelState;
        }
    }

    private IValueProvider ActiveValueProvider {
        get;
        set;
    }

    internal bool IsExecutingAsyncTasks {
        get {
            return _executingAsyncTasks;
        }
        set {
            _executingAsyncTasks = value;
        }
    }

    public ModelBindingExecutionContext ModelBindingExecutionContext {
        get {
            if (_modelBindingExecutionContext == null) {
                _modelBindingExecutionContext = new ModelBindingExecutionContext(new HttpContextWrapper(Context), this.ModelState);

                //This is used to query the ViewState in ViewStateValueProvider later.
                _modelBindingExecutionContext.PublishService<StateBag>(ViewState);

                //This is used to query RouteData in RouteDataValueProvider later.
                _modelBindingExecutionContext.PublishService<RouteData>(RouteData);
            }
            return _modelBindingExecutionContext;
        }
    }
    
    /// <summary>
    /// We support calling TryUpdateModel only within a Data Method of DataBoundControl.
    /// So this method provides a way to enfore that.
    /// This sets the active value provider which is used to provide the values for
    /// TryUpdateModel. This method should be called before calling TryUpdateModel otherwise the latter
    /// would throw. Also it's callers responsibility to reset the active value Provider by calling this 
    /// method again with null values. (Currently this is all done by ModelDataSourceView).
    /// </summary>
    internal void SetActiveValueProvider(IValueProvider valueProvider) {
        ActiveValueProvider = valueProvider;
    }

    /// <summary>
    /// Attempts to update the model object from the values within a databound control. This
    /// must be invoked within the Select/Update/Delete/InsertMethods used for data binding. 
    /// </summary>
    /// <returns>True if the model object is updated succesfully with valid values. False otherwise.</returns>
    public virtual bool TryUpdateModel<TModel>(TModel model) where TModel : class {

        if (ActiveValueProvider == null) {
            throw new InvalidOperationException(SR.GetString(SR.Page_InvalidUpdateModelAttempt, "TryUpdateModel"));
        }

        return TryUpdateModel<TModel>(model, ActiveValueProvider);
    }

    /// <summary>
    /// Attempts to update the model object from the values provided by given valueProvider.
    /// </summary>
    /// <returns>True if the model object is updated succesfully with valid values. False otherwise.</returns>
    public virtual bool TryUpdateModel<TModel>(TModel model, IValueProvider valueProvider) where TModel : class {

        if (model == null) {
            throw new ArgumentNullException("model");
        }

        if (valueProvider == null) {
            throw new ArgumentNullException("valueProvider");
        }

        IModelBinder binder = ModelBinders.Binders.DefaultBinder;

        ModelBindingContext bindingContext = new ModelBindingContext() {
            ModelBinderProviders = ModelBinderProviders.Providers,
            ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(TModel)),
            ModelState = ModelState,
            ValueProvider = valueProvider
        };

        if (binder.BindModel(ModelBindingExecutionContext, bindingContext)) {
            return ModelState.IsValid;
        }

        //ModelBinding failed!!!
        return false;
    }

    /// <summary>
    /// Updates the model object from the values within a databound control. This must be invoked 
    /// within the Select/Update/Delete/InsertMethods used for data binding.
    /// Throws an exception if the update fails.
    /// </summary>
    public virtual void UpdateModel<TModel>(TModel model) where TModel : class {

        if (ActiveValueProvider == null) {
            throw new InvalidOperationException(SR.GetString(SR.Page_InvalidUpdateModelAttempt, "UpdateModel"));
        }

        UpdateModel<TModel>(model, ActiveValueProvider);
    }

    /// <summary>
    /// Updates the model object from the values provided by given valueProvider.
    /// Throws an exception if the update fails.
    /// </summary>
    public virtual void UpdateModel<TModel>(TModel model, IValueProvider valueProvider) where TModel : class {
        if (!TryUpdateModel(model, valueProvider)) {
            throw new InvalidOperationException(SR.GetString(SR.Page_UpdateModel_UpdateUnsuccessful, typeof(TModel).FullName));
        }
    }

    [
    DefaultValue(UnobtrusiveValidationMode.None),
    WebCategory("Behavior"),
    WebSysDescription(SR.Page_UnobtrusiveValidationMode)
    ]
    public UnobtrusiveValidationMode UnobtrusiveValidationMode {
        get {
            return _unobtrusiveValidationMode ?? ValidationSettings.UnobtrusiveValidationMode;
        }
        set {
            if (value < UnobtrusiveValidationMode.None || value > UnobtrusiveValidationMode.WebForms) {
                throw new ArgumentOutOfRangeException("value");
            }

            _unobtrusiveValidationMode = value;
        }
    }

    /// <devdoc>
    /// <para>Gets the <see langword='Application'/> object provided by the HTTP Runtime.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public HttpApplicationState Application {
        get {
            return _application;
        }
    }

    /// <devdoc>
    /// <para>Gets the HttpContext for the Page.</para>
    /// </devdoc>
    protected internal override HttpContext Context {
        get {
            if (_context == null) {
                _context = HttpContext.Current;
            }
            return _context;
        }
    }

    // Set of unique control ids which have already loaded control state
    private StringSet ControlStateLoadedControlIds {
        get {
            if (_controlStateLoadedControlIds == null) {
                _controlStateLoadedControlIds = new StringSet();
            }
            return _controlStateLoadedControlIds;
        }
    }

    /// <devdoc>
    ///     The value to be written to the __VIEWSTATE hidden fields.  Getter is exposed through a protected property in
    ///     PageAdapter.
    /// </devdoc>
    internal string ClientState {
        get {
            return _clientState;
        }
        set {
            _clientState = value;
        }
    }

    /*
     * Any onsubmit statment to hook up by the form. The HtmlForm object calls this
     * during RenderAttributes.
     */
    internal string ClientOnSubmitEvent {
        get {
            if (ClientScript.HasSubmitStatements ||
                (Form != null && Form.SubmitDisabledControls && (EnabledControls.Count > 0))) {
                // to avoid being affected by earlier instructions we must
                // write out the language as well
                return "javascript:return WebForm_OnSubmit();";
            }
            return string.Empty;
        }
    }


    public ClientScriptManager ClientScript {
        get {
            if (_clientScriptManager == null) {
                _clientScriptManager = new ClientScriptManager(this);
            }

            return _clientScriptManager;
        }
    }


    /// <devdoc>
    ///    <para>Indicates whether the requesting browser is uplevel or downlevel so that the appropriate behavior can be
    ///       generated for the request.</para>
    /// </devdoc>
    [
    DefaultValue(""),
    WebSysDescription(SR.Page_ClientTarget),
    Browsable(false),
    EditorBrowsable(EditorBrowsableState.Advanced),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public string ClientTarget {
        get {
            return (_clientTarget == null) ? String.Empty : _clientTarget;
        }
        set {
            _clientTarget = value;
            if (_request != null) {
                _request.ClientTarget = value;
            }
        }
    }

    private string _clientQueryString = null;
    public String ClientQueryString {
        get {
            if (_clientQueryString == null) {
                if (RequestInternal != null && Request.HasQueryString) {
                    // Eliminate system post fields (generated by the framework) from the
                    // querystring used for adaptive rendering.
                    Hashtable ht = new Hashtable();
                    foreach (string systemPostField in s_systemPostFields) {
                        ht.Add(systemPostField, true);
                    }

                    // 
                    HttpValueCollection httpValueCollection = (HttpValueCollection)((SkipFormActionValidation) ? Request.Unvalidated.QueryString : Request.QueryString);
                    _clientQueryString = httpValueCollection.ToString(urlencoded: true, excludeKeys: ht);
                }
                else {
                    _clientQueryString = String.Empty;
                }
            }

            return _clientQueryString;
        }
    }

    internal bool ContainsEncryptedViewState {
        get {
            return _containsEncryptedViewState;
        }
        set {
            _containsEncryptedViewState = value;
        }
    }

    /// <devdoc>
    ///    <para>
    ///       Gets or sets the error page to which the requesting browser should be
    ///       redirected in the event of an unhandled page exception.
    ///    </para>
    /// </devdoc>
    [
    DefaultValue(""),
    WebSysDescription(SR.Page_ErrorPage),
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public string ErrorPage {
        get {
            return _errorPage;
        }
        set {
            _errorPage = value;
        }
    }

    /// <devdoc>
    ///   Gets a value indicating whether the page is being loaded in response to a client callback.
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public bool IsCallback {
        get {
            return _isCallback;
        }
    }

    /// <internalonly/>
    /// <devdoc>Page class can be cached/reused</devdoc>
    [
    Browsable(false),
    EditorBrowsable(EditorBrowsableState.Never)
    ]
    public bool IsReusable {
        get { return false; }
    }

    /// <devdoc>
    ///     Required for small browsers that cache too aggressively.
    /// </devdoc>
    protected internal virtual String UniqueFilePathSuffix {
        get {
            if (_uniqueFilePathSuffix != null) {
                return _uniqueFilePathSuffix;
            }
            // Only need a few digits, so save space by modulo'ing by a prime.
            // The chosen prime is the highest of six digits.
            long ticks = DateTime.Now.Ticks % 999983;
            _uniqueFilePathSuffix = String.Concat(UniqueFilePathSuffixID + "=", ticks.ToString("D6", CultureInfo.InvariantCulture));
            _uniqueFilePathSuffix = _uniqueFilePathSuffix.PadLeft(6, '0');
            return _uniqueFilePathSuffix;
        }
    }

    // This property should be public. (DevDiv Bugs 161340)
    public Control AutoPostBackControl {
        get {
            return _autoPostBackControl;
        }
        set {
            _autoPostBackControl = value;
        }
    }

    internal bool ClientSupportsFocus {
        get {
            return (_request != null) &&
                ((_request.Browser.EcmaScriptVersion >= FocusMinimumEcmaVersion) || (_request.Browser.JScriptVersion >= FocusMinimumJScriptVersion));
        }
    }

    internal bool ClientSupportsJavaScript {
        get {
            if (!_clientSupportsJavaScriptChecked) {
                _clientSupportsJavaScript = (_request != null) &&
                    (_request.Browser.EcmaScriptVersion >= JavascriptMinimumVersion);
                _clientSupportsJavaScriptChecked = true;
            }

            return _clientSupportsJavaScript;
        }
    }

    private ArrayList EnabledControls {
        get {
            if (_enabledControls == null) {
                _enabledControls = new ArrayList();
            }
            return _enabledControls;
        }
    }

    internal string FocusedControlID {
        get {
            if (_focusedControlID == null) {
                return String.Empty;
            }
            return _focusedControlID;
        }
    }

    /// <devdoc>
    ///    The control that has been set to be focused (empty if there was no such control)
    /// </devdoc>
    internal Control FocusedControl {
        get {
            return _focusedControl;
        }
    }


    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public HtmlHead Header {
        get {
            return _header;
        }
    }

    /// <internalonly/>
    /// <devdoc>
    ///     VSWhidbey 80467: Need to adapt Id separator.
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
    EditorBrowsable(EditorBrowsableState.Never)
    ]
    public new virtual char IdSeparator {
        get {
            if (!_haveIdSeparator) {
                if (AdapterInternal != null) {
                    _idSeparator = PageAdapter.IdSeparator;
                }
                else {
                    _idSeparator = IdSeparatorFromConfig;
                }
                _haveIdSeparator = true;
            }

            return _idSeparator;
        }
    }


    /// <devdoc>
    ///    The control that has was last focused (empty if there was no such control)
    /// </devdoc>
    // We
    internal string LastFocusedControl {
        [AspNetHostingPermission(SecurityAction.Assert, Level = AspNetHostingPermissionLevel.Low)]
        get {
            if (RequestInternal != null) {
                // SECURITY: Change this to just check form + query string
                string lastFocus = Request[lastFocusID];
                if (lastFocus != null) {
                    return lastFocus;
                }
            }
            return String.Empty;
        }
    }


    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public bool MaintainScrollPositionOnPostBack {
        get {
            if (RequestInternal != null && RequestInternal.Browser != null && !RequestInternal.Browser.SupportsMaintainScrollPositionOnPostback)
                return false;
            return _maintainScrollPosition;
        }
        set {
            if (_maintainScrollPosition != value) {
                _maintainScrollPosition = value;
                if (_maintainScrollPosition) LoadScrollPosition();
            }
        }
    }


    /// <devdoc>
    ///    <para>The MasterPage used by the Page.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
    WebSysDescription(SR.MasterPage_MasterPage)
    ]
    public MasterPage Master {
        get {
            if (_master == null && !_preInitWorkComplete) {
                _master = MasterPage.CreateMaster(this, Context, _masterPageFile, _contentTemplateCollection);
            }

            return _master;
        }
    }


    /// <devdoc>
    ///    <para>Gets and sets the masterPageFile of this Page.</para>
    /// </devdoc>
    [
    DefaultValue(""),
    WebCategory("Behavior"),
    WebSysDescription(SR.MasterPage_MasterPageFile)
    ]
    public virtual string MasterPageFile {
        get {
            return VirtualPath.GetVirtualPathString(_masterPageFile);
        }
        set {
            if (_preInitWorkComplete) {
                throw new InvalidOperationException(SR.GetString(SR.PropertySetBeforePageEvent, "MasterPageFile", "Page_PreInit"));
            }

            if (value != VirtualPath.GetVirtualPathString(_masterPageFile)) {
                _masterPageFile = VirtualPath.CreateAllowNull(value);

                if (_master != null && Controls.Contains(_master)) {
                    Controls.Remove(_master);
                }
                _master = null;
            }
        }
    }

    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
    EditorBrowsable(EditorBrowsableState.Never)
    ]
    public int MaxPageStateFieldLength {
        get {
            return _maxPageStateFieldLength;
        }
        set {
            if (this.ControlState > ControlState.FrameworkInitialized) {
                throw new InvalidOperationException(SR.GetString(SR.PropertySetAfterFrameworkInitialize, "MaxPageStateFieldLength"));
            }

            if (value == 0 || value < -1) {
                throw new ArgumentException(SR.GetString(SR.Page_Illegal_MaxPageStateFieldLength), "MaxPageStateFieldLength");
            }
            _maxPageStateFieldLength = value;
        }
    }

    /// <devdoc>
    ///    Indicates whether page requires cross post script
    /// </devdoc>
    internal bool ContainsCrossPagePost {
        get {
            return _containsCrossPagePost;
        }
        set {
            _containsCrossPagePost = value;
        }
    }

    /// <devdoc>
    /// True if the form should render a reference to the focus script.
    /// </devdoc>
    internal bool RenderFocusScript {
        get {
            return _requireFocusScript;
        }
    }

    internal Stack PartialCachingControlStack {
        get {
            return _partialCachingControlStack;
        }
    }

    /// <devdoc>
    ///    Returns the page state persister associated with the page.
    /// </devdoc>
    protected virtual PageStatePersister PageStatePersister {
        get {
            if (_persister == null) {
                PageAdapter adapter = PageAdapter;
                if (adapter != null) {
                    _persister = adapter.GetStatePersister();
                }
                if (_persister == null) {
                    _persister = new HiddenFieldPageStatePersister(this);
                }
            }
            return _persister;
        }
    }

    // Reconstructs the view state string from the view state fields in the request
    internal string RequestViewStateString {
        get {
            if (!_cachedRequestViewState) {
                StringBuilder state = new StringBuilder();
                try {
                    NameValueCollection requestValueCollection = RequestValueCollection;
                    if (requestValueCollection != null) {
                        // If ViewStateChunking is disabled(-1) or there is no ViewStateFieldCount, return the __VIEWSTATE field
                        string fieldCountStr = RequestValueCollection[ViewStateFieldCountID];
                        if (MaxPageStateFieldLength == -1 || fieldCountStr == null) {
                            _cachedRequestViewState = true;
                            _requestViewState = RequestValueCollection[ViewStateFieldPrefixID];
                            return _requestViewState;
                        }

                        // Build up the entire persisted state from all the viewstate fields
                        int numViewStateFields = Convert.ToInt32(fieldCountStr, CultureInfo.InvariantCulture);
                        if (numViewStateFields < 0) {
                            throw new HttpException(SR.GetString(SR.ViewState_InvalidViewState));
                        }

                        // The view state is split into __VIEWSTATE, __VIEWSTATE1, __VIEWSTATE2, ... fields
                        for (int i=0; i<numViewStateFields; ++i) {
                            string key = ViewStateFieldPrefixID;

                            // For backwards compat we always need the first chunk to be __VIEWSTATE
                            if (i > 0) key += i.ToString(CultureInfo.InvariantCulture);
                            string viewStateChunk = RequestValueCollection[key];
                            if (viewStateChunk == null) {
                                throw new HttpException(SR.GetString(SR.ViewState_MissingViewStateField, key));
                            }

                            state.Append(viewStateChunk);
                        }
                    }

                    _cachedRequestViewState = true;
                    _requestViewState = state.ToString();
                } catch (Exception e) {
                    ViewStateException.ThrowViewStateError(e, state.ToString());
                }
            }
            return _requestViewState;
        }
    }

    internal string ValidatorInvalidControl {
        get {
            if (_validatorInvalidControl == null) {
                return String.Empty;
            }
            return _validatorInvalidControl;
        }
    }


    /// <devdoc>
    /// <para>Gets the <see cref='System.Web.TraceContext'/> object for the current Web
    ///    request. Tracing tracks and presents the execution details about a Web request. </para>
    /// For trace data to be visible in a rendered page, you must
    /// turn tracing on for that page.
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public TraceContext Trace {
        get {
            return Context.Trace;
        }
    }


    /// <devdoc>
    /// <para>Gets the <see langword='Request'/> object provided by the HTTP Runtime, which
    ///    allows you to access data from incoming HTTP requests.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public HttpRequest Request {
        get {
            if (_request == null)
                throw new HttpException(SR.GetString(SR.Request_not_available));

            return _request;
        }
    }

    internal HttpRequest RequestInternal {
        get {
            return _request;
        }
    }

    /// <devdoc>
    /// <para>Gets the <see langword='Response '/>object provided by the HTTP Runtime, which
    ///    allows you to send HTTP response data to a client browser.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public HttpResponse Response {
        get {
            if (_response == null)
                throw new HttpException(SR.GetString(SR.Response_not_available));

            return _response;
        }
    }

    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public RouteData RouteData {
        get {
            if (Context != null && Context.Request != null) {
                // RequestContext is created on demand if not set so it should never be null
                return Context.Request.RequestContext.RouteData;
            }
            return null;
        }
    }

    /// <devdoc>
    /// <para>Gets the <see langword='Server'/> object supplied by the HTTP runtime.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public HttpServerUtility Server {
        get { return Context.Server;}
    }


    /// <devdoc>
    /// <para>Retrieves a <see langword='Cache'/> object in which to store the page for
    ///    subsequent requests. This property is read-only.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public Cache Cache {
        get {
            if (_cache == null)
                throw new HttpException(SR.GetString(SR.Cache_not_available));

            return _cache;
        }
    }

    /// <devdoc>
    /// <para>Gets the <see langword='Session'/>
    /// object provided by the HTTP Runtime. This object provides information about the current request's session.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public virtual HttpSessionState Session {
        get {
            if (!_sessionRetrieved) {
                /* try just once to retrieve it */
                _sessionRetrieved = true;

                try {
                    _session = Context.Session;
                }
                catch {
                    //  Just ignore exceptions, return null.
                }
            }

            if (_session == null) {
                throw new HttpException(SR.GetString(SR.Session_not_enabled));
            }

            return _session;
        }
    }

    [
    Bindable(true),
    Localizable(true),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public string Title {
        get {
            if ((Page.Header == null) && (this.ControlState >= ControlState.ChildrenInitialized)) {
                throw new InvalidOperationException(SR.GetString(SR.Page_Title_Requires_Head));
            }

            if (_titleToBeSet != null) {
                return _titleToBeSet;
            }

            return Page.Header.Title;
        }
        set {
            if (Page.Header == null) {
                if (this.ControlState >= ControlState.ChildrenInitialized) {
                    throw new InvalidOperationException(SR.GetString(SR.Page_Title_Requires_Head));
                }
                else {
                    _titleToBeSet = value;
                }
            }
            else {
                Page.Header.Title = value;
            }
        }
    }

    [
    Bindable(true),
    Localizable(true),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public string MetaDescription {
        get {
            if ((Page.Header == null) && (this.ControlState >= ControlState.ChildrenInitialized)) {
                throw new InvalidOperationException(SR.GetString(SR.Page_Description_Requires_Head));
            }

            if (_descriptionToBeSet != null) {
                return _descriptionToBeSet;
            }

            return Page.Header.Description;
        }
        set {
            if (Page.Header == null) {
                if (this.ControlState >= ControlState.ChildrenInitialized) {
                    throw new InvalidOperationException(SR.GetString(SR.Page_Description_Requires_Head));
                }
                else {
                    _descriptionToBeSet = value;
                }
            }
            else {
                Page.Header.Description = value;
            }
        }
    }

    [
    Bindable(true),
    Localizable(true),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public string MetaKeywords {
        get {
            if ((Page.Header == null) && (this.ControlState >= ControlState.ChildrenInitialized)) {
                throw new InvalidOperationException(SR.GetString(SR.Page_Keywords_Requires_Head));
            }

            if (_keywordsToBeSet != null) {
                return _keywordsToBeSet;
            }

            return Page.Header.Keywords;
        }
        set {
            if (Page.Header == null) {
                if (this.ControlState >= ControlState.ChildrenInitialized) {
                    throw new InvalidOperationException(SR.GetString(SR.Page_Keywords_Requires_Head));
                }
                else {
                    _keywordsToBeSet = value;
                }
            }
            else {
                Page.Header.Keywords = value;
            }
        }
    }

    /// <devdoc>
    /// indicates whether the Page has PageTheme defined.
    /// </devdoc>
    internal bool ContainsTheme {
        get {
            Debug.Assert(_preInitWorkComplete || DesignMode, "ContainsTheme should not be accessed before Page's PreInit.");
            return _theme != null;
        }
    }


    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public virtual String Theme {
        get {
            return _themeName;
        }
        set {
            if (_preInitWorkComplete) {
                throw new InvalidOperationException(SR.GetString(SR.PropertySetBeforePageEvent, "Theme", "Page_PreInit"));
            }

            if (!String.IsNullOrEmpty(value) && !FileUtil.IsValidDirectoryName(value)) {
                throw new ArgumentException(SR.GetString(SR.Page_theme_invalid_name, value), "Theme");
            }

            _themeName = value;
        }
    }

    internal bool SupportsStyleSheets {
        get {
            if (_supportsStyleSheets == -1) {
                if (Header != null &&
                    Header.StyleSheet != null &&
                    RequestInternal != null &&
                    Request.Browser != null &&
                    (string)Request.Browser["preferredRenderingType"] != "xhtml-mp" &&
                    Request.Browser.SupportsCss &&
                    !Page.IsCallback &&
                    (ScriptManager == null || !ScriptManager.IsInAsyncPostBack)) {

                    // We don't want to render the style sheet for XHTML mobile profile devices even though
                    // SupportsCss may be true because they need the CSS to be in a separate file.

                    // We don't want embedded styles sheet to render during a callback (VSWhidbey 420743)
                    _supportsStyleSheets = 1;
                    return true;
                }

                _supportsStyleSheets = 0;
                return false;
            }
            return (_supportsStyleSheets == 1);
        }
    }

    [
    Browsable(false),
    Filterable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public virtual String StyleSheetTheme {
        get {
            return _styleSheetName;
        }
        set {
            if (_pageFlags[styleSheetInitialized]) {
                throw new InvalidOperationException(SR.GetString(SR.SetStyleSheetThemeCannotBeSet));
            }
            _styleSheetName = value;
        }
    }

    /// <devdoc>
    ///    <para>Indicates the user making the page request. This property uses the
    ///       Context.User property to determine where the request originates. This property
    ///       is read-only.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public IPrincipal User {
        get { return Context.User;}
    }

    internal XhtmlConformanceMode XhtmlConformanceMode {
        get {
            // We only want the evaluation of conformance mode to be done at most once per page request.
            if (!_xhtmlConformanceModeSet) {
                // The conformance mode is used to determine if backward compatible markup should
                // be generated as in pre-Whidbey versions.  So if an adapter is assigned, we can
                // assume this is Whidbey rendering and we return the default mode that doesn't do
                // backward compatible rendering.
                if (DesignMode) {
                    _xhtmlConformanceMode = XhtmlConformanceSection.DefaultMode;
                }
                else {
                    _xhtmlConformanceMode = GetXhtmlConformanceSection().Mode;
                }
                _xhtmlConformanceModeSet = true;
            }

            return _xhtmlConformanceMode;
        }
    }

    /*
     * This protected virtual method is called by the Page to create the HtmlTextWriter
     * to use for rendering. The class created is based on the TagWriter property on
     * the browser capabilities.
     */

    /// <devdoc>
    /// <para>Creates an <see cref='System.Web.UI.HtmlTextWriter'/> object to render the page's
    ///    content. If the <see langword='IsUplevel'/> property is set to
    /// <see langword='false'/>, an <see langword='Html32TextWriter'/> object is created
    ///    to render requests originating from downlevel browsers. For derived pages, you
    ///    can override this method to create a custom text writer.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected internal virtual HtmlTextWriter CreateHtmlTextWriter(TextWriter tw) {
        // Use Context.Request (rather than Request) to avoid exception in get_Request when
        // Request is not available.
        if (Context != null && Context.Request != null && Context.Request.Browser != null) {
            return Context.Request.Browser.CreateHtmlTextWriter(tw);
        }

        HtmlTextWriter writer = CreateHtmlTextWriterInternal(tw, _request );
        if (writer == null) {
            writer = new HtmlTextWriter(tw);
        }
        return writer;
    }

    internal static HtmlTextWriter CreateHtmlTextWriterInternal(TextWriter tw, HttpRequest request) {

        if (request != null && request.Browser != null) {
            return request.Browser.CreateHtmlTextWriterInternal(tw);
        }

        // Fall back to Html 3.2
        return new Html32TextWriter(tw);
    }

    public static HtmlTextWriter CreateHtmlTextWriterFromType(TextWriter tw, Type writerType) {
        if (writerType == typeof(HtmlTextWriter)) {
            return new HtmlTextWriter(tw);
        }
        else if (writerType == typeof(Html32TextWriter)) {
            return new Html32TextWriter(tw);
        }
        else {
            try {
                // Make sure the type has the correct base class (ASURT 123677)
                Util.CheckAssignableType(typeof(HtmlTextWriter), writerType);

                return (HtmlTextWriter)HttpRuntime.CreateNonPublicInstance(writerType, new object[] { tw });
            }
            catch {
                throw new HttpException(SR.GetString(SR.Invalid_HtmlTextWriter, writerType.FullName));
            }
        }
    }

    /// <devdoc>
    /// Overridden to check the Page's own ID against the one being searched.
    /// </devdoc>
    public override Control FindControl(String id) {
        if (StringUtil.EqualsIgnoreCase(id, PageID)) {
            return this;
        }
        return base.FindControl(id, 0);
    }
    /*
     * This method is implemented by the Page classes that we generate on
     * the fly.  It returns a has code unique to the control layout.
     */

    /// <devdoc>
    /// <para>Retrieves a hash code that is generated by <see langword='Page'/> objects that
    ///    are generated at runtime. This hash code is unique to the page's control
    ///    layout.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public virtual int GetTypeHashCode() {
        return 0;
    }

    /*
     * Override for small efficiency win: page doesn't prepend its name
     */
    internal override string GetUniqueIDPrefix() {
        // Only overridde if we're at the top level
        if (Parent == null)
            return String.Empty;

        // Use base implementation for interior nodes
        return base.GetUniqueIDPrefix();
    }

    // This is a non-cryptographic hash code that can be used to identify which Page generated
    // a __VIEWSTATE field. It shouldn't be considered sensitive information since its inputs
    // are assumed to be known by all parties.
    internal uint GetClientStateIdentifier() {
        // Use non-randomized hash code algorithms instead of String.GetHashCode.

        // Use the page's directory and class name as part of the key (ASURT 64044)
        // We need to make sure that the hash is case insensitive, since the file system
        // is, and strange view state errors could otherwise happen (ASURT 128657)
        int pageHashCode = StringUtil.GetNonRandomizedHashCode(TemplateSourceDirectory, ignoreCase:true);
        pageHashCode += StringUtil.GetNonRandomizedHashCode(GetType().Name, ignoreCase:true);

        return (uint)pageHashCode;
    }

    /*
     * Called when an exception occurs in ProcessRequest
     */

    /// <devdoc>
    /// <para>Throws an <see cref='System.Web.HttpException'/> object when an error occurs during a call to the
    /// <see cref='System.Web.UI.Page.ProcessRequest'/> method. If there is a custom error page, and
    ///    custom error page handling is enabled, the method redirects to the specified
    ///    custom error page.</para>
    /// </devdoc>
    private bool HandleError(Exception e) {

        try {
            // Remember the exception to be accessed via Server.GetLastError/ClearError
            Context.TempError = e;
            // Raise the error event
            OnError(EventArgs.Empty);
            // If the error has been cleared by the event handler, nothing else to do
            if (Context.TempError == null)
                return true;
        } finally {
            Context.TempError = null;
        }

        // If an error page was specified, redirect to it
        if (!String.IsNullOrEmpty(_errorPage)) {
            // only redirect if custom errors are enabled:
            if (Context.IsCustomErrorEnabled) {
                _response.RedirectToErrorPage(_errorPage, CustomErrorsSection.GetSettings(Context).RedirectMode);
                return true;
            }
        }

        // Increment all of the appropriate error counters
        PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_UNHANDLED);

        string traceString = null;
        if (Context.TraceIsEnabled) {
            Trace.Warn(SR.GetString(SR.Unhandled_Err_Error), null, e);
            if (Trace.PageOutput) {
                StringWriter sw = new StringWriter();
                HtmlTextWriter htw = new HtmlTextWriter(sw);

                // Try to build the profile tree so the control hierarchy will show up
                BuildPageProfileTree(false);

                // these three calls will happen again at the end of the request, but
                // in order to have the full trace log on the rendered page, we need
                // to call them now.
                Trace.EndRequest();
                Trace.StopTracing();
                Trace.StatusCode = 500;
                Trace.Render(htw);
                traceString = sw.ToString();
            }
        }

        // If the exception is an HttpException with a formatter, just
        // rethrow it instead of a new one (ASURT 45479)
        if (HttpException.GetErrorFormatter(e) != null) {
            return false;
        }

        // Don't touch security exceptions (ASURT 78366)
        if (e is System.Security.SecurityException)
            return false;

        throw new HttpUnhandledException(null, traceString, e);
    }


    /// <devdoc>
    ///    <para>Gets a value indicating whether the page is being created in response to a
    ///       cross page postback.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public bool IsCrossPagePostBack {
        get {
            return _isCrossPagePostBack;
        }
    }

    internal bool IsExportingWebPart {
        get {
            return _pageFlags[isExportingWebPart];
        }
    }

    internal bool IsExportingWebPartShared {
        get {
            return _pageFlags[isExportingWebPartShared];
        }
    }

    /*
     * Returns true if this is a postback, which means it has some
     * previous viewstate to reload. Use this in the Load method to differentiate
     * an initial load from a postback reload.
     */

    /// <devdoc>
    ///    <para>Gets a value indicating whether the page is being loaded in response to a
    ///       client postback, or if it is being loaded and accessed for the first time.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public bool IsPostBack {
        get {
            if (_requestValueCollection == null)
                return false;

            // Treat it as postback if the page is created thru cross page postback.
            if (_isCrossPagePostBack)
                return true;

            // Don't treat it as a postback if the page is posted from cross page
            if (_pageFlags[isCrossPagePostRequest])
                return false;

            // Don't treat it as a postback if a view state MAC check failed and we
            // simply ate the exception.
            if (ViewStateMacValidationErrorWasSuppressed)
                return false;

            // If we're in a Transfer/Execute, never treat as postback (ASURT 121000)
            // Unless we are being transfered back to the original page, in which case
            // it is ok to treat it as a postback (VSWhidbey 117747)
            // Note that Context.Handler could be null (VSWhidbey 159775)
            if (Context.ServerExecuteDepth > 0 &&
                (Context.Handler == null || GetType() != Context.Handler.GetType())) {
                return false;
            }

            // If the page control layout has changed, pretend that we are in
            // a non-postback situation.
            return !_fPageLayoutChanged;
        }
    }

    internal NameValueCollection RequestValueCollection {
        get { return _requestValueCollection; }
    }

    [
    Browsable(false),
    DefaultValue(true),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
    EditorBrowsable(EditorBrowsableState.Never),
    ]
    public virtual bool EnableEventValidation {
        get {
            return _enableEventValidation;
        }
        set {
            if (this.ControlState > ControlState.FrameworkInitialized) {
                throw new InvalidOperationException(SR.GetString(SR.PropertySetAfterFrameworkInitialize, "EnableEventValidation"));
            }

            _enableEventValidation = value;
        }
    }

    [
    Browsable(false)
    ]
    public override bool EnableViewState {
        get {
            return base.EnableViewState;
        }
        set {
            base.EnableViewState = value;
        }
    }

    [
    Browsable(false),
    DefaultValue(ViewStateEncryptionMode.Auto),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
    EditorBrowsable(EditorBrowsableState.Never),
    ]
    public ViewStateEncryptionMode ViewStateEncryptionMode {
        get {
            return _encryptionMode;
        }
        set {
            if (this.ControlState > ControlState.FrameworkInitialized) {
                throw new InvalidOperationException(SR.GetString(SR.PropertySetAfterFrameworkInitialize, "ViewStateEncryptionMode"));
            }

            if (value < ViewStateEncryptionMode.Auto || value > ViewStateEncryptionMode.Never) {
                throw new ArgumentOutOfRangeException("value");
            }

            _encryptionMode = value;
        }
    }

    /// <devdoc>
    ///    <para>Setting this property helps prevent one-click attacks (ASURT 126375)</para>
    /// </devdoc>
    [
    Browsable(false)
    ]
    public string ViewStateUserKey {
        get {
            return _viewStateUserKey;
        }
        set {
            // Make sure it's not called too late
            if (ControlState >= ControlState.Initialized) {
                throw new HttpException(SR.GetString(SR.Too_late_for_ViewStateUserKey));
            }

            _viewStateUserKey = value;
        }
    }


    [
    Browsable(false),
    EditorBrowsable(EditorBrowsableState.Never)
    ]
    public override string ID {
        get {
            return base.ID;
        }
        set {
            base.ID = value;
        }
    }


    [
    Browsable(false),
    EditorBrowsable(EditorBrowsableState.Never),
    DefaultValue(ValidateRequestMode.Enabled)
    ]
    public override ValidateRequestMode ValidateRequestMode {
        get {
            return base.ValidateRequestMode;
        }
        set {
            base.ValidateRequestMode = value;
        }
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    [DefaultValue(false)]
    // If this property is false, then
    // - we eagerly validate RawUrl at the appropriate point in ProcessRequestMain / ProcessRequestTransacted, and
    // - the ClientQueryString property is populated from Request.QueryString (and might be validated) instead of Request.Unvalidated.QueryString.
    public bool SkipFormActionValidation {
        get {
            return _pageFlags[skipFormActionValidation];
        }
        set {
            // Clear the cached ClientQueryString value if the value of this property changes
            if (value != SkipFormActionValidation) {
                _clientQueryString = null;
            }

            _pageFlags[skipFormActionValidation] = value;
        }
    }

    [
    Browsable(false)
    ]
    public override bool Visible {
        get {
            return base.Visible;
        }
        set {
            base.Visible = value;
        }
    }

    /// <devdoc>
    ///    <para>Decrypt the string using symmetric algorithm defined in config.</para>
    /// </devdoc>
    internal static string DecryptString(string s, Purpose purpose) {
        if (s == null)
            return null;

        byte[] protectedData = HttpServerUtility.UrlTokenDecode(s);

        // DevDiv Bugs 137864: IVType.Hash is necessary for WebResource / ScriptResource URLs
        // so that client and server caching will continue to work. MS AJAX also caches these
        // client-side, and switching to a different IV type could potentially break MS AJAX
        // due to loading the same Javascript resource multiple times.
        // MSRC 10405: Crypto board approves of this usage of IVType.Hash.

        byte[] clearData = null;
        if (protectedData != null) {
            if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider) {
                // ASP.NET 4.5 Crypto DCR: Go through the new AspNetCryptoServiceProvider
                // if we're configured to do so.
                ICryptoService cryptoService = AspNetCryptoServiceProvider.Instance.GetCryptoService(purpose, CryptoServiceOptions.CacheableOutput);
                clearData = cryptoService.Unprotect(protectedData);
            }
            else {
                // If we're not configured to go through the new crypto routines,
                // fall back to the standard MachineKey crypto routines.
#pragma warning disable 618 // calling obsolete methods
                clearData = MachineKeySection.EncryptOrDecryptData(fEncrypt: false, buf: protectedData, modifier: null, start: 0, length: protectedData.Length, useValidationSymAlgo: false, useLegacyMode: false, ivType: IVType.Hash);
#pragma warning restore 618 // calling obsolete methods
            }
        }

        if (clearData == null)
            throw new HttpException(SR.GetString(SR.ViewState_InvalidViewState));
        return Encoding.UTF8.GetString(clearData);
    }

    /*
     * Performs intialization of the page required by the designer.
     */

    /// <devdoc>
    ///    <para>Performs any initialization of the page that is required by RAD designers.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void DesignerInitialize() {
        InitRecursive(null);
    }

    internal NameValueCollection GetCollectionBasedOnMethod(bool dontReturnNull) {
        // Get the right NameValueCollection base on the method
        if (_request.HttpVerb == HttpVerb.POST) {
            return (dontReturnNull || _request.HasForm) ? _request.Form : null;
        }
        else {
            return (dontReturnNull || _request.HasQueryString) ? _request.QueryString : null;
        }
    }

    private bool DetermineIsExportingWebPart() {
        byte[] queryString = Request.QueryStringBytes;
        if ((queryString == null) || (queryString.Length < 28)) {
            return false;
        }
        // query string is never unicode - it can be UTF-8, in which case it's fine to compare character by character
        // because what we're looking for is only in the low-ASCII range.
        if ((queryString[0] != '_') ||
            (queryString[1] != '_') ||
            (queryString[2] != 'W') ||
            (queryString[3] != 'E') ||
            (queryString[4] != 'B') ||
            (queryString[5] != 'P') ||
            (queryString[6] != 'A') ||
            (queryString[7] != 'R') ||
            (queryString[8] != 'T') ||
            (queryString[9] != 'E') ||
            (queryString[10] != 'X') ||
            (queryString[11] != 'P') ||
            (queryString[12] != 'O') ||
            (queryString[13] != 'R') ||
            (queryString[14] != 'T') ||
            (queryString[15] != '=') ||
            (queryString[16] != 't') ||
            (queryString[17] != 'r') ||
            (queryString[18] != 'u') ||
            (queryString[19] != 'e') ||
            (queryString[20] != '&')) {

            return false;
        }
        // Setting the export flag so that personalization can know not to toggle modes,
        // which would create a new subrequest and kill the export.
        _pageFlags.Set(isExportingWebPart);
        return true;
    }

    /*
     * Determine which of the following three cases we're in:
     * - Initial request.  No postback, return null
     * - GET postback request.  Return Context.Request.QueryString
     * - POST postback request.  Return Context.Request.Form
     */

    /// <devdoc>
    ///    <para>Determines the type of request made for the page based on if the page was a
    ///       postback, and whether a GET or POST method was used for the request.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected internal virtual NameValueCollection DeterminePostBackMode() {
        if (Context.Request == null)
            return null;

        // If PreventPostback is set, don't treat as postback (VSWhidbey 181013).
        if (Context.PreventPostback)
            return null;

        NameValueCollection ret = GetCollectionBasedOnMethod(dontReturnNull: false);

        if (ret == null)
            return null;

        // Some devices may send incorrect POST strings without trailing equal signs
        // if the last field is empty. Detecting this:
        bool isPostback = false;
        String [] nullValues = ret.GetValues(null);
        if (nullValues != null) {
            int numNull = nullValues.Length;
            for (int i = 0; i < numNull; i++) {
                if (nullValues[i].StartsWith(ViewStateFieldPrefixID, StringComparison.Ordinal) || nullValues[i] == postEventSourceID) {
                    isPostback = true;
                    break;
                }
            }
        }

        // If there is no state or postEventSourceID in the request,
        // it's an initial request
        // 



        if (ret[ViewStateFieldPrefixID] == null &&
            ret[ViewStateFieldCountID] == null &&
            ret[postEventSourceID] == null &&
            !isPostback)
            ret = null;

        // If page was posted due to a HttpResponse.Redirect, ignore the postback.
        else if (Request.QueryStringText.IndexOf(HttpResponse.RedirectQueryStringAssignment, StringComparison.Ordinal) != -1)
            ret = null;

        return ret;
    }

    /// <summary>
    /// Returns an unvalidated name/value collection of the postback variables. This method will
    /// only be called if DeterminePostBackMode() returns a non-null value.
    /// This method exists to support the granular request validation feature added in .NET 4.5
    /// </summary>
    /// <returns>An unvalidated name/value collection of the postback variables.</returns>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected internal virtual NameValueCollection DeterminePostBackModeUnvalidated() {
        // Get the right NameValueCollection base on the method. This is modeled on GetCollectionBasedOnMethod()
        return _request.HttpVerb == HttpVerb.POST ? _request.Unvalidated.Form : _request.Unvalidated.QueryString;
    }

    /// <devdoc>
    /// <para>This method is used to encrypt previous page hidden form variable that is sent to the client
    /// during cross page post. This is to prevent spoofed previous pages from being instantiated and executed.</para>
    /// This is also used by the AssemblyResourceLoader to prevent tampering of URLs.
    /// </devdoc>
    internal static string EncryptString(string s, Purpose purpose) {
        Debug.Assert(s != null);

        // DevDiv Bugs 137864: IVType.Hash is necessary for WebResource / ScriptResource URLs
        // so that client and server caching will continue to work. MS AJAX also caches these
        // client-side, and switching to a different IV type could potentially break MS AJAX
        // due to loading the same Javascript resource multiple times.
        // MSRC 10405: Crypto board approves of this usage of IVType.Hash.

        byte[] clearData = Encoding.UTF8.GetBytes(s);
        byte[] protectedData;
        if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider) {
            // ASP.NET 4.5 Crypto DCR: Go through the new AspNetCryptoServiceProvider
            // if we're configured to do so.
            ICryptoService cryptoService = AspNetCryptoServiceProvider.Instance.GetCryptoService(purpose, CryptoServiceOptions.CacheableOutput);
            protectedData = cryptoService.Protect(clearData);
        }
        else {
            // If we're not configured to go through the new crypto routines,
            // fall back to the standard MachineKey crypto routines.
#pragma warning disable 618 // calling obsolete methods
            protectedData = MachineKeySection.EncryptOrDecryptData(fEncrypt: true, buf: clearData, modifier: null, start: 0, length: clearData.Length, useValidationSymAlgo: false, useLegacyMode: false, ivType: IVType.Hash);
#pragma warning restore 618 // calling obsolete methods
        }

        return HttpServerUtility.UrlTokenEncode(protectedData);
    }

    private void LoadAllState() {

        object state = LoadPageStateFromPersistenceMedium();
        IDictionary controlStates = null;
        Pair allSavedViewState = null;
        Pair statePair = state as Pair;
        if (state != null) {
            controlStates = statePair.First as IDictionary;
            allSavedViewState = statePair.Second as Pair;
        }

        // The control state (controlStatePair) was saved as an dictionary of objects:
        // 1. A list of controls that require postback[under the page id]
        // 2. A dictionary of control states

        if (controlStates != null) {
            _controlsRequiringPostBack = (ArrayList)controlStates[PageRegisteredControlsThatRequirePostBackKey];

            if (_registeredControlsRequiringControlState != null) {
                foreach (Control ctl in _registeredControlsRequiringControlState) {
                    ctl.LoadControlStateInternal(controlStates[ctl.UniqueID]);
                }
            }
        }

        // The view state (allSavedViewState) was saved as an array of objects:
        // 1. The hash code string
        // 2. The state of the entire control hierarchy

        // Is there any state?
        if (allSavedViewState != null) {
            // Get the hash code from the state
            string hashCode = (string) allSavedViewState.First;

            // If it's different from the current one, the layout has changed
            int viewhash = Int32.Parse(hashCode, NumberFormatInfo.InvariantInfo);
            _fPageLayoutChanged = viewhash != GetTypeHashCode();

            // If the page control layout has changed, don't attempt to
            // load any more state.
            if (!_fPageLayoutChanged) {
                // UNCOMMENT FOR DEBUG OUTPUT
                // WalkViewState(allSavedViewState.Second, null, 0);
                LoadViewStateRecursive(allSavedViewState.Second);

            }
        }
    }

    /*
     * Override this method to persist view state to something other
     * than hidden fields (

*/

    /// <devdoc>
    ///    <para>Loads any saved view state information to the page. Override this method if
    ///       you want to load the page view state in anything other than a hidden field.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected internal virtual object LoadPageStateFromPersistenceMedium() {
        PageStatePersister persister = PageStatePersister;
        try {
            persister.Load();
        }
        catch (HttpException e) {
            //VSWhidbey 201601. Ignore the exception in cross-page post
            //since this might be a cross application postback.

            if (_pageFlags[isCrossPagePostRequest]) {
                return null;
            }

            // DevDiv #461378: Ignore validation errors for cross-page postbacks.
            if (ShouldSuppressMacValidationException(e)) {
                if (Context != null && Context.TraceIsEnabled) {
                    Trace.Write("aspx.page", "Ignoring page state", e);
                }

                ViewStateMacValidationErrorWasSuppressed = true;
                return null;
            }

            e.WebEventCode = WebEventCodes.RuntimeErrorViewStateFailure;
            throw;
        }
        return new Pair(persister.ControlState, persister.ViewState);
    }

    private bool ViewStateMacValidationErrorWasSuppressed {
        get { return _pageFlags[wasViewStateMacErrorSuppressed]; }
        set { _pageFlags[wasViewStateMacErrorSuppressed] = value; }
    }

    internal bool ShouldSuppressMacValidationException(Exception e) {
        // If the patch isn't active, don't suppress anything, as it would be a change in behavior.
        if (!EnableViewStateMacRegistryHelper.SuppressMacValidationErrorsFromCrossPagePostbacks) {
            return false;
        }

        // We check the __VIEWSTATEGENERATOR field for an identifier that matches the current Page.
        // If the generator field exists and says that the current Page generated the incoming
        // __VIEWSTATE field, then a validation failure represents a real error and we need to
        // surface this information to the developer for resolution. Otherwise we assume this
        // view state was not meant for us, so if validation fails we'll just ignore __VIEWSTATE.
        if (ViewStateException.IsMacValidationException(e)) {
            if (EnableViewStateMacRegistryHelper.SuppressMacValidationErrorsAlways) {
                return true;
            }

            // DevDiv #841854: VSUK is often used for CSRF checks, so we can't ---- MAC exceptions by default in this case.
            if (!String.IsNullOrEmpty(ViewStateUserKey)) {
                return false;
            }

            if (_requestValueCollection == null) {
                return true;
            }

            if (!VerifyClientStateIdentifier(_requestValueCollection[ViewStateGeneratorFieldID])) {
                return true;
            }
        }

        return false;
    }

    private bool VerifyClientStateIdentifier(string identifier) {
        // Returns true iff we can parse the incoming identifier and it matches our own.
        // If we can't parse the identifier, then by definition we didn't generate it.
        uint parsedIdentifier;
        return identifier != null
            && UInt32.TryParse(identifier, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out parsedIdentifier)
            && parsedIdentifier == GetClientStateIdentifier();
    }

    internal void LoadScrollPosition() {
        // Don't load scroll position if the previous page was a crosspage postback
        if (_previousPagePath != null) {
            return;
        }
        // Load the scroll positions from the request if they exist
        if (_requestValueCollection != null) {
            string xpos = _requestValueCollection[_scrollPositionXID];
            if (xpos != null) {
                if (!Int32.TryParse(xpos, out _scrollPositionX)) {
                    _scrollPositionX = 0;
                }
            }
            string ypos = _requestValueCollection[_scrollPositionYID];
            if (ypos != null) {
                if (!Int32.TryParse(ypos, out _scrollPositionY)) {
                    _scrollPositionY = 0;
                }
            }
        }
    }

    internal IStateFormatter2 CreateStateFormatter() {
        return new ObjectStateFormatter(this, true);
    }

    // Decomposes the large view state string into pieces of size <= MaxPageStateFieldLength
    internal ICollection DecomposeViewStateIntoChunks() {
        string state = ClientState;
        if (state == null) return null;

        // Any value less than or equal to 0 turns off chunking
        if (MaxPageStateFieldLength <= 0) {
            ArrayList chunks = new ArrayList(1);
            chunks.Add(state);
            return chunks;
        }

        // Break up the view state into the correctly sized chunks
        int numFullChunks = ClientState.Length / MaxPageStateFieldLength;
        ArrayList viewStateChunks = new ArrayList(numFullChunks+1);
        int curPos = 0;
        for (int i=0; i<numFullChunks; i++) {
            viewStateChunks.Add(state.Substring(curPos, MaxPageStateFieldLength));
            curPos += MaxPageStateFieldLength;
        }
        // Add the leftover characters
        if (curPos < state.Length) {
            viewStateChunks.Add(state.Substring(curPos));
        }

        // Always want to return at least one empty chunk
        if (viewStateChunks.Count == 0) {
            viewStateChunks.Add(String.Empty);
        }
        return viewStateChunks;
    }

    internal void RenderViewStateFields(HtmlTextWriter writer) {
        if (_hiddenFieldsToRender == null) {
            _hiddenFieldsToRender = new Dictionary<string, string>();
        }
        if (ClientState != null) {
            ICollection viewStateChunks = DecomposeViewStateIntoChunks();

            writer.WriteLine();

            // Don't write out a view state field count if there is only 1 viewstate field
            if (viewStateChunks.Count > 1) {
                string value = viewStateChunks.Count.ToString(CultureInfo.InvariantCulture);
                writer.Write("<input type=\"hidden\" name=\"");
                writer.Write(ViewStateFieldCountID);
                writer.Write("\" id=\"");
                writer.Write(ViewStateFieldCountID);
                writer.Write("\" value=\"");
                writer.Write(value);
                writer.WriteLine("\" />");
                _hiddenFieldsToRender[ViewStateFieldCountID] = value;
            }

            int count = 0;
            foreach (string stateChunk in viewStateChunks) {
                writer.Write("<input type=\"hidden\" name=\"");
                string name = ViewStateFieldPrefixID;
                writer.Write(ViewStateFieldPrefixID);
                string countString = null;
                if (count > 0) {
                    countString = count.ToString(CultureInfo.InvariantCulture);
                    name += countString;
                    writer.Write(countString);
                }
                writer.Write("\" id=\"");
                writer.Write(name);
                writer.Write("\" value=\"");
                writer.Write(stateChunk);
                writer.WriteLine("\" />");
                ++count;
                _hiddenFieldsToRender[name] = stateChunk;
            }

            // DevDiv #461378: Write out an identifier so we know who generated this __VIEWSTATE field.
            // It doesn't need to be MACed since the only thing we use it for is error suppression,
            // similar to how __PREVIOUSPAGE works.
            if (EnableViewStateMacRegistryHelper.WriteViewStateGeneratorField) {
                // hex is easier than base64 to work with and consumes only one extra byte on the wire
                ClientScript.RegisterHiddenField(ViewStateGeneratorFieldID, GetClientStateIdentifier().ToString("X8", CultureInfo.InvariantCulture));
            }
        }
        else {
            // ASURT 106992
            // Need to always render out the viewstate field so alternate viewstate persistence will get called
            writer.Write("\r\n<input type=\"hidden\" name=\"");
            writer.Write(ViewStateFieldPrefixID);
            // Dev10 

            writer.Write("\" id=\"");
            writer.Write(ViewStateFieldPrefixID);
            writer.WriteLine("\" value=\"\" />");
            _hiddenFieldsToRender[ViewStateFieldPrefixID] = String.Empty;
        }
    }

    /// <devdoc>
    ///     Default markup for begin form.
    /// </devdoc>
    internal void BeginFormRender(HtmlTextWriter writer, string formUniqueID) {

        // DevDiv 27324: Form should render div tag around hidden inputs
        // DevDiv 33149: backward compat. switch for obsolete rendering
        // Dev10 705089: in 4.0 mode or later, we render the div block with class="aspNetHidden" for xHTML conformance.
        bool renderDivAroundHiddenInputs = RenderDivAroundHiddenInputs(writer);
        if (renderDivAroundHiddenInputs) {
            writer.WriteLine();
            if (RenderingCompatibility >= VersionUtil.Framework40) {
                writer.Write("<div class=\"" + HiddenClassName + "\">");
            }
            else {
                writer.Write("<div>");
            }
        }

        ClientScript.RenderHiddenFields(writer);
        RenderViewStateFields(writer);

        if (renderDivAroundHiddenInputs) {
            writer.WriteLine("</div>");
        }

        if (ClientSupportsJavaScript) {
            if (MaintainScrollPositionOnPostBack && _requireScrollScript == false) {
                ClientScript.RegisterHiddenField(_scrollPositionXID, _scrollPositionX.ToString(CultureInfo.InvariantCulture));
                ClientScript.RegisterHiddenField(_scrollPositionYID, _scrollPositionY.ToString(CultureInfo.InvariantCulture));
                ClientScript.RegisterStartupScript(typeof(Page), PageScrollPositionScriptKey, @"
theForm.oldSubmit = theForm.submit;
theForm.submit = WebForm_SaveScrollPositionSubmit;

theForm.oldOnSubmit = theForm.onsubmit;
theForm.onsubmit = WebForm_SaveScrollPositionOnSubmit;
" + (IsPostBack ? @"
theForm.oldOnLoad = window.onload;
window.onload = WebForm_RestoreScrollPosition;
" : String.Empty), true);
                RegisterWebFormsScript();
                _requireScrollScript = true;
            }

            // VSWhidbey 375885, Render the focus script later (specifically for interaction with scrollposition)
            if (ClientSupportsFocus && Form != null && (RenderFocusScript || (Form.DefaultFocus.Length > 0) || (Form.DefaultButton.Length > 0))) {
                string focusedControlId = String.Empty;

                // Someone calling SetFocus(controlId) is the most precendent
                if (FocusedControlID.Length > 0) {
                    focusedControlId = FocusedControlID;
                }
                else if (FocusedControl != null) {
                    if (FocusedControl.Visible) {
                        focusedControlId = FocusedControl.ClientID;
                    }
                }
                else if (ValidatorInvalidControl.Length > 0) {
                    focusedControlId = ValidatorInvalidControl;
                }
                // AutoPostBack focus is the second least precendent
                else if (LastFocusedControl.Length > 0) {
                    // This doesn't have to be an ASP.NET control
                    focusedControlId = LastFocusedControl;
                }
                // DefaultFocus is the next
                else if (Form.DefaultFocus.Length > 0) {
                    // VSWhidbey 379627: Always render the default focus, regardless if we can find it, or if its visible
                    focusedControlId = Form.DefaultFocus;
                }
                // DefaultButton is the least precendent
                else if (Form.DefaultButton.Length > 0) {
                    focusedControlId = Form.DefaultButton;
                }

                // If something got focused, render some script to focus it only if its safe
                int match;
                if (focusedControlId.Length > 0 && !CrossSiteScriptingValidation.IsDangerousString(focusedControlId, out match) &&
                    CrossSiteScriptingValidation.IsValidJavascriptId(focusedControlId)) {

                    ClientScript.RegisterClientScriptResource(typeof(HtmlForm), "Focus.js");

                    if (!ClientScript.IsClientScriptBlockRegistered(typeof(HtmlForm), "Focus")) {
                        RegisterWebFormsScript();
                        ClientScript.RegisterStartupScript(
                            typeof(HtmlForm),
                            "Focus",
                            "WebForm_AutoFocus('" + Util.QuoteJScriptString(focusedControlId) + "');",
                            true);
                    }

                    IScriptManager scriptManager = ScriptManager;
                    if (scriptManager != null) {
                        scriptManager.SetFocusInternal(focusedControlId);
                    }
                }
            }


            // Set the necessary stuff to re-enable disabled controls on the client
            if (RenderDisabledControlsScript) {
                ClientScript.RegisterOnSubmitStatement(typeof(Page), PageReEnableControlsScriptKey, "WebForm_ReEnableControls();");
                RegisterWebFormsScript();
            }

            if (_fRequirePostBackScript) {
                RenderPostBackScript(writer, formUniqueID);
            }

            if (_fRequireWebFormsScript) {
                RenderWebFormsScript(writer);
            }
        }

        ClientScript.RenderClientScriptBlocks(writer);
    }

    internal void EndFormRenderArrayAndExpandoAttribute(HtmlTextWriter writer, string formUniqueID) {
        if (ClientSupportsJavaScript) {
            // Devdiv 9409 - Register the array for reenabling only after the controls have been processed,
            // so that list controls can have their children registered.
            if (RenderDisabledControlsScript) {
                foreach (Control control in EnabledControls) {
                    ClientScript.RegisterArrayDeclaration(EnabledControlArray, "'" + control.ClientID + "'");
                }
            }
            ClientScript.RenderArrayDeclares(writer);
            ClientScript.RenderExpandoAttribute(writer);
        }
    }

    private bool RenderDisabledControlsScript {
        get {
            return Form.SubmitDisabledControls && (EnabledControls.Count > 0) &&
                (_request.Browser.W3CDomVersion.Major > 0);
        }
    }

    internal void EndFormRenderHiddenFields(HtmlTextWriter writer, string formUniqueID) {
        if (RequiresViewStateEncryptionInternal) {
            ClientScript.RegisterHiddenField(ViewStateEncryptionID, String.Empty);
        }

        if (_containsCrossPagePost) {
            string path = EncryptString(Request.CurrentExecutionFilePath, Purpose.WebForms_Page_PreviousPageID);
            ClientScript.RegisterHiddenField(previousPageID, path);
        }

        if (EnableEventValidation) {
            ClientScript.SaveEventValidationField();
        }

        if (ClientScript.HasRegisteredHiddenFields) {
            bool renderDivAroundHiddenInputs = RenderDivAroundHiddenInputs(writer);
            if (renderDivAroundHiddenInputs) {
                writer.WriteLine();
                if (RenderingCompatibility >= VersionUtil.Framework40) {
                    writer.AddAttribute(HtmlTextWriterAttribute.Class, HiddenClassName);
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Div);
            }

            ClientScript.RenderHiddenFields(writer);

            if (renderDivAroundHiddenInputs) {
                writer.RenderEndTag(); // DIV
            }
        }
    }

    internal void EndFormRenderPostBackAndWebFormsScript(HtmlTextWriter writer, string formUniqueID) {
        if (ClientSupportsJavaScript) {
            if (_fRequirePostBackScript && !_fPostBackScriptRendered) {
                RenderPostBackScript(writer, formUniqueID);
            }

            if (_fRequireWebFormsScript && !_fWebFormsScriptRendered)
                RenderWebFormsScript(writer);
        }

        ClientScript.RenderClientStartupScripts(writer);
    }

    /// <devdoc>
    ///     Default markup for end form.
    /// </devdoc>
    internal void EndFormRender(HtmlTextWriter writer, string formUniqueID) {
        EndFormRenderArrayAndExpandoAttribute(writer, formUniqueID);
        EndFormRenderHiddenFields(writer, formUniqueID);
        EndFormRenderPostBackAndWebFormsScript(writer, formUniqueID);
    }

    // VSWhidbey 475945: For ClientScriptManager.GetPostBackEventReference() to check if '$' should be used for id separator
    internal bool IsInOnFormRender {
        get {
            return _inOnFormRender;
        }
    }

    /// <devdoc>
    ///     Called by both adapters and default rendering prior to form rendering.
    /// </devdoc>
    internal void OnFormRender() {
        // Make sure there is only one form tag (ASURT 18891, 18894)
        if (_fOnFormRenderCalled) {
            throw new HttpException(SR.GetString(SR.Multiple_forms_not_allowed));
        }

        _fOnFormRenderCalled = true;
        _inOnFormRender = true;
    }

    /// <devdoc>
    ///     Called by both adapters and default rendering after form rendering.
    /// </devdoc>
    internal void OnFormPostRender(HtmlTextWriter writer) {
        _inOnFormRender = false;
        if (_postFormRenderDelegate != null) {
            _postFormRenderDelegate(writer, null);
        }
    }

    /// <devdoc>
    ///     Needed by adapters which do more than one pass, so that OnFormRender can be called more than once.
    /// </devdoc>
    // 
    internal void ResetOnFormRenderCalled() {
        _fOnFormRenderCalled = false;
    }


    /// <devdoc>
    /// Sets focus to the specified control
    /// </devdoc>
    public void SetFocus(Control control) {
        if (control == null) {
            throw new ArgumentNullException("control");
        }

        if (Form == null) {
            throw new InvalidOperationException(SR.GetString(SR.Form_Required_For_Focus));
        }

        if (Form.ControlState == ControlState.PreRendered) {
            throw new InvalidOperationException(SR.GetString(SR.Page_MustCallBeforeAndDuringPreRender, "SetFocus"));
        }

        _focusedControl = control;
        _focusedControlID = null;

        RegisterFocusScript();
    }


    /// <devdoc>
    /// Sets focus to the specified client id
    /// </devdoc>
    public void SetFocus(string clientID) {
        if ((clientID == null) || (clientID.Trim().Length == 0)) {
            throw new ArgumentNullException("clientID");
        }

        if (Form == null) {
            throw new InvalidOperationException(SR.GetString(SR.Form_Required_For_Focus));
        }

        if (Form.ControlState == ControlState.PreRendered) {
            throw new InvalidOperationException(SR.GetString(SR.Page_MustCallBeforeAndDuringPreRender, "SetFocus"));
        }

        _focusedControlID = clientID.Trim();
        _focusedControl = null;

        RegisterFocusScript();
    }

    internal void SetValidatorInvalidControlFocus(string clientID) {
        if (String.IsNullOrEmpty(_validatorInvalidControl)) {
            _validatorInvalidControl = clientID;

            RegisterFocusScript();
        }
    }

    //Note: BCL should provide a way to abort threads without asserting ControlThread for platform internal code.
    [SecurityPermission(SecurityAction.Assert, ControlThread = true)]
    internal static void ThreadResetAbortWithAssert() {
        Thread.ResetAbort();
    }

    /*
     * Enables controls to obtain client-side script function that will cause
     * (when invoked) a server post-back to the form.
     */

    /// <devdoc>
    ///    <para>
    ///       Associates the reference to the control that will
    ///       process the postback on the server.
    ///    </para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Obsolete("The recommended alternative is ClientScript.GetPostBackEventReference. http://go.microsoft.com/fwlink/?linkid=14202")]
    public string GetPostBackEventReference(Control control) {
        return ClientScript.GetPostBackEventReference(control, String.Empty);
    }

    /*
     * Enables controls to obtain client-side script function that will cause
     * (when invoked) a server post-back to the form.
     * argument: Parameter that will be passed to control on server
     */

    /// <devdoc>
    ///    <para>Passes a parameter to the control that will do the postback processing on the
    ///       server.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Obsolete("The recommended alternative is ClientScript.GetPostBackEventReference. http://go.microsoft.com/fwlink/?linkid=14202")]
    public string GetPostBackEventReference(Control control,
                                            string argument) {
        return ClientScript.GetPostBackEventReference(control, argument);
    }


    /// <devdoc>
    ///    <para>This returs a string that can be put in client event to post back to the named control</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Obsolete("The recommended alternative is ClientScript.GetPostBackEventReference. http://go.microsoft.com/fwlink/?linkid=14202")]
    public string GetPostBackClientEvent(Control control, string argument) {
        return ClientScript.GetPostBackEventReference(control, argument);
    }


    /// <devdoc>
    ///    <para>This returs a string that can be put in client event to post back to the named control</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Obsolete("The recommended alternative is ClientScript.GetPostBackClientHyperlink. http://go.microsoft.com/fwlink/?linkid=14202")]
    public string GetPostBackClientHyperlink(Control control, string argument) {
        return ClientScript.GetPostBackClientHyperlink(control, argument, false);
    }

    internal void InitializeStyleSheet() {
        if (_pageFlags[styleSheetInitialized]) {
            return;
        }

        String styleSheetName = StyleSheetTheme;
        if (!String.IsNullOrEmpty(styleSheetName)) {

            BuildResultCompiledType resultType = ThemeDirectoryCompiler.GetThemeBuildResultType(
                Context, styleSheetName);

            if (resultType != null) {
                _styleSheet = (PageTheme)resultType.CreateInstance();
                _styleSheet.Initialize(this, true);
            }
            else {
                throw new HttpException(SR.GetString(SR.Page_theme_not_found, styleSheetName));
            }
        }

        _pageFlags.Set(styleSheetInitialized);
    }

    private void InitializeThemes() {
        String themeName = Theme;
        if (!String.IsNullOrEmpty(themeName)) {
            BuildResultCompiledType resultType = ThemeDirectoryCompiler.GetThemeBuildResultType(
                Context, themeName);

            if (resultType != null) {
                _theme = (PageTheme)resultType.CreateInstance();
                _theme.Initialize(this, false);
            }
            else {
                throw new HttpException(SR.GetString(SR.Page_theme_not_found, themeName));
            }
        }
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    protected internal void AddContentTemplate(string templateName, ITemplate template) {
        if (_contentTemplateCollection == null) {
            _contentTemplateCollection = new Hashtable(11, StringComparer.OrdinalIgnoreCase);
        }

        try {
            _contentTemplateCollection.Add(templateName, template);
        }
        catch (ArgumentException) {
            throw new HttpException(SR.GetString(SR.MasterPage_Multiple_content, templateName));
        }
    }

    private void ApplyMasterPage() {
        if (Master != null) {
            ArrayList appliedMasterPages = new ArrayList();
            appliedMasterPages.Add(_masterPageFile.VirtualPathString.ToLower(CultureInfo.InvariantCulture));
            MasterPage.ApplyMasterRecursive(Master, appliedMasterPages);
        }
    }

    internal void ApplyControlSkin(Control ctrl) {
        if (_theme != null) {
            _theme.ApplyControlSkin(ctrl);
        }
    }

    internal bool ApplyControlStyleSheet(Control ctrl) {
        if (_styleSheet != null) {
            _styleSheet.ApplyControlSkin(ctrl);
            return true;
        }

        return false;
    }

    internal void RegisterFocusScript() {
        if (ClientSupportsFocus && (_requireFocusScript == false)) {
            ClientScript.RegisterHiddenField(lastFocusID, String.Empty);
            _requireFocusScript = true;

            // If there are any partial caching controls on the stack, forward the call to them
            if (_partialCachingControlStack != null) {
                foreach(BasePartialCachingControl c in _partialCachingControlStack) {
                    c.RegisterFocusScript();
                }
            }
        }
    }

    internal void RegisterPostBackScript() {
        if (!ClientSupportsJavaScript) {
            return;
        }

        if (_fPostBackScriptRendered) {
            return;
        }

        if (!_fRequirePostBackScript) {
            ClientScript.RegisterHiddenField(postEventSourceID, String.Empty);
            ClientScript.RegisterHiddenField(postEventArgumentID, String.Empty);

            _fRequirePostBackScript = true;
        }

        // If there are any partial caching controls on the stack, forward the call to them
        if (_partialCachingControlStack != null) {
            foreach(BasePartialCachingControl c in _partialCachingControlStack) {
                c.RegisterPostBackScript();
            }
        }
    }

    private void RenderPostBackScript(HtmlTextWriter writer, string formUniqueID) {
        writer.Write(EnableLegacyRendering ?
            ClientScriptManager.ClientScriptStartLegacy :
            ClientScriptManager.ClientScriptStart);
        if (PageAdapter != null) {
            writer.Write("var theForm = ");
            writer.Write(PageAdapter.GetPostBackFormReference(formUniqueID));
            writer.WriteLine(";");
        }
        else {
            writer.Write("var theForm = document.forms['");
            writer.Write(formUniqueID);
            writer.WriteLine("'];");

            // VSWhidbey 392597: Try to use the document._ctl00 syntax since PocketPC doesn't support document.forms[id]
            writer.Write("if (!theForm) {\r\n    theForm = document.");
            writer.Write(formUniqueID);
            writer.WriteLine(";\r\n}");
        }
        writer.WriteLine(@"function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
        theForm.__EVENTTARGET.value = eventTarget;
        theForm.__EVENTARGUMENT.value = eventArgument;
        theForm.submit();
    }
}");
        writer.WriteLine(EnableLegacyRendering ?
             ClientScriptManager.ClientScriptEndLegacy :
             ClientScriptManager.ClientScriptEnd);
        _fPostBackScriptRendered = true;
    }


    /// <devdoc>
    ///   Allows controls on a page to access to the _doPostBack and _doCallback JavaScript handlers on the
    ///   client. This method can be called multiple times by multiple controls. It should
    ///   render only one instance of the WebForms script.
    /// </devdoc>
    internal void RegisterWebFormsScript() {
        if (ClientSupportsJavaScript) {
            if (_fWebFormsScriptRendered) {
                return;
            }

            RegisterPostBackScript();

            _fRequireWebFormsScript = true;

            // If there are any partial caching controls on the stack, forward the call to them
            if (_partialCachingControlStack != null) {
                foreach(BasePartialCachingControl c in _partialCachingControlStack) {
                    c.RegisterWebFormsScript();
                }
            }
        }
    }

    private void RenderWebFormsScript(HtmlTextWriter writer) {
        ClientScript.RenderWebFormsScript(writer);
        _fWebFormsScriptRendered = true;
    }


    /// <devdoc>
    ///    <para>Determines if the client script block is registered with the page.</para>
    /// </devdoc>
    [Obsolete("The recommended alternative is ClientScript.IsClientScriptBlockRegistered(string key). http://go.microsoft.com/fwlink/?linkid=14202")]
    public bool IsClientScriptBlockRegistered(string key) {
        return ClientScript.IsClientScriptBlockRegistered(typeof(Page), key);
    }


    /// <devdoc>
    ///    <para>Determines if the client startup script is registered with the
    ///       page.</para>
    /// </devdoc>
    [Obsolete("The recommended alternative is ClientScript.IsStartupScriptRegistered(string key). http://go.microsoft.com/fwlink/?linkid=14202")]
    public bool IsStartupScriptRegistered(string key) {
        return ClientScript.IsStartupScriptRegistered(typeof(Page), key);
    }


    /// <devdoc>
    ///    <para>Declares a value that will be declared as a JavaScript array declaration
    ///       when the page renders. This can be used by script-based controls to declare
    ///       themselves within an array so that a client script library can work with
    ///       all the controls of the same type.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Obsolete("The recommended alternative is ClientScript.RegisterArrayDeclaration(string arrayName, string arrayValue). http://go.microsoft.com/fwlink/?linkid=14202")]
    public void RegisterArrayDeclaration(string arrayName, string arrayValue) {
        ClientScript.RegisterArrayDeclaration(arrayName, arrayValue);
    }


    /// <devdoc>
    ///    <para>
    ///       Allows controls to automatically register a hidden field on the form. The
    ///       field will be emitted when the form control renders itself.
    ///    </para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Obsolete("The recommended alternative is ClientScript.RegisterHiddenField(string hiddenFieldName, string hiddenFieldInitialValue). http://go.microsoft.com/fwlink/?linkid=14202")]
    public virtual void RegisterHiddenField(string hiddenFieldName, string hiddenFieldInitialValue) {
        ClientScript.RegisterHiddenField(hiddenFieldName, hiddenFieldInitialValue);
    }


    /// <devdoc>
    ///    <para> Prevents controls from sending duplicate blocks of
    ///       client-side script to the client. Any script blocks with the same <paramref name="key"/> parameter
    ///       values are considered duplicates.</para>
    /// </devdoc>
    [Obsolete("The recommended alternative is ClientScript.RegisterClientScriptBlock(Type type, string key, string script). http://go.microsoft.com/fwlink/?linkid=14202")]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual void RegisterClientScriptBlock(string key, string script) {
        ClientScript.RegisterClientScriptBlock(typeof(Page), key, script);
    }


    /// <devdoc>
    ///    <para>
    ///       Allows controls to keep duplicate blocks of client-side script code from
    ///       being sent to the client. Any script blocks with the same <paramref name="key"/> parameter
    ///       value are considered duplicates.
    ///    </para>
    /// </devdoc>
    [Obsolete("The recommended alternative is ClientScript.RegisterStartupScript(Type type, string key, string script). http://go.microsoft.com/fwlink/?linkid=14202")]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual void RegisterStartupScript(string key, string script) {
        ClientScript.RegisterStartupScript(typeof(Page), key, script, false);
    }


    /// <devdoc>
    ///    <para>Allows a control to access a the client
    ///    <see langword='onsubmit'/> event.
    ///       The script should be a function call to client code registered elsewhere.</para>
    /// </devdoc>
    [Obsolete("The recommended alternative is ClientScript.RegisterOnSubmitStatement(Type type, string key, string script). http://go.microsoft.com/fwlink/?linkid=14202")]
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public void RegisterOnSubmitStatement(string key, string script) {
        ClientScript.RegisterOnSubmitStatement(typeof(Page), key, script);
    }

    internal void RegisterEnabledControl(Control control) {
        EnabledControls.Add(control);
    }

    /// <devdoc>
    ///    <para>If called, Control State for this control will be persisted.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public void RegisterRequiresControlState(Control control) {
        if (control == null) {
            throw new ArgumentException(SR.GetString(SR.Page_ControlState_ControlCannotBeNull));
        }

        if (control.ControlState == ControlState.PreRendered) {
            throw new InvalidOperationException(SR.GetString(SR.Page_MustCallBeforeAndDuringPreRender, "RegisterRequiresControlState"));
        }

        if (_registeredControlsRequiringControlState == null) {
            _registeredControlsRequiringControlState = new ControlSet();
        }

        // Don't do anything if RegisterRequiresControlState is called multiple times on the same control.
        if (!_registeredControlsRequiringControlState.Contains(control)) {
            _registeredControlsRequiringControlState.Add(control);

            IDictionary controlState = (IDictionary)PageStatePersister.ControlState;
            if (controlState != null) {
                string uniqueID = control.UniqueID;

                // VSWhidbey 422416: We allow control state loaded only once, to
                // match the same behavior of ViewState loading in Control.AddedControl
                // method which ViewState is removed after applied once.  The
                // scenario is having a control to be re-parented multiple times.
                // Note: We can't call remove here, because we may be in the middle of iterating thru
                // the keys of controlState(within in a call to RegisterRequiresClearChildControlState),
                // so we just remember that we loaded this control's control state
                if (!ControlStateLoadedControlIds.Contains(uniqueID)) {
                    control.LoadControlStateInternal(controlState[uniqueID]);
                    ControlStateLoadedControlIds.Add(uniqueID);
                }
            }
        }
    }

    public bool RequiresControlState(Control control) {
        return (_registeredControlsRequiringControlState != null && _registeredControlsRequiringControlState.Contains(control));
    }

    /// <devdoc>
    ///    <para>If called, Control State for this control will no longer persisted.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public void UnregisterRequiresControlState(Control control) {
        if (control == null) {
            throw new ArgumentException(SR.GetString(SR.Page_ControlState_ControlCannotBeNull));
        }

        if (_registeredControlsRequiringControlState == null) {
            return;
        }

        _registeredControlsRequiringControlState.Remove(control);
    }

    internal bool ShouldLoadControlState(Control control) {
        if (_registeredControlsRequiringClearChildControlState == null) return true;
        foreach (Control cleared in _registeredControlsRequiringClearChildControlState.Keys) {
            if (control != cleared && control.IsDescendentOf(cleared)) return false;
        }
        return true;
    }

    internal void RegisterRequiresClearChildControlState(Control control) {
        if (_registeredControlsRequiringClearChildControlState == null) {
            _registeredControlsRequiringClearChildControlState = new HybridDictionary();
            _registeredControlsRequiringClearChildControlState.Add(control, true);
        }
        else if (_registeredControlsRequiringClearChildControlState[control] == null) {
            _registeredControlsRequiringClearChildControlState.Add(control, true);
        }

        IDictionary controlState = (IDictionary)PageStatePersister.ControlState;
        if (controlState != null) {
            // Clear out the control state for children of this control
            List<string> controlsToClear = new List<string>(controlState.Count);
            foreach (string id in controlState.Keys) {
                Control controlWithState = FindControl(id);
                if (controlWithState != null && controlWithState.IsDescendentOf(control)) {
                    controlsToClear.Add(id);
                }
            }
            foreach (string id in controlsToClear) {
                controlState[id] = null;
            }
        }
    }


    /// <devdoc>
    ///    <para>Registers a control as one that requires postback handling.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public void RegisterRequiresPostBack(Control control) {

        // Fail if the control is not an IPostBackDataHandler (VSWhidbey 184483)
        if (!(control is IPostBackDataHandler)) {
            IPostBackDataHandler dataHandler = control.AdapterInternal as IPostBackDataHandler;
            if (dataHandler == null)
                throw new HttpException(SR.GetString(SR.Ctrl_not_data_handler));
        }

        if (_registeredControlsThatRequirePostBack == null)
            _registeredControlsThatRequirePostBack = new ArrayList();

        _registeredControlsThatRequirePostBack.Add(control.UniqueID);
    }

    // Push a BasePartialCachingControl on the stack of registered caching controls
    internal void PushCachingControl(BasePartialCachingControl c) {

        // Create the stack on demand
        if (_partialCachingControlStack == null) {
            _partialCachingControlStack = new Stack();
        }

        _partialCachingControlStack.Push(c);
    }

    // Pop a BasePartialCachingControl from the stack of registered caching controls
    internal void PopCachingControl() {
        Debug.Assert(_partialCachingControlStack != null);
        _partialCachingControlStack.Pop();
    }


    /*
     * This method will process the data posted back in the request header.
     * The collection of posted data keys consists of three types :
     * 1.  Fully qualified ids of controls.  The associated value is the data
     *     posted back by the browser for an intrinsic html element.
     * 2.  Fully qualified ids of controls that have explicitly registered that
     *     they want to be notified on postback.  This is required for intrinsic
     *     html elements that for some states do not postback data ( e.g. a select
     *     when there is no selection, a checkbox or radiobutton that is not checked )
     *     The associated value for these keys is not relevant.
     * 3.  Framework generated hidden fields for event processing, whose values are
     *     set by client-side script prior to postback.
     *
     * This method handles the process of notifying the relevant controls that a postback
     * has occurred, via the IPostBackDataHandler interface.
     *
     * It can potentially be called twice: before and after LoadControl.  This is to
     * handle the case where users programmatically add controls in Page_Load (ASURT 29045).
     */
    private void ProcessPostData(NameValueCollection postData, bool fBeforeLoad) {
        if (_changedPostDataConsumers == null)
            _changedPostDataConsumers = new ArrayList();

        // identify controls that have postback data
        if (postData != null) {
            foreach (string postKey in postData) {
                if (postKey != null) {
                    // Ignore system post fields
                    if (IsSystemPostField(postKey))
                        continue;

                    Control ctrl = FindControl(postKey);
                    if (ctrl == null) {
                        if (fBeforeLoad) {
                            // It was not found, so keep track of it for the post load attempt
                            if (_leftoverPostData == null)
                                _leftoverPostData = new NameValueCollection();
                            _leftoverPostData.Add(postKey, null);
                        }
                        continue;
                    }

                    IPostBackDataHandler consumer = ctrl.PostBackDataHandler;

                    // Ignore controls that are not IPostBackDataHandler (see ASURT 13581)
                    if (consumer == null) {

                        // If it's a IPostBackEventHandler (which doesn't implement IPostBackDataHandler),
                        // register it (ASURT 39040)
                        if(ctrl.PostBackEventHandler != null)
                            RegisterRequiresRaiseEvent(ctrl.PostBackEventHandler);

                        continue;
                    }

                    bool changed;
                    if(consumer != null) {
                        NameValueCollection postCollection = ctrl.CalculateEffectiveValidateRequest() ? _requestValueCollection : _unvalidatedRequestValueCollection;
                        changed = consumer.LoadPostData(postKey, postCollection);
                        if(changed)
                           _changedPostDataConsumers.Add(ctrl);
                    }

                    // ensure controls are only notified of postback once
                    if (_controlsRequiringPostBack != null)
                        _controlsRequiringPostBack.Remove(postKey);
                }
            }
        }

        // Keep track of the leftover for the post-load attempt
        ArrayList leftOverControlsRequiringPostBack = null;

        // process controls that explicitly registered to be notified of postback
        if (_controlsRequiringPostBack != null) {
            foreach (string controlID in _controlsRequiringPostBack) {
                Control c = FindControl(controlID);

                if (c != null) {
                    IPostBackDataHandler consumer = c.AdapterInternal as IPostBackDataHandler;
                    if(consumer == null) {
                        consumer = c as IPostBackDataHandler;
                    }

                    // Give a helpful error if the control is not a IPostBackDataHandler (ASURT 128532)
                    if (consumer == null) {
                        throw new HttpException(SR.GetString(SR.Postback_ctrl_not_found, controlID));
                    }

                    NameValueCollection postCollection = c.CalculateEffectiveValidateRequest() ? _requestValueCollection : _unvalidatedRequestValueCollection;
                    bool changed = consumer.LoadPostData(controlID, postCollection);
                    if (changed)
                        _changedPostDataConsumers.Add(c);
                }
                else {
                    if (fBeforeLoad) {
                        if (leftOverControlsRequiringPostBack == null)
                            leftOverControlsRequiringPostBack = new ArrayList();
                        leftOverControlsRequiringPostBack.Add(controlID);
                    }
                }
            }

            _controlsRequiringPostBack = leftOverControlsRequiringPostBack;
        }

    }

    // Operations like FindControl and LoadPostData call EnsureDataBound, which may fire up 
    // async model binding methods. Therefore we make ProcessPostData method to be async so that we can await 
    // async data bindings.
    // The differences between ProcessPostData and ProcessPostDataAsync are:
    // 1. ProcessPostDataAsync awaits GetWaitForPreviousStepCompletionAwaitable after FindControl();
    // 2. ProcessPostDataAsync calls LoadPostDataAsync() instead of LoadPostData().
    private async Task ProcessPostDataAsync(NameValueCollection postData, bool fBeforeLoad) {
        if (_changedPostDataConsumers == null)
            _changedPostDataConsumers = new ArrayList();

        // identify controls that have postback data
        if (postData != null) {
            foreach (string postKey in postData) {
                if (postKey != null) {
                    // Ignore system post fields
                    if (IsSystemPostField(postKey))
                        continue;

                    Control ctrl = null;
                    using (Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                        ctrl = FindControl(postKey);
                        await GetWaitForPreviousStepCompletionAwaitable();
                    }

                    if (ctrl == null) {
                        if (fBeforeLoad) {
                            // It was not found, so keep track of it for the post load attempt
                            if (_leftoverPostData == null)
                                _leftoverPostData = new NameValueCollection();
                            _leftoverPostData.Add(postKey, null);
                        }
                        continue;
                    }

                    IPostBackDataHandler consumer = ctrl.PostBackDataHandler;

                    // Ignore controls that are not IPostBackDataHandler (see ASURT 13581)
                    if (consumer == null) {

                        // If it's a IPostBackEventHandler (which doesn't implement IPostBackDataHandler),
                        // register it (ASURT 39040)
                        if (ctrl.PostBackEventHandler != null)
                            RegisterRequiresRaiseEvent(ctrl.PostBackEventHandler);

                        continue;
                    }

                    if (consumer != null) {
                        NameValueCollection postCollection = ctrl.CalculateEffectiveValidateRequest() ? _requestValueCollection : _unvalidatedRequestValueCollection;
                        bool changed = await LoadPostDataAsync(consumer, postKey, postCollection);

                        if (changed)
                            _changedPostDataConsumers.Add(ctrl);
                    }

                    // ensure controls are only notified of postback once
                    if (_controlsRequiringPostBack != null)
                        _controlsRequiringPostBack.Remove(postKey);
                }
            }
        }

        // Keep track of the leftover for the post-load attempt
        ArrayList leftOverControlsRequiringPostBack = null;

        // process controls that explicitly registered to be notified of postback
        if (_controlsRequiringPostBack != null) {
            foreach (string controlID in _controlsRequiringPostBack) {
                Control c = null;
                using (Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    c = FindControl(controlID);
                    await GetWaitForPreviousStepCompletionAwaitable();
                }

                if (c != null) {
                    IPostBackDataHandler consumer = c.AdapterInternal as IPostBackDataHandler;
                    if (consumer == null) {
                        consumer = c as IPostBackDataHandler;
                    }

                    // Give a helpful error if the control is not a IPostBackDataHandler (ASURT 128532)
                    if (consumer == null) {
                        throw new HttpException(SR.GetString(SR.Postback_ctrl_not_found, controlID));
                    }

                    NameValueCollection postCollection = c.CalculateEffectiveValidateRequest() ? _requestValueCollection : _unvalidatedRequestValueCollection;
                    bool changed = await LoadPostDataAsync(consumer, controlID, postCollection);
                    if (changed)
                        _changedPostDataConsumers.Add(c);
                }
                else {
                    if (fBeforeLoad) {
                        if (leftOverControlsRequiringPostBack == null)
                            leftOverControlsRequiringPostBack = new ArrayList();
                        leftOverControlsRequiringPostBack.Add(controlID);
                    }
                }
            }

            _controlsRequiringPostBack = leftOverControlsRequiringPostBack;
        }

    }

    private async Task<bool> LoadPostDataAsync(IPostBackDataHandler consumer, string postKey, NameValueCollection postCollection) {
        bool changed;

        // ListControl family controls call EnsureDataBound in consumer.LoadPostData, which could be an async call in 4.6. 
        // LoadPostData, however, is a sync method, which means we cannot await EnsureDataBound in the method.
        // To workaround this, for ListControl family controls, we call EnsureDataBound before we call into LoadPostData.
        if (AppSettings.EnableAsyncModelBinding && consumer is ListControl) {
            var listControl = consumer as ListControl;
            listControl.SkipEnsureDataBoundInLoadPostData = true;
            using (Context.SyncContext.AllowVoidAsyncOperationsBlock()) {                
                listControl.InternalEnsureDataBound();                
                await GetWaitForPreviousStepCompletionAwaitable();
            }
        }

        changed = consumer.LoadPostData(postKey, postCollection);

        return changed;
    }

    /*
     * This method will raise change events for those controls that indicated
     * during PostProcessData that their data has changed.
     */
    // !! IMPORTANT !!
    // If you change this method, also change RaiseChangedEventsAsync.
    internal void RaiseChangedEvents() {
        if (_changedPostDataConsumers != null) {
            // fire change notifications for those controls that changed as a result of postback
            for (int i=0; i < _changedPostDataConsumers.Count; i++) {
                Control c = (Control)_changedPostDataConsumers[i];
                IPostBackDataHandler changedPostDataConsumer;

                if(c != null) {
                    changedPostDataConsumer = c.PostBackDataHandler;
                }
                else {
                    continue;
                }

                // Make sure the IPostBackDataHandler is still in the tree (ASURT 82495)
                if (c != null && !c.IsDescendentOf(this))
                    continue;

                if(c != null && c.PostBackDataHandler != null) {
                    changedPostDataConsumer.RaisePostDataChangedEvent();
                }
            }
        }
    }

    // TAP version of RaiseChangedEvents.
    // !! IMPORTANT !!
    // If you change this method, also change RaiseChangedEvents.
    internal async Task RaiseChangedEventsAsync() {
        if (_changedPostDataConsumers != null) {
            // fire change notifications for those controls that changed as a result of postback
            for (int i = 0; i < _changedPostDataConsumers.Count; i++) {
                Control c = (Control)_changedPostDataConsumers[i];
                IPostBackDataHandler changedPostDataConsumer;

                if (c != null) {
                    changedPostDataConsumer = c.PostBackDataHandler;
                }
                else {
                    continue;
                }

                // Make sure the IPostBackDataHandler is still in the tree (ASURT 82495)
                if (c != null && !c.IsDescendentOf(this))
                    continue;

                if (c != null && c.PostBackDataHandler != null) {
                    using (Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                        changedPostDataConsumer.RaisePostDataChangedEvent();
                        await GetWaitForPreviousStepCompletionAwaitable();
                    }
                }
            }
        }
    }

    private void RaisePostBackEvent(NameValueCollection postData) {

        // first check if there is a register control needing the postback event
        // if we don't have one of those, fall back to the hidden field
        // Note: this must happen before we look at postData[postEventArgumentID] (ASURT 50106)
        if (_registeredControlThatRequireRaiseEvent != null) {
            RaisePostBackEvent(_registeredControlThatRequireRaiseEvent, null);
        }
        else {
            string eventSource = postData[postEventSourceID];
            bool hasEventSource = (!String.IsNullOrEmpty(eventSource));

            // VSWhidbey 204824: We also need to check if the postback is submitted
            // by an autopostback control in mobile browsers which cannot set
            // event target in markup
            if (hasEventSource || AutoPostBackControl != null) {
                Control sourceControl = null;
                if (hasEventSource) {
                    sourceControl = FindControl(eventSource);
                }

                if (sourceControl != null && sourceControl.PostBackEventHandler != null) {
                    string eventArgument = postData[postEventArgumentID];
                    RaisePostBackEvent((sourceControl.PostBackEventHandler), eventArgument);
                }
            }
            else {
                Validate();
            }
        }
    }

    // Overridable method that just calls RaisePostBackEvent on controls (ASURT 48154)

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected virtual void RaisePostBackEvent(IPostBackEventHandler sourceControl, string eventArgument) {
        sourceControl.RaisePostBackEvent(eventArgument);
    }

    // 

    /// <devdoc>
    ///    <para>Registers a control as requiring an event to be raised when it is processed
    ///       on the page.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual void RegisterRequiresRaiseEvent(IPostBackEventHandler control) {
        _registeredControlThatRequireRaiseEvent = control;
    }

    // VSWhidbey 402530
    // This property should be public. (DevDiv Bugs 161340)
    public bool IsPostBackEventControlRegistered {
        get {
            return (_registeredControlThatRequireRaiseEvent != null);
        }
    }


    /// <devdoc>
    ///    <para> Indicates whether page validation succeeded.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public bool IsValid {
        get {
            if (!_validated)
                throw new HttpException(SR.GetString(SR.IsValid_Cant_Be_Called));

            if (_validators != null) {
                ValidatorCollection vc = Validators;
                int count = vc.Count;
                for (int i = 0; i < count; i++) {
                    if (!vc[i].IsValid) {
                        return false;
                    }
                }
            }
            return true;
        }
    }


    /// <devdoc>
    ///    <para>Gets a collection of all validation controls contained on the requested page.</para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public ValidatorCollection Validators {
        get {
            if (_validators == null) {
                _validators = new ValidatorCollection();
            }
            return _validators;
        }
    }


    /// <devdoc>
    ///    <para>Gets the PreviousPage of current Page, it could be either the original Page from
    ///    Server.Transfer or cross page posting.
    ///    </para>
    /// </devdoc>
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public Page PreviousPage {
        get {
            // check _previousPage first since _previousPagePath could be null in case of Server.Transfer
            if (_previousPage == null) {
                if (_previousPagePath != null) {

                    if (!Util.IsUserAllowedToPath(Context, _previousPagePath)) {
                        throw new InvalidOperationException(SR.GetString(SR.Previous_Page_Not_Authorized));
                    }

                    ITypedWebObjectFactory result =
                        (ITypedWebObjectFactory)BuildManager.GetVPathBuildResult(Context, _previousPagePath);

                    // Make sure it has the correct base type
                    if (typeof(Page).IsAssignableFrom(result.InstantiatedType)) {
                        _previousPage = (Page)result.CreateInstance();
                        _previousPage._isCrossPagePostBack = true;

                        Server.Execute(_previousPage, TextWriter.Null,
                            true /*preserveForm*/, false /*setPreviousPage*/);
                    }
                }
            }

            return _previousPage;
        }
    }

    /*
     * Map virtual path (absolute or relative) to physical path
     */

    /// <devdoc>
    ///    <para>Assigns a virtual path, either absolute or relative, to a physical path.</para>
    /// </devdoc>
    public string MapPath(string virtualPath) {
        return _request.MapPath(VirtualPath.CreateAllowNull(virtualPath), TemplateControlVirtualDirectory,
            true/*allowCrossAppMapping*/);
    }

    /*
     * The following members should only be set by derived class through codegen.
     * 
*/

    static char[] s_varySeparator = new char[] {';'};


    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    ///    Note: this methods needs to be virtual because the Mobile control team
    ///    overrides it (ASURT 66157)
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual void InitOutputCache(int duration, string varyByHeader,
        string varyByCustom, OutputCacheLocation location, string varyByParam) {
        InitOutputCache(duration, null, varyByHeader, varyByCustom, location, varyByParam);
    }

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    ///    Note: this methods needs to be virtual because the Mobile control team
    ///    overrides it (ASURT 66157)
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual void InitOutputCache(int duration, string varyByContentEncoding, string varyByHeader,
        string varyByCustom, OutputCacheLocation location, string varyByParam) {

        // DevDivBugs 18348: for a cross-page postback, use cache policy for
        // original page and ignore cache policy for this page.
        if (_isCrossPagePostBack) {
            return;
        }

        OutputCacheParameters cacheSettings = new OutputCacheParameters();

        cacheSettings.Duration = duration;
        cacheSettings.VaryByContentEncoding = varyByContentEncoding;
        cacheSettings.VaryByHeader = varyByHeader;
        cacheSettings.VaryByCustom = varyByCustom;
        cacheSettings.Location = location;
        cacheSettings.VaryByParam = varyByParam;

        InitOutputCache(cacheSettings);
    }


    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    ///    Note: this methods needs to be virtual because the Mobile control team
    ///    overrides it (ASURT 66157)
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected internal virtual void InitOutputCache(OutputCacheParameters cacheSettings)
    {
        // DevDivBugs 18348: for a cross-page postback, use cache policy for
        // original page and ignore cache policy for this page.
        if (_isCrossPagePostBack) {
            return;
        }
        OutputCacheSettingsSection outputCacheSettings;
        OutputCacheProfile profile = null;
        HttpCachePolicy     cache = Response.Cache;
        HttpCacheability    cacheability;
        OutputCacheLocation location = (OutputCacheLocation) (-1);
        int duration = 0;
        string varyByContentEncoding = null;
        string varyByHeader = null;
        string varyByCustom = null;
        string varyByParam = null;
        string sqlDependency = null;
        string varyByControl = null;
        bool noStore = false;
        RuntimeConfig config;

        config = RuntimeConfig.GetAppConfig();
        OutputCacheSection outputCacheConfig = config.OutputCache;

        // If output cache is not enabled, then don't do anything and return.
        if (! outputCacheConfig.EnableOutputCache)
        {
            return;
        }

        if (cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0)
        {
            outputCacheSettings = config.OutputCacheSettings;
            profile = (OutputCacheProfile) outputCacheSettings.OutputCacheProfiles[cacheSettings.CacheProfile];

            if (profile == null) {
                throw new HttpException(SR.GetString(SR.CacheProfile_Not_Found, cacheSettings.CacheProfile));
            }

            // If the profile disables it, then bail out
            if (!profile.Enabled) {
                return;
            }
        }

        // If a cache profile was set above, the settings below will override the set defaults from config

        // Pick up the settings from the configuration settings profile first
        if (profile != null) {
            duration = profile.Duration;
            varyByContentEncoding = profile.VaryByContentEncoding;
            varyByHeader = profile.VaryByHeader;
            varyByCustom = profile.VaryByCustom;
            varyByParam = profile.VaryByParam;
            sqlDependency = profile.SqlDependency;
            noStore = profile.NoStore;
            varyByControl = profile.VaryByControl;
            location = profile.Location;

            if (String.IsNullOrEmpty(varyByContentEncoding)) {
                varyByContentEncoding = null;
            }
            if (String.IsNullOrEmpty(varyByHeader)) {
                varyByHeader = null;
            }
            if (String.IsNullOrEmpty(varyByCustom)) {
                varyByCustom = null;
            }
            if (String.IsNullOrEmpty(varyByParam)) {
                varyByParam = null;
            }
            if (String.IsNullOrEmpty(varyByControl)) {
                varyByControl = null;
            }

            if (StringUtil.EqualsIgnoreCase(varyByParam, "none")) {
                varyByParam = null;
            }

            if (StringUtil.EqualsIgnoreCase(varyByControl, "none")) {
                varyByControl = null;
            }
        }

        // Start overriding options from the directive
        if (cacheSettings.IsParameterSet(OutputCacheParameter.Duration)) {
            duration = cacheSettings.Duration;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByContentEncoding)) {
            varyByContentEncoding = cacheSettings.VaryByContentEncoding;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByHeader)) {
            varyByHeader = cacheSettings.VaryByHeader;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByCustom)) {
            varyByCustom = cacheSettings.VaryByCustom;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl)) {
            varyByControl = cacheSettings.VaryByControl;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam)) {
            varyByParam = cacheSettings.VaryByParam;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.SqlDependency)) {
            sqlDependency = cacheSettings.SqlDependency;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.NoStore)) {
            noStore = cacheSettings.NoStore;
        }
        if (cacheSettings.IsParameterSet(OutputCacheParameter.Location)) {
            location = cacheSettings.Location;
        }

        // 

        // Make some checks here and see if a configuration exception needs to be thrown:

        // If location wasn't specified in the profile or in the directive, set a default one
        if (location == (OutputCacheLocation) (-1)) {
            location = OutputCacheLocation.Any;
        }

        // Skip all checks if Location is "None" or we are disabled
        if ((location != OutputCacheLocation.None) &&
            (profile == null || profile.Enabled)) {

            // Check and see if duration is specified in the profile or in the directives
            if ((profile == null || profile.Duration == -1) &&
                (cacheSettings.IsParameterSet(OutputCacheParameter.Duration) == false)) {
                throw new HttpException(SR.GetString(SR.Missing_output_cache_attr, "duration"));
            }

            // Check and see if varyByParam is specified in the profile or in the directives
            if ((profile == null || ((profile.VaryByParam == null) && (profile.VaryByControl == null))) &&
                (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam) == false &&
                cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl) == false)) {
                throw new HttpException(SR.GetString(SR.Missing_output_cache_attr, "varyByParam"));
            }
        }

        // Set the cache policy based upon these settings

        if (noStore) {
            Response.Cache.SetNoStore();
        }

        switch (location) {
            case OutputCacheLocation.Any:
                cacheability = HttpCacheability.Public;
                break;

            case OutputCacheLocation.Server:
                cacheability = HttpCacheability.ServerAndNoCache;
                break;

            case OutputCacheLocation.ServerAndClient:
                cacheability = HttpCacheability.ServerAndPrivate;
                break;

            case OutputCacheLocation.Client:
                cacheability = HttpCacheability.Private;
                break;

            case OutputCacheLocation.Downstream:
                cacheability = HttpCacheability.Public;
                cache.SetNoServerCaching();
                break;

            case OutputCacheLocation.None:
                cacheability = HttpCacheability.NoCache;
                break;

            default:
                throw new ArgumentOutOfRangeException("cacheSettings", SR.GetString(SR.Invalid_cache_settings_location));
        }

        cache.SetCacheability(cacheability);

        if (location != OutputCacheLocation.None) {
            cache.SetExpires(Context.Timestamp.AddSeconds(duration));
            cache.SetMaxAge(new TimeSpan(0, 0, duration));
            cache.SetValidUntilExpires(true);
            cache.SetLastModified(Context.Timestamp);

            //
            // A client cache'd item won't be cached on
            // the server or a proxy, so it doesn't need
            // a Varies header.
            //
            if (location != OutputCacheLocation.Client) {
                if (varyByContentEncoding != null) {
                    string[] a = varyByContentEncoding.Split(s_varySeparator);
                    foreach (string s in a) {
                        cache.VaryByContentEncodings[s.Trim()] = true;
                    }
                }
                if (varyByHeader != null) {
                    string[] a = varyByHeader.Split(s_varySeparator);
                    foreach (string s in a) {
                        cache.VaryByHeaders[s.Trim()] = true;
                    }
                }
                if(PageAdapter != null) {
                    StringCollection adapterVaryByHeaders = PageAdapter.CacheVaryByHeaders;
                    if(adapterVaryByHeaders != null) {
                        foreach(string header in adapterVaryByHeaders) {
                            cache.VaryByHeaders[header] = true;
                        }
                    }
                }

                //
                // Only items cached on the server need VaryByCustom and
                // VaryByParam
                //
                if (location != OutputCacheLocation.Downstream) {
                    if (varyByCustom != null) {
                        cache.SetVaryByCustom(varyByCustom);
                    }

                    if (String.IsNullOrEmpty(varyByParam) &&
                        String.IsNullOrEmpty(varyByControl) &&
                        (PageAdapter == null || PageAdapter.CacheVaryByParams == null)) {
                        cache.VaryByParams.IgnoreParams = true;
                    }
                    else {
                        if (!String.IsNullOrEmpty(varyByParam)) {
                            string[] a = varyByParam.Split(s_varySeparator);
                            foreach (string s in a) {
                                cache.VaryByParams[s.Trim()] = true;
                            }
                        }
                        if (!String.IsNullOrEmpty(varyByControl)) {
                            string[] a = varyByControl.Split(s_varySeparator);
                            foreach (string s in a) {
                                cache.VaryByParams[s.Trim()] = true;
                            }
                        }
                        if(PageAdapter != null) {
                            IList adapterVaryByParams = PageAdapter.CacheVaryByParams;
                            if(adapterVaryByParams != null) {
                                foreach(string p in adapterVaryByParams) {
                                    cache.VaryByParams[p] = true;
                                }
                            }
                        }
                    }

#if !FEATURE_PAL // FEATURE_PAL does not fully SQL dependencies
                    if (!String.IsNullOrEmpty(sqlDependency)) {
                        Response.AddCacheDependency(SqlCacheDependency.CreateOutputCacheDependency(sqlDependency));
                    }
#endif // !FEATURE_PAL
                }
            }
        }
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Obsolete("The recommended alternative is HttpResponse.AddFileDependencies. http://go.microsoft.com/fwlink/?linkid=14202")]
    protected ArrayList FileDependencies {
        set { Response.AddFileDependencies(value); }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected object GetWrappedFileDependencies(string[] virtualFileDependencies) {
        Debug.Assert(virtualFileDependencies != null);
        return virtualFileDependencies;
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected internal void AddWrappedFileDependencies(object virtualFileDependencies) {
        Response.AddVirtualPathDependencies((string[])virtualFileDependencies);
    }

    internal const bool BufferDefault = true;

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public bool Buffer {
        set { Response.BufferOutput = value; }
        get { return Response.BufferOutput; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public string ContentType {
        set { Response.ContentType = value; }
        get { return Response.ContentType; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public int CodePage {
        set { Response.ContentEncoding = Encoding.GetEncoding(value); }
        get { return Response.ContentEncoding.CodePage; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public string ResponseEncoding {
        set { Response.ContentEncoding = Encoding.GetEncoding(value); }
        get { return Response.ContentEncoding.EncodingName; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public string Culture {
        set {
            CultureInfo newCulture = null;

            if(StringUtil.EqualsIgnoreCase(value, HttpApplication.AutoCulture)) {
                CultureInfo browserCulture = CultureFromUserLanguages(true);
                if(browserCulture != null) {
                    newCulture = browserCulture;
                }
            }
            else if(StringUtil.StringStartsWithIgnoreCase(value, HttpApplication.AutoCulture)) {
                CultureInfo browserCulture = CultureFromUserLanguages(true);
                if(browserCulture != null) {
                    newCulture = browserCulture;
                }
                else {
                    try {
                        newCulture = HttpServerUtility.CreateReadOnlyCultureInfo(value.Substring(5));
                    }
                    catch {}
                }
            }
            else {
                newCulture = HttpServerUtility.CreateReadOnlyCultureInfo(value);
            }

            if (newCulture != null) {
                Thread.CurrentThread.CurrentCulture = newCulture;
                _dynamicCulture = newCulture;
            }
        }
        get { return Thread.CurrentThread.CurrentCulture.DisplayName; }
    }

    internal CultureInfo DynamicCulture {
        get { return _dynamicCulture; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public int LCID {
        set {
            CultureInfo newCulture = HttpServerUtility.CreateReadOnlyCultureInfo(value);
            Thread.CurrentThread.CurrentCulture = newCulture;
            _dynamicCulture = newCulture;
        }

        get { return Thread.CurrentThread.CurrentCulture.LCID; }
    }

    private CultureInfo CultureFromUserLanguages(bool specific) {
        if(_context != null &&
                        _context.Request != null &&
                        _context.Request.UserLanguages != null) {
            try {
                return CultureUtil.CreateReadOnlyCulture(_context.Request.UserLanguages, specific);
            }
            catch {
            }
        }
        return null;
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public string UICulture {
        set {
            CultureInfo newUICulture = null;

            if(StringUtil.EqualsIgnoreCase(value, HttpApplication.AutoCulture)) {
                CultureInfo browserCulture = CultureFromUserLanguages(false);
                if(browserCulture != null) {
                    newUICulture = browserCulture;
                }
            }
            else if(StringUtil.StringStartsWithIgnoreCase(value, HttpApplication.AutoCulture)) {
                CultureInfo browserCulture = CultureFromUserLanguages(false);
                if(browserCulture != null) {
                    newUICulture = browserCulture;
                }
                else {
                    try {
                        newUICulture = HttpServerUtility.CreateReadOnlyCultureInfo(value.Substring(5));
                    }
                    catch {}
                }
            }
            else {
                newUICulture = HttpServerUtility.CreateReadOnlyCultureInfo(value);
            }

            if (newUICulture != null) {
                Thread.CurrentThread.CurrentUICulture = newUICulture;
                _dynamicUICulture = newUICulture;
            }
        }
        get { return Thread.CurrentThread.CurrentUICulture.DisplayName; }
    }

    internal CultureInfo DynamicUICulture {
        get { return _dynamicUICulture; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public TimeSpan AsyncTimeout {
        set {
            if (value < TimeSpan.Zero) {
                throw new ArgumentException(SR.GetString(SR.Page_Illegal_AsyncTimeout), "AsyncTimeout");
            }

            _asyncTimeout = value;
            _asyncTimeoutSet = true;
        }
        get {
            if (!_asyncTimeoutSet) {
                if (Context != null) {
                    PagesSection pagesSection = RuntimeConfig.GetConfig(Context).Pages;

                    if (pagesSection != null) {
                        AsyncTimeout = pagesSection.AsyncTimeout;
                    }
                }

                if (!_asyncTimeoutSet) {
                    AsyncTimeout = TimeSpan.FromSeconds((double)Page.DefaultAsyncTimeoutSeconds);
                }
            }

            return _asyncTimeout;
        }
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected int TransactionMode {
        set { _transactionMode = value; }
        get { return _transactionMode; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected bool AspCompatMode {
        set { _aspCompatMode = value; }
        get { return _aspCompatMode; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected bool AsyncMode {
        set { _asyncMode = value; }
        get { return _asyncMode; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public bool TraceEnabled {
        set { Trace.IsEnabled = value; }
        get { return Trace.IsEnabled; }
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public System.Web.TraceMode TraceModeValue {
        set { Trace.TraceMode = value; }
        get { return Trace.TraceMode; }
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Browsable(false)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public bool EnableViewStateMac {
        get { return _enableViewStateMac; }
        set {
            // DevDiv #461378: EnableViewStateMac=false can lead to remote code execution, so we
            // have an mechanism that forces this to keep its default value of 'true'. We only
            // allow actually setting the value if this enforcement mechanism is inactive.
            if (!EnableViewStateMacRegistryHelper.EnforceViewStateMac) {
                _enableViewStateMac = value;
            }
        }
    }

    internal const bool SmartNavigationDefault = false;

    /// <devdoc>
    ///    <para>Is the SmartNavigation feature in use</para>
    /// </devdoc>
    [
    Browsable(false),
    Filterable(false)
    ]
    [Obsolete("The recommended alternative is Page.SetFocus and Page.MaintainScrollPositionOnPostBack. http://go.microsoft.com/fwlink/?linkid=14202")]
    public bool SmartNavigation {
        get {
            // If it's not supported or asked for, return false
            if (_smartNavSupport == SmartNavigationSupport.NotDesiredOrSupported)
                return false;

            // Otherwise, determine what the browser supports
            if (_smartNavSupport == SmartNavigationSupport.Desired) {
                // *** We need to check the current context here since
                //     we check SmartNavigation when the context == null.
                HttpContext currentContext = HttpContext.Current;

                // Make sure that there is a current context
                if (currentContext == null) {
                    // If there isn't one, assume SmartNavigation is off
                    return false;
                }

                // *** We CANNOT just check Request.Browser since Request will be null and throw an exception
                HttpBrowserCapabilities browser = currentContext.Request.Browser;

                // If it's not IE6+ on Windows, we don't support Smart Navigation
                if (!String.Equals(browser.Browser, "ie", StringComparison.OrdinalIgnoreCase) || browser.MajorVersion < 6 ||
                    !browser.Win32) {
                    _smartNavSupport = SmartNavigationSupport.NotDesiredOrSupported;
                }
                else
                    _smartNavSupport = SmartNavigationSupport.IE6OrNewer;
            }

            return (_smartNavSupport != SmartNavigationSupport.NotDesiredOrSupported);
        }
        set {
            if (value)
                _smartNavSupport = SmartNavigationSupport.Desired;
            else
                _smartNavSupport = SmartNavigationSupport.NotDesiredOrSupported;
        }
    }
    internal bool IsTransacted { get { return (_transactionMode != 0 /*TransactionOption.Disabled*/); } }
    internal bool IsInAspCompatMode { get { return _aspCompatMode; } }


    public bool IsAsync {
        get { return _asyncMode; }
    }


    /// <devdoc>
    /// Occurs when the control is done handling postback data, and before PreRender.
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public event EventHandler LoadComplete {
        add {
            Events.AddHandler(EventLoadComplete, value);
        }
        remove {
            Events.RemoveHandler(EventLoadComplete, value);
        }
    }


    /// <devdoc>
    /// Raised after postback data is handled, and before PreRender.
    /// </devdoc>
    protected virtual void OnLoadComplete(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventLoadComplete];
        if (handler != null) {
            handler(this, e);
        }
    }


    /// <devdoc>
    /// Raised after PreRender is complete
    /// </devdoc>
    protected virtual void OnPreRenderComplete(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventPreRenderComplete];
        if (handler != null) {
            handler(this, e);
        }
    }

    /// <devdoc>
    /// Heres where all the 'final' page-level framework stuff happens.
    /// Raise the PreRenderComplete event giving the user the first (and last)
    /// chance to do certain things that affect page behavior, and
    /// then perform the processing steps.
    /// </devdoc>
    private void PerformPreRenderComplete() {
        OnPreRenderComplete(EventArgs.Empty);
    }


    /// <devdoc>
    /// Occurs before controls' OnInit
    /// </devdoc>
    public event EventHandler PreInit {
        add {
            Events.AddHandler(EventPreInit, value);
        }
        remove {
            Events.RemoveHandler(EventPreInit, value);
        }
    }


    /// <devdoc>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public event EventHandler PreLoad {
        add {
            Events.AddHandler(EventPreLoad, value);
        }
        remove {
            Events.RemoveHandler(EventPreLoad, value);
        }
    }


    /// <devdoc>
    /// Occurs after all controls have completed PreRender
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public event EventHandler PreRenderComplete {
        add {
            Events.AddHandler(EventPreRenderComplete, value);
        }
        remove {
            Events.RemoveHandler(EventPreRenderComplete, value);
        }
    }

    /// <devdoc>
    /// Override this method to apply stylesheet before building controls
    /// </devdoc>
    protected override void FrameworkInitialize() {
        base.FrameworkInitialize();

        InitializeStyleSheet();
    }

    /// <devdoc>
    /// Override this method to initialize culture properties.
    /// </devdoc>
    protected virtual void InitializeCulture() {
    }


    /// <devdoc>
    /// </devdoc>
    protected internal override void OnInit(EventArgs e) {
        base.OnInit(e);

        if (_theme != null) {
            _theme.SetStyleSheet();
        }

        if (_styleSheet != null) {
            _styleSheet.SetStyleSheet();
        }
    }


    /// <devdoc>
    /// Raised before OnInit.
    /// </devdoc>
    protected virtual void OnPreInit(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventPreInit];
        if (handler != null) {
            handler(this, e);
        }
    }

    /// <devdoc>
    /// Heres where all the 'early' page initialization happens.
    /// Raise the PreInit event giving the user the first (and last)
    /// chance to do certain things that affect page behavior, and
    /// then perform the initialization steps.
    ///
    /// For now this early initialization includes
    /// theme loading.
    /// 



    private void PerformPreInit() {
        OnPreInit(EventArgs.Empty);

        InitializeThemes();

        ApplyMasterPage();

        _preInitWorkComplete = true;
    }

    // TAP version of the PerformPreInit routine.
    // !! IMPORTANT !!
    // If you change this method, also change PerformPreInit.
    private async Task PerformPreInitAsync() {
        using (Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
            OnPreInit(EventArgs.Empty);
            await GetWaitForPreviousStepCompletionAwaitable();
        }

        InitializeThemes();

        ApplyMasterPage();

        _preInitWorkComplete = true;
    }


    /// <devdoc>
    /// Occurs when the page is done initializing, and before loading viewstate data.
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public event EventHandler InitComplete {
        add {
            Events.AddHandler(EventInitComplete, value);
        }
        remove {
            Events.RemoveHandler(EventInitComplete, value);
        }
    }


    /// <devdoc>
    /// Raised after page is initialized, and before loading viewstate.
    /// </devdoc>
    protected virtual void OnInitComplete(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventInitComplete];
        if (handler != null) {
            handler(this, e);
        }
    }


    /// <devdoc>
    /// Raises the PreLoad event
    /// </devdoc>
    protected virtual void OnPreLoad(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventPreLoad];
        if (handler != null) {
            handler(this, e);
        }
    }

    public void RegisterRequiresViewStateEncryption() {
        if (ControlState >= ControlState.PreRendered) {
            throw new InvalidOperationException(SR.GetString(SR.Too_late_for_RegisterRequiresViewStateEncryption));
        }

        _viewStateEncryptionRequested = true;
    }

    internal bool RequiresViewStateEncryptionInternal {
        get {
            return ViewStateEncryptionMode == ViewStateEncryptionMode.Always ||
                   _viewStateEncryptionRequested && ViewStateEncryptionMode == ViewStateEncryptionMode.Auto;
        }
    }


    /// <devdoc>
    /// Occurs when the page has completed saving view state and control state.
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public event EventHandler SaveStateComplete {
        add {
            Events.AddHandler(EventSaveStateComplete, value);
        }
        remove {
            Events.RemoveHandler(EventSaveStateComplete, value);
        }
    }


    /// <devdoc>
    /// Raises the SaveStateComplete event
    /// </devdoc>
    protected virtual void OnSaveStateComplete(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventSaveStateComplete];
        if (handler != null) {
            handler(this, e);
        }
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public virtual void ProcessRequest(HttpContext context) {
        // If running in non-full trust, call PermitOnly to cause the following code
        // to run as if there were user code on the stack.

        // Check if we're running in non-full trust
        if (HttpRuntime.NamedPermissionSet != null && !HttpRuntime.DisableProcessRequestInApplicationTrust) {

            // Are we supposed to execute process request without full trust?
            if (HttpRuntime.ProcessRequestInApplicationTrust) {

                // If so, we don't normally need to do anything, because this ProcessRequest method
                // is being called from an override in the generated code (so there is user code
                // on the stack).

                // However, if the page is no-compile, there won't be any user code on the stack,
                // so we need to explicitely call PermitOnly to make it happen
                if (NoCompile) {
                    HttpRuntime.NamedPermissionSet.PermitOnly();
                }
            }
            else {
                // Here, we want to run the request in full trust, so the situation is reversed.
                // i.e. in the no-compile case, there is no user code on the stack, so we don't need to
                // do anything.  But in the compiled case, the ProcessRequest override is on the stack,
                // so we need to nullify it using an Assert.
                ProcessRequestWithAssert(context);
                return;
            }
        }

        ProcessRequestWithNoAssert(context);
    }

    [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
    private void ProcessRequestWithAssert(HttpContext context) {
        ProcessRequestWithNoAssert(context);
    }

    private void ProcessRequestWithNoAssert(HttpContext context) {
        SetIntrinsics(context);
        ProcessRequest();
    }

    // assert SecurityPermission, for ASURT #112116
    [SecurityPermission(SecurityAction.Assert, ControlThread=true)]
    void SetCultureWithAssert(Thread currentThread, CultureInfo currentCulture, CultureInfo currentUICulture) {
        SetCulture(currentThread, currentCulture, currentUICulture);
    }

    void SetCulture(Thread currentThread, CultureInfo currentCulture, CultureInfo currentUICulture) {
        currentThread.CurrentCulture = currentCulture;
        currentThread.CurrentUICulture = currentUICulture;
    }

    //
    // ProcessRequestXXX methods are there because
    // transacted pages require some code (ProcessRequestMain)
    // to run inside the transaction and some outside
    //
    // Another reason - support for async pages
    //

    private void ProcessRequest() {
        // culture needs to be saved/restored only on synchronous pages (if at all)
        // save culture
        Thread currentThread = Thread.CurrentThread;
        CultureInfo prevCulture = currentThread.CurrentCulture;
        CultureInfo prevUICulture = currentThread.CurrentUICulture;

        try {
            ProcessRequest(true /*includeStagesBeforeAsyncPoint*/, true /*includeStagesAfterAsyncPoint*/);
        }
        finally {
            // restore culture
            RestoreCultures(currentThread, prevCulture, prevUICulture);
        }
    }

    // !! IMPORTANT !!
    // If you change this method, also change ProcessRequestAsync(bool, bool).
    private void ProcessRequest(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint) {
        // Initialize the object and build the tree of controls.
        // This must happen *after* the intrinsics have been set.
        // On async pages only call Initialize once (ProcessRequest is called twice)
        if (includeStagesBeforeAsyncPoint) {
            FrameworkInitialize();

            this.ControlState = ControlState.FrameworkInitialized;
        }

        bool needToCallEndTrace = Context.WorkerRequest is IIS7WorkerRequest;
        try {
            try {
                if (IsTransacted) {
                    ProcessRequestTransacted();
                }
                else {
                    // No transactions
                    ProcessRequestMain(includeStagesBeforeAsyncPoint, includeStagesAfterAsyncPoint);
                }

                if (includeStagesAfterAsyncPoint) {
                    needToCallEndTrace = false;
                    ProcessRequestEndTrace();
                }
            }
            catch (ThreadAbortException) {
                try {
                    if (needToCallEndTrace)
                        ProcessRequestEndTrace();
                } catch {}
            }
            finally {
                if (includeStagesAfterAsyncPoint) {
                    ProcessRequestCleanup();
                }
            }
        }
        catch { throw; }    // Prevent Exception Filter Security Issue (ASURT 122835)
    }

    // TAP version of ProcessRequest(bool, bool)
    // !! IMPORTANT !!
    // If you change this method, also change ProcessRequest(bool, bool).
    private async Task ProcessRequestAsync(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint) {
        // Initialize the object and build the tree of controls.
        // This must happen *after* the intrinsics have been set.
        // On async pages only call Initialize once (ProcessRequest is called twice)
        if (includeStagesBeforeAsyncPoint) {
            FrameworkInitialize();

            this.ControlState = ControlState.FrameworkInitialized;
        }

        bool needToCallEndTrace = Context.WorkerRequest is IIS7WorkerRequest;
        try {
            try {
                if (IsTransacted) {
                    ProcessRequestTransacted();
                }
                else {
                    // No transactions
                    await ProcessRequestMainAsync(includeStagesBeforeAsyncPoint, includeStagesAfterAsyncPoint).WithinCancellableCallback(Context);
                }

                if (includeStagesAfterAsyncPoint) {
                    needToCallEndTrace = false;
                    ProcessRequestEndTrace();
                }
            }
            catch (ThreadAbortException) {
                try {
                    if (needToCallEndTrace)
                        ProcessRequestEndTrace();
                } catch {}
            }
            finally {
                if (includeStagesAfterAsyncPoint) {
                    ProcessRequestCleanup();
                }
            }
        }
        catch { throw; }    // Prevent Exception Filter Security Issue (ASURT 122835)
    }

    private void RestoreCultures(Thread currentThread, CultureInfo prevCulture, CultureInfo prevUICulture) {
        if (prevCulture != currentThread.CurrentCulture || prevUICulture != currentThread.CurrentUICulture) {
            if (HttpRuntime.IsFullTrust) {
                SetCulture(currentThread, prevCulture, prevUICulture);
            }
            else {
                SetCultureWithAssert(currentThread, prevCulture, prevUICulture);
            }
        }
    }

    // This must be in its own method to avoid jitting System.EnterpriseServices.dll
    // when it is not needed (ASURT 71868)
    private void ProcessRequestTransacted() {

        bool transactionAborted = false;
        TransactedCallback processRequestCallback = new TransactedCallback(ProcessRequestMain);

        // Part of the request needs to be done under transacted context
        Transactions.InvokeTransacted(processRequestCallback,
            (TransactionOption) _transactionMode, ref transactionAborted);

        // The remainder has to be done outside
        try {
            if (transactionAborted) {
                OnAbortTransaction(EventArgs.Empty);
                WebBaseEvent.RaiseSystemEvent(this, WebEventCodes.RequestTransactionAbort);
            }
            else {
                OnCommitTransaction(EventArgs.Empty);
                WebBaseEvent.RaiseSystemEvent(this, WebEventCodes.RequestTransactionComplete);
            }

            // Make sure Request.RawUrl gets validated.
            ValidateRawUrlIfRequired();
        }
        catch (ThreadAbortException) {
            // Don't go into HandleError logic for ThreadAbortException's, since they
            // are expected (e.g. when Response.Redirect() is called).
            throw;
        }
        catch (Exception e) {
            // Increment all of the appropriate error counters
            PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
            PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);

            // If it hasn't been handled, rethrow it
            if (!HandleError(e))
                throw;
        }
    }

    private void ProcessRequestCleanup() {
        if (_request == null) {
            // ProcessRequestCleanup() has already been called
            return;
        }

#if DISPLAYRAREFIELDSTATISTICS
        // Display rare field statistics at the end of the page (for debugging purpose)
        DisplayRareFieldStatistics();
#endif

        _request = null;
        _response = null;

        if (!IsCrossPagePostBack) {
            UnloadRecursive(true);
        }

        if (Context.TraceIsEnabled) {
            Trace.StopTracing();
        }
    }

    private void ProcessRequestEndTrace() {

        if (Context.TraceIsEnabled) {
            Trace.EndRequest();

            // DevDiv Bugs 154103: Do not write trace output while in an async postback
            if (Trace.PageOutput && !IsCallback &&
                 (ScriptManager == null || !ScriptManager.IsInAsyncPostBack)) {
                Trace.Render(CreateHtmlTextWriter(Response.Output));

                // responses with trace should not be cached
                Response.Cache.SetCacheability(HttpCacheability.NoCache);
            }
        }
    }

#if DEBUG
    private void DisplayRareFieldStatistics() {
        int totalControls = 0;
        int withOccasionalFields = 0;
        int withRareFields = 0;
        GetRareFieldStatistics(ref totalControls, ref withOccasionalFields, ref withRareFields);
        _response.Write("<hr><b><p>Total controls: " + totalControls + "<br>");
        _response.Write("With Occasional Fields: " + withOccasionalFields + "<br>");
        _response.Write("With Rare Fields: " + withRareFields + "</p></b>");
    }
#endif

    internal void SetPreviousPage(Page previousPage) {
        _previousPage = previousPage;
    }


    private void ProcessRequestMain() {
        ProcessRequestMain(true /*includeStagesBeforeAsyncPoint*/, true /*includeStagesAfterAsyncPoint*/);
    }

    // !! IMPORTANT !!
    // If you make changes to this method, also make changes to ProcessRequestMainAsync.
    private void ProcessRequestMain(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint) {
        try {
            HttpContext con = Context;

            string exportedWebPartID = null;
            if (includeStagesBeforeAsyncPoint) {
                // For ASPCOMPAT need to call OnPageStart for each Session object

#if !FEATURE_PAL // FEATURE_PAL does not enable COM
                if (IsInAspCompatMode)
                    AspCompatApplicationStep.OnPageStartSessionObjects();
#else // !FEATURE_PAL
				throw new NotImplementedException ("ROTORTODO");
#endif // !FEATURE_PAL

                // Is it a GET, POST or initial request?
                if(PageAdapter != null) {
                    _requestValueCollection = PageAdapter.DeterminePostBackMode();
                    if (_requestValueCollection != null) {
                        _unvalidatedRequestValueCollection = PageAdapter.DeterminePostBackModeUnvalidated();
                    }
                }
                else {
                    _requestValueCollection = DeterminePostBackMode();
                    // The contract for DeterminePostBackModeUnvalidated() is that it will only be called when
                    // DeterminePostBackMode() returns a non-null result. This was done so that the implementation
                    // of DeterminePostBackModeUnvalidated() can be kep simple, without having to duplicate the
                    // same logic as DeterminePostBackMode().
                    if (_requestValueCollection != null) {
                        _unvalidatedRequestValueCollection = DeterminePostBackModeUnvalidated();
                    }
                }
                // It's possible that someone incorrectly implements DeterminePostBackModeUnvalidated() such that it
                // returns null when DeterminePostBackMode() a non-null value. This could cause NullRefExceptions later on.
                // However since few customers would override these methods we assume that this won't happen very often.
                // A customer overriding DeterminePostBackModeUnvalidated() should understand what they are doing.

                string callbackControlId = String.Empty;

                // Special-case Web Part Export so it executes in the same security context as the page itself (VSWhidbey 426574)
                if (DetermineIsExportingWebPart()) {
                    if (!RuntimeConfig.GetAppConfig().WebParts.EnableExport) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartExportHandler_DisabledExportHandler));
                    }

                    exportedWebPartID = Request.QueryString["webPart"];
                    if (String.IsNullOrEmpty(exportedWebPartID)) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartExportHandler_InvalidArgument));
                    }

                    if (String.Equals(Request.QueryString["scope"], "shared", StringComparison.OrdinalIgnoreCase)) {
                        _pageFlags.Set(isExportingWebPartShared);
                    }

                    string queryString = Request.QueryString["query"];
                    if (queryString == null) {
                        queryString = String.Empty;
                    }
                    Request.QueryStringText = queryString;
                    con.Trace.IsEnabled = false;
                }

                if (_requestValueCollection != null) {

                    // Determine if viewstate was encrypted.
                    if (_requestValueCollection[ViewStateEncryptionID] != null) {
                        ContainsEncryptedViewState = true;
                    }

                    // Determine if this is a callback.
                    callbackControlId = _requestValueCollection[callbackID];
                    // Only accepting POST callbacks to reduce mail attack possibilities (VSWhidbey 417355)
                    if ((callbackControlId != null) && (_request.HttpVerb == HttpVerb.POST)) {
                        _isCallback = true;
                    }
                    else { // Otherwise, determine if this is cross-page posting(callsbacks can never be cross page posts)
                        if (!IsCrossPagePostBack) {
                            VirtualPath previousPagePath = null;

                            if (_requestValueCollection[previousPageID] != null) {
                                try {
                                    previousPagePath = VirtualPath.CreateNonRelativeAllowNull(
                                        DecryptString(_requestValueCollection[previousPageID], Purpose.WebForms_Page_PreviousPageID));
                                }
                                catch {
                                    // VSWhidbey 493209 If we fails to decrypt the previouspageid, still
                                    // treat this as a cross page post, not a regular postback. Otherwise
                                    // the viewstate cannot be decrypted properly. This will happen during
                                    // cross page post between different applications.
                                    _pageFlags[isCrossPagePostRequest] = true;

                                    // do nothing, ignore CryptographicException.
                                }

                                // Process if the page is posted from cross-page that still exists and the target page is not same as source page.
                                if (previousPagePath != null &&
                                    previousPagePath != Request.CurrentExecutionFilePathObject) {
                                    _pageFlags[isCrossPagePostRequest] = true;
                                    _previousPagePath = previousPagePath;
                                    Debug.Assert(_previousPagePath != null);
                                }
                            }
                        }
                    }
                }

                // Load the scroll position data now that we have the request value collection
                if (MaintainScrollPositionOnPostBack) {
                    LoadScrollPosition();
                }

                // we can't cache the value of IsEnabled because it could change during any phase.
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreInit");
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_ENTER, _context.WorkerRequest);
                PerformPreInit();
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreInit");

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin Init");
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_ENTER, _context.WorkerRequest);
                InitRecursive(null);
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Init");

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin InitComplete");
                OnInitComplete(EventArgs.Empty);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End InitComplete");

                if (IsPostBack) {
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin LoadState");
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_ENTER, _context.WorkerRequest);
                    LoadAllState();
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) {
                        Trace.Write("aspx.page", "End LoadState");
                        Trace.Write("aspx.page", "Begin ProcessPostData");
                    }

                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_ENTER, _context.WorkerRequest);
                    ProcessPostData(_requestValueCollection, true /* fBeforeLoad */);
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "End ProcessPostData");
                }

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreLoad");
                OnPreLoad(EventArgs.Empty);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreLoad");

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin Load");
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_ENTER, _context.WorkerRequest);
                LoadRecursive();
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Load");

                if (IsPostBack) {
                    // Try process the post data again (ASURT 29045)
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin ProcessPostData Second Try");
                    ProcessPostData(_leftoverPostData, false /* !fBeforeLoad */);
                    if (con.TraceIsEnabled) {
                        Trace.Write("aspx.page", "End ProcessPostData Second Try");
                        Trace.Write("aspx.page", "Begin Raise ChangedEvents");
                    }

                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_ENTER, _context.WorkerRequest);
                    RaiseChangedEvents();
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) {
                        Trace.Write("aspx.page", "End Raise ChangedEvents");
                        Trace.Write("aspx.page", "Begin Raise PostBackEvent");
                    }
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_ENTER, _context.WorkerRequest);
                    RaisePostBackEvent(_requestValueCollection);
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Raise PostBackEvent");
                }

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin LoadComplete");
                OnLoadComplete(EventArgs.Empty);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End LoadComplete");

                if (IsPostBack && IsCallback) {
                    PrepareCallback(callbackControlId);
                }
                else if (!IsCrossPagePostBack) {
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreRender");
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_ENTER, _context.WorkerRequest);
                    PreRenderRecursiveInternal();
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreRender");
                }
            }

            /// Async Point here

            if (_legacyAsyncInfo == null || _legacyAsyncInfo.CallerIsBlocking) {
                // for non-async pages with registered async tasks - run the tasks here
                // also when running async page via server.execute - run the tasks here
                ExecuteRegisteredAsyncTasks();
            }

            // Make sure RawUrl gets validated.
            ValidateRawUrlIfRequired();

            if (includeStagesAfterAsyncPoint) {
                if (IsCallback) {
                    RenderCallback();
                    return;
                }

                if (IsCrossPagePostBack) {
                    return;
                }

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreRenderComplete");
                PerformPreRenderComplete();
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreRenderComplete");

                if (con.TraceIsEnabled) {
                    BuildPageProfileTree(EnableViewState);
                    Trace.Write("aspx.page", "Begin SaveState");
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_ENTER, _context.WorkerRequest);

                SaveAllState();

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) {
                    Trace.Write("aspx.page", "End SaveState");
                    Trace.Write("aspx.page", "Begin SaveStateComplete");
                }
                OnSaveStateComplete(EventArgs.Empty);
                if (con.TraceIsEnabled) {
                    Trace.Write("aspx.page", "End SaveStateComplete");
                    Trace.Write("aspx.page", "Begin Render");
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_ENTER, _context.WorkerRequest);
                // Special-case Web Part Export so it executes in the same security context as the page itself (VSWhidbey 426574)
                if (exportedWebPartID != null) {
                    ExportWebPart(exportedWebPartID);
                }
                else {
                    RenderControl(CreateHtmlTextWriter(Response.Output));
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_LEAVE, _context.WorkerRequest);

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Render");

                CheckRemainingAsyncTasks(false);
            }
        }
        catch (ThreadAbortException e) {
            // Don't go into HandleError logic for ThreadAbortExceptions, since they
            // are expected (e.g. when Response.Redirect() is called).

            // VSWhidbey 500309: perf improvement. We can safely cancel the thread abort here
            // to avoid re-throwing the exception if this is a redirect and we're not being executed
            // under the context of a Server.Execute call (i.e. _context.Handler == this).  Otherwise,
            // re-throw so this can be handled lower in the stack (see HttpApplication.ExecuteStep).

            // This perf optimization can only be applied if we are executing the entire page
            // lifecycle within this method call (otherwise, in async pages) calling ResetAbort
            // would only skip part of the lifecycle, not the entire page (as Response.End is supposed to)

            HttpApplication.CancelModuleException cancelException = e.ExceptionState as HttpApplication.CancelModuleException;
            if (includeStagesBeforeAsyncPoint && includeStagesAfterAsyncPoint &&    // executing entire page
                _context.Handler == this &&                                         // not in server execute
                _context.ApplicationInstance != null &&                             // application must be non-null so we can complete the request
                cancelException != null && !cancelException.Timeout) {              // this is Response.End
                _context.ApplicationInstance.CompleteRequest();
                ThreadResetAbortWithAssert();
            }
            else {
                CheckRemainingAsyncTasks(true);
                throw;
            }
        }
        catch (System.Configuration.ConfigurationException) {
            throw;
        }
        catch (Exception e) {
            // Increment all of the appropriate error counters
            PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
            PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);

            // If it hasn't been handled, rethrow it
            if (!HandleError(e))
                throw;
        }
    }

    // TAP version of ProcessRequestMain routine.
    // !! IMPORTANT !!
    // If you make changes to this method, also make changes to ProcessRequestMain.
    private async Task ProcessRequestMainAsync(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint) {
        try {
            HttpContext con = Context;

            string exportedWebPartID = null;
            if (includeStagesBeforeAsyncPoint) {
                // For ASPCOMPAT need to call OnPageStart for each Session object

#if !FEATURE_PAL // FEATURE_PAL does not enable COM
                if (IsInAspCompatMode)
                    AspCompatApplicationStep.OnPageStartSessionObjects();
#else // !FEATURE_PAL
				throw new NotImplementedException ("ROTORTODO");
#endif // !FEATURE_PAL

                // Is it a GET, POST or initial request?
                if(PageAdapter != null) {
                    _requestValueCollection = PageAdapter.DeterminePostBackMode();
                    if (_requestValueCollection != null) {
                        _unvalidatedRequestValueCollection = PageAdapter.DeterminePostBackModeUnvalidated();
                    }
                }
                else {
                    _requestValueCollection = DeterminePostBackMode();
                    // The contract for DeterminePostBackModeUnvalidated() is that it will only be called when
                    // DeterminePostBackMode() returns a non-null result. This was done so that the implementation
                    // of DeterminePostBackModeUnvalidated() can be kep simple, without having to duplicate the
                    // same logic as DeterminePostBackMode().
                    if (_requestValueCollection != null) {
                        _unvalidatedRequestValueCollection = DeterminePostBackModeUnvalidated();
                    }
                }
                // It's possible that someone incorrectly implements DeterminePostBackModeUnvalidated() such that it
                // returns null when DeterminePostBackMode() a non-null value. This could cause NullRefExceptions later on.
                // However since few customers would override these methods we assume that this won't happen very often.
                // A customer overriding DeterminePostBackModeUnvalidated() should understand what they are doing.

                string callbackControlId = String.Empty;

                // Special-case Web Part Export so it executes in the same security context as the page itself (VSWhidbey 426574)
                if (DetermineIsExportingWebPart()) {
                    if (!RuntimeConfig.GetAppConfig().WebParts.EnableExport) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartExportHandler_DisabledExportHandler));
                    }

                    exportedWebPartID = Request.QueryString["webPart"];
                    if (String.IsNullOrEmpty(exportedWebPartID)) {
                        throw new InvalidOperationException(SR.GetString(SR.WebPartExportHandler_InvalidArgument));
                    }

                    if (String.Equals(Request.QueryString["scope"], "shared", StringComparison.OrdinalIgnoreCase)) {
                        _pageFlags.Set(isExportingWebPartShared);
                    }

                    string queryString = Request.QueryString["query"];
                    if (queryString == null) {
                        queryString = String.Empty;
                    }
                    Request.QueryStringText = queryString;
                    con.Trace.IsEnabled = false;
                }

                if (_requestValueCollection != null) {

                    // Determine if viewstate was encrypted.
                    if (_requestValueCollection[ViewStateEncryptionID] != null) {
                        ContainsEncryptedViewState = true;
                    }

                    // Determine if this is a callback.
                    callbackControlId = _requestValueCollection[callbackID];
                    // Only accepting POST callbacks to reduce mail attack possibilities (VSWhidbey 417355)
                    if ((callbackControlId != null) && (_request.HttpVerb == HttpVerb.POST)) {
                        _isCallback = true;
                    }
                    else { // Otherwise, determine if this is cross-page posting(callsbacks can never be cross page posts)
                        if (!IsCrossPagePostBack) {
                            VirtualPath previousPagePath = null;

                            if (_requestValueCollection[previousPageID] != null) {
                                try {
                                    previousPagePath = VirtualPath.CreateNonRelativeAllowNull(
                                        DecryptString(_requestValueCollection[previousPageID], Purpose.WebForms_Page_PreviousPageID));
                                }
                                catch {
                                    // VSWhidbey 493209 If we fails to decrypt the previouspageid, still
                                    // treat this as a cross page post, not a regular postback. Otherwise
                                    // the viewstate cannot be decrypted properly. This will happen during
                                    // cross page post between different applications.
                                    _pageFlags[isCrossPagePostRequest] = true;

                                    // do nothing, ignore CryptographicException.
                                }

                                // Process if the page is posted from cross-page that still exists and the target page is not same as source page.
                                if (previousPagePath != null &&
                                    previousPagePath != Request.CurrentExecutionFilePathObject) {
                                    _pageFlags[isCrossPagePostRequest] = true;
                                    _previousPagePath = previousPagePath;
                                    Debug.Assert(_previousPagePath != null);
                                }
                            }
                        }
                    }
                }

                // Load the scroll position data now that we have the request value collection
                if (MaintainScrollPositionOnPostBack) {
                    LoadScrollPosition();
                }

                // we can't cache the value of IsEnabled because it could change during any phase.
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreInit");
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_ENTER, _context.WorkerRequest);
                await PerformPreInitAsync().WithinCancellableCallback(con);
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_INIT_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreInit");

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin Init");
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_ENTER, _context.WorkerRequest);
                Task initRecursiveTask = InitRecursiveAsync(null, this);
                await initRecursiveTask.WithinCancellableCallback(con);
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_INIT_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Init");

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin InitComplete");
                using (con.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    OnInitComplete(EventArgs.Empty);
                    await GetWaitForPreviousStepCompletionAwaitable();
                }
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End InitComplete");

                if (IsPostBack) {
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin LoadState");
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_ENTER, _context.WorkerRequest);
                    LoadAllState();
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) {
                        Trace.Write("aspx.page", "End LoadState");
                        Trace.Write("aspx.page", "Begin ProcessPostData");
                    }

                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_ENTER, _context.WorkerRequest);
                    if (AppSettings.EnableAsyncModelBinding) {
                        await ProcessPostDataAsync(_requestValueCollection, true /* fBeforeLoad */).WithinCancellableCallback(con);
                    }
                    else {
                        ProcessPostData(_requestValueCollection, true /* fBeforeLoad */);
                    }

                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_POSTDATA_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "End ProcessPostData");
                }

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreLoad");
                using (con.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    OnPreLoad(EventArgs.Empty);
                    await GetWaitForPreviousStepCompletionAwaitable();
                }
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreLoad");

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin Load");
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_ENTER, _context.WorkerRequest);
                await LoadRecursiveAsync(this).WithinCancellableCallback(con);
                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Load");

                if (IsPostBack) {
                    // Try process the post data again (ASURT 29045)
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin ProcessPostData Second Try");
                    if (AppSettings.EnableAsyncModelBinding) {
                        await ProcessPostDataAsync(_leftoverPostData, false /* !fBeforeLoad */).WithinCancellableCallback(con);
                    }
                    else {
                        ProcessPostData(_leftoverPostData, false /* !fBeforeLoad */);
                    }

                    if (con.TraceIsEnabled) {
                        Trace.Write("aspx.page", "End ProcessPostData Second Try");
                        Trace.Write("aspx.page", "Begin Raise ChangedEvents");
                    }

                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_ENTER, _context.WorkerRequest);
                    await RaiseChangedEventsAsync().WithinCancellableCallback(con);
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_POST_DATA_CHANGED_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) {
                        Trace.Write("aspx.page", "End Raise ChangedEvents");
                        Trace.Write("aspx.page", "Begin Raise PostBackEvent");
                    }
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_ENTER, _context.WorkerRequest);
                    using (con.SyncContext.AllowVoidAsyncOperationsBlock()) {
                        RaisePostBackEvent(_requestValueCollection);
                        await GetWaitForPreviousStepCompletionAwaitable();
                    }
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RAISE_POSTBACK_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Raise PostBackEvent");
                }

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin LoadComplete");
                using (con.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    OnLoadComplete(EventArgs.Empty);
                    await GetWaitForPreviousStepCompletionAwaitable();
                }
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End LoadComplete");

                if (IsPostBack && IsCallback) {
                    await PrepareCallbackAsync(callbackControlId).WithinCancellableCallback(con);
                }
                else if (!IsCrossPagePostBack) {
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreRender");
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_ENTER, _context.WorkerRequest);
                    await PreRenderRecursiveInternalAsync(this).WithinCancellableCallback(con);
                    if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_PRE_RENDER_LEAVE, _context.WorkerRequest);
                    if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreRender");
                }
            }

            /// Async Point here

            if (_legacyAsyncInfo == null || _legacyAsyncInfo.CallerIsBlocking) {
                // for non-async pages with registered async tasks - run the tasks here
                // also when running async page via server.execute - run the tasks here
                ExecuteRegisteredAsyncTasks();
            }

            // Make sure RawUrl gets validated.
            ValidateRawUrlIfRequired();

            if (includeStagesAfterAsyncPoint) {
                if (IsCallback) {
                    RenderCallback();
                    return;
                }

                if (IsCrossPagePostBack) {
                    return;
                }

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "Begin PreRenderComplete");
                PerformPreRenderComplete();
                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End PreRenderComplete");

                if (con.TraceIsEnabled) {
                    BuildPageProfileTree(EnableViewState);
                    Trace.Write("aspx.page", "Begin SaveState");
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_ENTER, _context.WorkerRequest);

                SaveAllState();

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_SAVE_VIEWSTATE_LEAVE, _context.WorkerRequest);
                if (con.TraceIsEnabled) {
                    Trace.Write("aspx.page", "End SaveState");
                    Trace.Write("aspx.page", "Begin SaveStateComplete");
                }
                OnSaveStateComplete(EventArgs.Empty);
                if (con.TraceIsEnabled) {
                    Trace.Write("aspx.page", "End SaveStateComplete");
                    Trace.Write("aspx.page", "Begin Render");
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_ENTER, _context.WorkerRequest);
                // Special-case Web Part Export so it executes in the same security context as the page itself (VSWhidbey 426574)
                if (exportedWebPartID != null) {
                    ExportWebPart(exportedWebPartID);
                }
                else {
                    RenderControl(CreateHtmlTextWriter(Response.Output));
                }

                if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Verbose, EtwTraceFlags.Page)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_RENDER_LEAVE, _context.WorkerRequest);

                if (con.TraceIsEnabled) Trace.Write("aspx.page", "End Render");

                CheckRemainingAsyncTasks(false);
            }
        }
        catch (ThreadAbortException e) {
            // Don't go into HandleError logic for ThreadAbortExceptions, since they
            // are expected (e.g. when Response.Redirect() is called).

            // VSWhidbey 500309: perf improvement. We can safely cancel the thread abort here
            // to avoid re-throwing the exception if this is a redirect and we're not being executed
            // under the context of a Server.Execute call (i.e. _context.Handler == this).  Otherwise,
            // re-throw so this can be handled lower in the stack (see HttpApplication.ExecuteStep).

            // This perf optimization can only be applied if we are executing the entire page
            // lifecycle within this method call (otherwise, in async pages) calling ResetAbort
            // would only skip part of the lifecycle, not the entire page (as Response.End is supposed to)

            HttpApplication.CancelModuleException cancelException = e.ExceptionState as HttpApplication.CancelModuleException;
            if (includeStagesBeforeAsyncPoint && includeStagesAfterAsyncPoint &&    // executing entire page
                _context.Handler == this &&                                         // not in server execute
                _context.ApplicationInstance != null &&                             // application must be non-null so we can complete the request
                cancelException != null && !cancelException.Timeout) {              // this is Response.End
                _context.ApplicationInstance.CompleteRequest();
                ThreadResetAbortWithAssert();
            }
            else {
                CheckRemainingAsyncTasks(true);
                throw;
            }
        }
        catch (System.Configuration.ConfigurationException) {
            throw;
        }
        catch (Exception e) {
            // Increment all of the appropriate error counters
            PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
            PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);

            // If it hasn't been handled, rethrow it
            if (!HandleError(e))
                throw;
        }
    }

    internal WithinCancellableCallbackTaskAwaitable GetWaitForPreviousStepCompletionAwaitable() {
        AspNetSynchronizationContext syncContext = SynchronizationContext.Current as AspNetSynchronizationContext;
        if (syncContext != null) {
            return syncContext.WaitForPendingOperationsAsync().WithinCancellableCallback(Context);
        }
        else {
            // If the SynchronizationContext has been replaced, we can't query for previous step completion, so just assume it completed.
            return WithinCancellableCallbackTaskAwaitable.Completed;
        }
    }

    private void BuildPageProfileTree(bool enableViewState) {
        if (!_profileTreeBuilt) {
            _profileTreeBuilt = true;
            BuildProfileTree("ROOT", enableViewState);
        }
    }

    private void ExportWebPart(string exportedWebPartID) {
        WebPart webPartToExport = null;

        WebPartManager webPartManager = WebPartManager.GetCurrentWebPartManager(this);
        if (webPartManager != null) {
            webPartToExport = webPartManager.WebParts[exportedWebPartID];
        }

        if (webPartToExport == null || webPartToExport.IsClosed || webPartToExport is ProxyWebPart) {
            // If there is no WebPartManager, or the web part is not on the page, or has been replaced
            // by a ProxyWebPart, we should perform a Response.Redirect() back to the page with the
            // Export query string removed. The Export query string has already been removed in
            // ProcessRequestMain().
            // (VSWhidbey 358464, 496050, 504819, 515472)
            Response.Redirect(Request.RawUrl, false);
        }
        else {
            // We'll be writing Xml to the response -> Prepare the response
            Response.Cache.SetCacheability(HttpCacheability.NoCache);
            Response.Expires = 0;
            Response.ContentType = "application/mswebpart";
            string title = webPartToExport.DisplayTitle;
            if (String.IsNullOrEmpty(title)) {
                title = SR.GetString(SR.Part_Untitled);
            }
            NonWordRegex nonWordRegex = new NonWordRegex();
            Response.AddHeader("content-disposition", "attachment; filename=" +
                                nonWordRegex.Replace(title, "") +
                                ".WebPart");
            using (XmlTextWriter writer = new XmlTextWriter(Response.Output)) {
                writer.Formatting = Formatting.Indented;
                writer.WriteStartDocument();
                // Export to the response stream
                webPartManager.ExportWebPart(webPartToExport, writer);
                writer.WriteEndDocument();
            }
        }
    }

    private void InitializeWriter(HtmlTextWriter writer) {
        Html32TextWriter h32tw = writer as Html32TextWriter;
        if (h32tw != null && Request.Browser != null) {
            h32tw.ShouldPerformDivTableSubstitution = Request.Browser.Tables;
        }
    }


    protected internal override void Render(HtmlTextWriter writer) {
        InitializeWriter(writer);

        base.Render(writer);
    }

    // !! IMPORTANT !!
    // If you change this method, also change PrepareCallbackAsync.
    private void PrepareCallback(string callbackControlID) {
        Response.Cache.SetNoStore();
        try {
            string param = _requestValueCollection[callbackParameterID];
            _callbackControl = FindControl(callbackControlID) as ICallbackEventHandler;

            if (_callbackControl != null) {
                _callbackControl.RaiseCallbackEvent(param);
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.Page_CallBackTargetInvalid, callbackControlID));
            }
        }
        catch (Exception e) {
            Response.Clear();
            Response.Write('e');
            if (Context.IsCustomErrorEnabled) {
                Response.Write(SR.GetString(SR.Page_CallBackError));
            }
            else {
                bool needsCallbackLoadScript = !String.IsNullOrEmpty(_requestValueCollection[callbackLoadScriptID]);
                Response.Write(needsCallbackLoadScript ?
                    Util.QuoteJScriptString(HttpUtility.HtmlEncode(e.Message)) :
                    HttpUtility.HtmlEncode(e.Message));
            }
        }
        return;
    }

    // TAP version of PrepareCallback.
    // !! IMPORTANT !!
    // If you change this method, also change PrepareCallback.
    private async Task PrepareCallbackAsync(string callbackControlID) {
        Response.Cache.SetNoStore();
        try {
            string param = _requestValueCollection[callbackParameterID];
            _callbackControl = FindControl(callbackControlID) as ICallbackEventHandler;

            if (_callbackControl != null) {
                using (Context.SyncContext.AllowVoidAsyncOperationsBlock()) {
                    _callbackControl.RaiseCallbackEvent(param);
                    await GetWaitForPreviousStepCompletionAwaitable();
                }
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.Page_CallBackTargetInvalid, callbackControlID));
            }
        }
        catch (Exception e) {
            Response.Clear();
            Response.Write('e');
            if (Context.IsCustomErrorEnabled) {
                Response.Write(SR.GetString(SR.Page_CallBackError));
            }
            else {
                bool needsCallbackLoadScript = !String.IsNullOrEmpty(_requestValueCollection[callbackLoadScriptID]);
                Response.Write(needsCallbackLoadScript ?
                    Util.QuoteJScriptString(HttpUtility.HtmlEncode(e.Message)) :
                    HttpUtility.HtmlEncode(e.Message));
            }
        }
        return;
    }

    private void RenderCallback() {
        bool needsCallbackLoadScript = !String.IsNullOrEmpty(_requestValueCollection[callbackLoadScriptID]);
        try {
            string index = null;
            if (needsCallbackLoadScript) {
                index = _requestValueCollection[callbackIndexID];
                if (String.IsNullOrEmpty(index)) {
                    throw new HttpException(SR.GetString(SR.Page_CallBackInvalid));
                }
                // We validate the user string because we're injecting it into the response script.
                // We don't need the integer, so we don't call Parse, we just need to check only expected
                // characters are in the string (0 to 9)
                for (int i = 0; i < index.Length; i++) {
                    char c = index[i];
                    if (c < '0' || c > '9') {
                        throw new HttpException(SR.GetString(SR.Page_CallBackInvalid));
                    }
                }
                Response.Write("<script>parent.__pendingCallbacks[");
                Response.Write(index);
                Response.Write("].xmlRequest.responseText=\"");
            }
            if (_callbackControl != null) {
                string result = _callbackControl.GetCallbackResult();
                if (EnableEventValidation) {
                    // Outputting the new value for the validation field under the length|value format.
                    string validation = ClientScript.GetEventValidationFieldValue();
                    Response.Write(validation.Length.ToString(CultureInfo.InvariantCulture));
                    Response.Write('|');
                    Response.Write(validation);
                }
                else {
                    Response.Write('s');
                }
                Response.Write(needsCallbackLoadScript ? Util.QuoteJScriptString(result) : result);
            }

            if (needsCallbackLoadScript) {
                Response.Write("\";parent.__pendingCallbacks[");
                Response.Write(index);
                Response.Write("].xmlRequest.readyState=4;parent.WebForm_CallbackComplete();</script>");
            }
        }
        catch (Exception e) {
            Response.Clear();
            Response.Write('e');
            if (Context.IsCustomErrorEnabled) {
                Response.Write(SR.GetString(SR.Page_CallBackError));
            }
            else {
                Response.Write(needsCallbackLoadScript ?
                    Util.QuoteJScriptString(HttpUtility.HtmlEncode(e.Message)) :
                    HttpUtility.HtmlEncode(e.Message));
            }
        }
        return;
    }

    private bool RenderDivAroundHiddenInputs(HtmlTextWriter writer) {
        return writer.RenderDivAroundHiddenInputs && (!EnableLegacyRendering || (RenderingCompatibility >= VersionUtil.Framework40));
    }

    internal void SetForm(HtmlForm form) {
        _form = form;
    }

    internal void SetPostFormRenderDelegate(RenderMethod renderMethod) {
        _postFormRenderDelegate = renderMethod;
    }

    public HtmlForm Form { get { return _form; } }

    /// <devdoc>
    ///    <para>If called, ViewState will be persisted (see ASURT 73020).</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public void RegisterViewStateHandler() {
        _needToPersistViewState = true;
    }

    private void SaveAllState() {
        // Don't do anything if no one cares about the view state (see ASURT 73020)
        // Note: If _needToPersistViewState is false, control state should also be ignored.
        if (!_needToPersistViewState)
            return;

        Pair statePair = new Pair();

        // Control state is saved as a dictionary of
        // 1. A list of controls that require postback (stored under the page id)
        // 2. A dictionary of controls and their control state

        IDictionary controlStates = null;

        if (_registeredControlsRequiringControlState != null &&
            _registeredControlsRequiringControlState.Count > 0) {

#if OBJECTSTATEFORMATTER
            controlStates = new HybridDictionary(_registeredControlsRequiringControlState.Count + 1);
#else
            controlStates = new Hashtable(_registeredControlsRequiringControlState.Count + 1);
#endif

            foreach (Control ctl in _registeredControlsRequiringControlState) {
                object controlState = ctl.SaveControlStateInternal();
                // Do not allow null control states to be added, and do not allow a control's state to be
                // added more than once.
                if (controlStates[ctl.UniqueID] == null && controlState != null) {
                    controlStates.Add(ctl.UniqueID, controlState);
                }
            }
        }
        if (_registeredControlsThatRequirePostBack != null && _registeredControlsThatRequirePostBack.Count > 0) {
            if (controlStates == null) {
#if OBJECTSTATEFORMATTER
                controlStates = new HybridDictionary();
#else
                controlStates = new Hashtable();
#endif
            }
            controlStates.Add(PageRegisteredControlsThatRequirePostBackKey, _registeredControlsThatRequirePostBack);
        }

        // Only persist control state if it is nonempty.
        if (controlStates != null && controlStates.Count > 0) {
            statePair.First = controlStates;
        }

        // The state is saved as an array of objects:
        // 1. The hash code string
        // 2. The state of the entire control hierarchy
        ViewStateMode inheritedMode = ViewStateMode;
        if (inheritedMode == ViewStateMode.Inherit) {
            inheritedMode = ViewStateMode.Enabled;
        }
        Pair allSavedViewState = new Pair(GetTypeHashCode().ToString(NumberFormatInfo.InvariantInfo), SaveViewStateRecursive(inheritedMode));

        if (Context.TraceIsEnabled) {
            int viewStateSize = 0;
            if (allSavedViewState.Second is Pair) {
                viewStateSize = EstimateStateSize(((Pair)allSavedViewState.Second).First);
            } else if (allSavedViewState.Second is Triplet) {
                viewStateSize = EstimateStateSize(((Triplet)allSavedViewState.Second).First);
            }

            Trace.AddControlStateSize(UniqueID, viewStateSize, controlStates == null? 0 : EstimateStateSize(controlStates[UniqueID]));
        }

        statePair.Second = allSavedViewState;

        SavePageStateToPersistenceMedium(statePair);
    }

    /*
     * Override this method to persist view state to something other
     * than hidden fields (

*/

    /// <devdoc>
    ///    <para>Saves any view state information for the page. Override
    ///       this method if you want to save the page view state in anything other than a hidden field.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    protected internal virtual void SavePageStateToPersistenceMedium(object state) {
        PageStatePersister persister = PageStatePersister;
        if (state is Pair) {
            Pair pair = (Pair)state;

            persister.ControlState = pair.First;
            persister.ViewState = pair.Second;
        }
        else /* triplet, legacy case, see VSWhidbey 155185 */ {
            persister.ViewState = state;
        }
        persister.Save();
    }

    /*
     * Set the intrinsics in this page object
     */

    private void SetIntrinsics(HttpContext context) {
        SetIntrinsics(context, false /* allowAsync */);
    }

    private void SetIntrinsics(HttpContext context, bool allowAsync) {
        _context = context;
        _request = context.Request;
        _response = context.Response;
        _application = context.Application;
        _cache = context.Cache;

        if (!allowAsync && _context != null && _context.ApplicationInstance != null) {
            // disable attempts to launch async operations from pages not marked as async=true
            // the first non-async page [on the server.execute stack] disables async operations
            // it is re-enabled back in HttpApplication after done executing handler
            _context.SyncContext.Disable();
        }

        // Synchronize the ClientTarget
        if (!String.IsNullOrEmpty(_clientTarget)) {
            _request.ClientTarget = _clientTarget;
        }

        // DCR 85444: Support per device type encoding
        HttpCapabilitiesBase caps = _request.Browser;

        if(caps != null) {
            // Dev10 440476: Page.SetIntrinsics method has a 


            // VSWhidbey 109162: Set content type at the very beginning so it can be
            // overwritten within the user code of the page if needed.
            _response.ContentType = caps.PreferredRenderingMime;

            string preferredResponseEncoding = caps.PreferredResponseEncoding;
            string preferredRequestEncoding =  caps.PreferredRequestEncoding;

            if (!String.IsNullOrEmpty(preferredResponseEncoding)) {
                _response.ContentEncoding = Encoding.GetEncoding(preferredResponseEncoding);
            }

            if(!String.IsNullOrEmpty(preferredRequestEncoding)) {
                _request.ContentEncoding = Encoding.GetEncoding(preferredRequestEncoding);
            }
        }

        // Hook up any automatic handler we may find (e.g. Page_Load)
        HookUpAutomaticHandlers();
    }

    /// <devdoc>
    /// Initializes the page's reference to the header control
    /// </devdoc>
    internal void SetHeader(HtmlHead header) {
        _header = header;

        if (!String.IsNullOrEmpty(_titleToBeSet)) {
            if (_header == null) {
                throw new InvalidOperationException(SR.GetString(SR.Page_Title_Requires_Head));
            }
            else {
                Title = _titleToBeSet;
                _titleToBeSet = null;
            }
        }

        if (!String.IsNullOrEmpty(_descriptionToBeSet)) {
            if (_header == null) {
                throw new InvalidOperationException(SR.GetString(SR.Page_Description_Requires_Head));
            }
            else {
                MetaDescription = _descriptionToBeSet;
                _descriptionToBeSet = null;
            }
        }

        if (!String.IsNullOrEmpty(_keywordsToBeSet)) {
            if (_header == null) {
                throw new InvalidOperationException(SR.GetString(SR.Page_Description_Requires_Head));
            }
            else {
                MetaKeywords = _keywordsToBeSet;
                _keywordsToBeSet = null;
            }
        }

    }

    /// Override to unload the previousPage. The previousPage is unloaded after
    /// the current page since current page could depend on previousPage.
    internal override void UnloadRecursive(bool dispose) {
        base.UnloadRecursive(dispose);

        if (_previousPage != null && _previousPage.IsCrossPagePostBack) {
            _previousPage.UnloadRecursive(dispose);
        }
    }

    // ASP Compat helpers
#if !FEATURE_PAL // FEATURE_PAL does not enable COM
    private AspCompatApplicationStep _aspCompatStep;

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected IAsyncResult AspCompatBeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData) {
        SetIntrinsics(context);

        _aspCompatStep = new AspCompatApplicationStep(context, new AspCompatCallback(ProcessRequest));
        return _aspCompatStep.BeginAspCompatExecution(cb, extraData);
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected void AspCompatEndProcessRequest(IAsyncResult result) {
        _aspCompatStep.EndAspCompatExecution(result);
    }
#endif // !FEATURE_PAL

    // Async page helpers

    public void ExecuteRegisteredAsyncTasks() {
        if (_legacyAsyncTaskManager == null) {
            // no tasks registered
            return;
        }

        if (_legacyAsyncTaskManager.TaskExecutionInProgress) {
            // already executing - don't re-enter
            return;
        }

        HttpAsyncResult ar = _legacyAsyncTaskManager.ExecuteTasks(null /*callback*/, null /*extraData*/);

        if (ar.Error != null) {
            // rethrow any errors running tasks synchronously
            throw new HttpException(null, ar.Error);
        }
    }

    private void CheckRemainingAsyncTasks(bool isThreadAbort) {
        // this method is called at the end of page execution
        // it throws if there are registered async tasks not executed yet
        if (_legacyAsyncTaskManager != null) {
            _legacyAsyncTaskManager.DisposeTimer();

            if (isThreadAbort) {
                _legacyAsyncTaskManager.CompleteAllTasksNow(true);
                return;
            }

            if (!_legacyAsyncTaskManager.FailedToStartTasks && _legacyAsyncTaskManager.AnyTasksRemain) {
                throw new HttpException(SR.GetString(SR.Registered_async_tasks_remain));
            }
        }
    }

    // Registers an asynchronous task with a page. Like other APIs on Page, this method is itself not thread-safe.
    public void RegisterAsyncTask(PageAsyncTask task) {
        if (task == null) {
            throw new ArgumentNullException("task");
        }

        if (SynchronizationContextUtil.CurrentMode == SynchronizationContextMode.Legacy) {
            if (_legacyAsyncTaskManager == null) {
                _legacyAsyncTaskManager = new LegacyPageAsyncTaskManager(this);
            }

            // Need to convert the user-provided PageAsyncTask to a legacy-style task for consumption by the legacy task manager
            LegacyPageAsyncTask legacyTask = new LegacyPageAsyncTask(task.BeginHandler, task.EndHandler, task.TimeoutHandler, task.State, task.ExecuteInParallel);
            _legacyAsyncTaskManager.AddTask(legacyTask);
        }
        else {
            // synchronous pages don't support async tasks
            if (!(this is IHttpAsyncHandler)) {
                throw new InvalidOperationException(SR.GetString(SR.Async_required));
            }

            if (_asyncTaskManager == null) {
                _asyncTaskManager = new PageAsyncTaskManager();
            }

            // We need to detect whether this is TAP or APM and enqueue the appropriate concrete type
            IPageAsyncTask asyncTask = (task.TaskHandler != null)
                ? (IPageAsyncTask)new PageAsyncTaskTap(task.TaskHandler)
                : (IPageAsyncTask)new PageAsyncTaskApm(task.BeginHandler, task.EndHandler, task.State);
            _asyncTaskManager.EnqueueTask(asyncTask);
        }
    }

    class LegacyPageAsyncInfo {
        private Page _page;
        private bool _callerIsBlocking; // in case of blocking caller can't lock app instance on another thread (deadlock)
        private HttpApplication _app;
        private AspNetSynchronizationContextBase _syncContext;
        private HttpAsyncResult _asyncResult;

        private bool _asyncPointReached;
        private int  _handlerCount;
        private ArrayList _beginHandlers;
        private ArrayList _endHandlers;
        private ArrayList _stateObjects;

        private AsyncCallback _completionCallback;
        private WaitCallback _callHandlersThreadpoolCallback;

        private int _currentHandler;
        private Exception _error;
        private bool _completed;

        internal LegacyPageAsyncInfo(Page page) {
            _page = page;
            _app = page.Context.ApplicationInstance;
            _syncContext = page.Context.SyncContext;
            _completionCallback = new AsyncCallback(this.OnAsyncHandlerCompletion);
            _callHandlersThreadpoolCallback = new WaitCallback(this.CallHandlersFromThreadpoolThread);
        }

        internal HttpAsyncResult AsyncResult {
            get { return _asyncResult; }
            set { _asyncResult = value; }
        }

        internal bool AsyncPointReached {
            get { return _asyncPointReached; }
            set { _asyncPointReached = value; }
        }

        internal bool CallerIsBlocking {
            get { return _callerIsBlocking; }
            set { _callerIsBlocking = value; }
        }

        internal void AddHandler(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
            if (_handlerCount == 0) {
                _beginHandlers = new ArrayList();
                _endHandlers   = new ArrayList();
                _stateObjects  = new ArrayList();
            }

            _beginHandlers.Add(beginHandler);
            _endHandlers.Add(endHandler);
            _stateObjects.Add(state);
            _handlerCount++;
        }



        internal void CallHandlers(bool onPageThread) {
            try {
                if (CallerIsBlocking || onPageThread) {
                    // locking app on another thread when the caller is blocking will lead to deadlocks, so don't lock here
                    // VSWhidbey 189344
                    CallHandlersPossiblyUnderLock(onPageThread);
                } else {
                    lock (_app) {
                        CallHandlersPossiblyUnderLock(onPageThread);
                    }
                }
            }
            catch (Exception e) {
                _error = e;
                _completed = true;
                _asyncResult.Complete(onPageThread, null /*result*/, _error);

                if (!onPageThread &&
                    e is ThreadAbortException &&
                    ((ThreadAbortException)e).ExceptionState is HttpApplication.CancelModuleException) {
                    // don't leave this threadpool thread with CancelModuleException
                    // as thread state - it might lead to AppDomainUnloadedException
                    // later, when the current app domain is unloaded and there is
                    // an attempt to get thread state form another app domain on
                    // the same thread
                    ThreadResetAbortWithAssert();
                }
            }
        }

        private void CallHandlersPossiblyUnderLock(bool onPageThread) {
            ThreadContext threadContext = null;

            if (!onPageThread) {
                threadContext = _app.OnThreadEnter();
            }

            try {
                while (_currentHandler < _handlerCount && _error == null) {
                    try {
                        IAsyncResult ar = ((BeginEventHandler)_beginHandlers[_currentHandler])(_page, EventArgs.Empty, _completionCallback, _stateObjects[_currentHandler]);

                        if (ar == null) {
                            throw new InvalidOperationException(SR.GetString(SR.Async_null_asyncresult));
                        }

                        if (ar.CompletedSynchronously) {
                            try {
                                ((EndEventHandler)_endHandlers[_currentHandler])(ar);
                            }
                            finally {
                                _currentHandler++;
                            }

                            continue;
                        }

                        // async completion
                        return;
                    }
                    catch (Exception e) {
                        if (onPageThread && _syncContext.PendingOperationsCount == 0) {
                            throw;
                        }

                        // Increment all of the appropriate error counters
                        PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
                        PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);

                        // If it hasn't been handled, rememeber it
                        try {
                            if (!_page.HandleError(e))
                                _error = e;
                        }
                        catch (Exception e2) {
                            _error = e2;
                        }
                    }
                }

                // check if any async operations started
#if DBG
                Debug.Trace("Async", "Page has PendingOperationsCount of " + _syncContext.PendingOperationsCount);
#endif

                if (_syncContext.PendingCompletion(_callHandlersThreadpoolCallback)) {
                    return;
                }

                // get the error that happened in async completion delegates

                if (_error == null && _syncContext.Error != null) {
                    try {
                        if (!_page.HandleError(_syncContext.Error)) {
                            _error = _syncContext.Error;
                            _syncContext.ClearError();
                        }
                    }
                    catch (Exception e) {
                        _error = e;
                    }
                }

                // finish up the page processing

                try {
                    _page.Context.InvokeCancellableCallback(new WaitCallback(o => { _page.ProcessRequest(false /*includeStagesBeforeAsyncPoint*/, true /*includeStagesAfterAsyncPoint*/); }), null);
                }
                catch (Exception e) {
                    if (onPageThread)
                        throw;

                    _error = e;
                }

                // complete the async request (notify HttpAppplication)

                if (threadContext != null) {
                    // call DisassociateFromCurrentThread before Complete, because complete
                    // might resume and finish up the pipeline inside the call
                    try {
                        threadContext.DisassociateFromCurrentThread();
                    }
                    finally {
                        threadContext = null;
                    }
                }

                _completed = true;
                _asyncResult.Complete(onPageThread, null /*result*/, _error);
            }
            finally {
                if (threadContext != null) {
                    threadContext.DisassociateFromCurrentThread();
                }
            }
        }

        private void OnAsyncHandlerCompletion(IAsyncResult ar) {
            if (ar.CompletedSynchronously)  // handled in CallHandlers()
                return;

            try {
                ((EndEventHandler)_endHandlers[_currentHandler])(ar);
            }
            catch (Exception e) {
                _error = e;
            }

            if (_completed) {
                // already completed (possibly due to timeout, don't continue)
                return;
            }

            _currentHandler++;

            if (Thread.CurrentThread.IsThreadPoolThread) {
                // if on thread pool thread, use the current thread
                CallHandlers(false);
            }
            else {
                // if on a non-threadpool thread, requeue
                ThreadPool.QueueUserWorkItem(_callHandlersThreadpoolCallback);
            }
        }

        private void CallHandlersFromThreadpoolThread(Object data) {
            Debug.Trace("Async", "Page -- CallHandlersFromThreadpoolThread");
            CallHandlers(false);
        }

        internal void SetError(Exception error) {
            _error = error;
        }
    }

    private void AsyncPageProcessRequestBeforeAsyncPointCancellableCallback(Object state) {
        ProcessRequest(true /*includeStagesBeforeAsyncPoint*/, false /*includeStagesAfterAsyncPoint*/);
    }

    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected IAsyncResult AsyncPageBeginProcessRequest(HttpContext context, AsyncCallback callback, Object extraData) {
        // This method just dispatches to either the TAP or APM implementation, depending on the synchronization mode
        if (SynchronizationContextUtil.CurrentMode == SynchronizationContextMode.Legacy) {
            return LegacyAsyncPageBeginProcessRequest(context, callback, extraData);
        }
        else {
            return TaskAsyncHelper.BeginTask(() => ProcessRequestAsync(context), callback, extraData);
        }
    }

    internal CancellationTokenSource CreateCancellationTokenFromAsyncTimeout() {
        TimeSpan timeout = AsyncTimeout;

        // CancellationTokenSource can only create timers within a specific range (<= _maxAsyncTimeout)
        return (timeout <= _maxAsyncTimeout)
            ? new CancellationTokenSource(timeout)
            : new CancellationTokenSource();
    }

    // TAP
    private async Task ProcessRequestAsync(HttpContext context) {
        // we disallow async operations except during specific portions of the lifecycle
        context.SyncContext.ProhibitVoidAsyncOperations();

        SetIntrinsics(context, true /* allowAsync */);

        if (_asyncTaskManager == null) {
            // could be already created if AddOnPreRenderCompleteAsync called before ProcessRequest
            _asyncTaskManager = new PageAsyncTaskManager();
        }

        try {
            // process everything before the async point
            // the AsyncPageProcessRequestBeforeAsyncPointCancellableCallback method has its own HandleError semantics and will not throw if the exception is handled
            Task preWorkTask = null;
            _context.InvokeCancellableCallback(_ => {
                preWorkTask = ProcessRequestAsync(includeStagesBeforeAsyncPoint: true, includeStagesAfterAsyncPoint: false);
            }, null);
            await preWorkTask;

            // perform the asynchronous work
            try {
                using (CancellationTokenSource cancellationTokenSource = CreateCancellationTokenFromAsyncTimeout()) {
                    CancellationToken cancellationToken = cancellationTokenSource.Token;
                    try {
                        await _asyncTaskManager.ExecuteTasksAsync(this, EventArgs.Empty, cancellationToken, _context.SyncContext, _context.ApplicationInstance);
                    }
                    finally {
                        // Homogenize any exceptions due to request timeout into a TimeoutException.
                        if (cancellationToken.IsCancellationRequested) {
                            throw new TimeoutException(SR.GetString(SR.Async_task_timed_out));
                        }
                    }
                }
            }
            catch (Exception ex) {
                // This catch block is copied from ProcessRequestMain
                // Increment all of the appropriate error counters
                PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_DURING_REQUEST);
                PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);

                // If it hasn't been handled, rethrow it
                if (!HandleError(ex))
                    throw;
            }

            // process everything after the async point
            Task postWorkTask = null;
            _context.InvokeCancellableCallback(_ => {
                postWorkTask = ProcessRequestAsync(includeStagesBeforeAsyncPoint: false, includeStagesAfterAsyncPoint: true);
            }, null);
            await postWorkTask;
        }
        finally {
            // call Unload events
            ProcessRequestCleanup();
        }
    }

    private IAsyncResult LegacyAsyncPageBeginProcessRequest(HttpContext context, AsyncCallback callback, Object extraData) {
        SetIntrinsics(context, true /* allowAsync */);

        if (_legacyAsyncInfo == null) {
            // could be already created if AddOnPreRenderCompleteAsync called before ProcessRequest
            _legacyAsyncInfo = new LegacyPageAsyncInfo(this);
        }

        _legacyAsyncInfo.AsyncResult = new HttpAsyncResult(callback, extraData);
        _legacyAsyncInfo.CallerIsBlocking = (callback == null);

        // process request stages before async point
        try {
            _context.InvokeCancellableCallback(new WaitCallback(this.AsyncPageProcessRequestBeforeAsyncPointCancellableCallback), null);
        }
        catch (Exception e) {
            if (_context.SyncContext.PendingOperationsCount == 0) {
                // if there are no pending async operations it is ok to throw
                throw;
            }

            // can't throw yet, have to wait for pending async operations to finish
            Debug.Trace("Async", "Exception with async pending - saving the error");
            _legacyAsyncInfo.SetError(e);
        }

        // register handler from async manager to run async tasks (if any tasks are registered)
        // for blocking callers async tasks were already run
        if (_legacyAsyncTaskManager != null && !_legacyAsyncInfo.CallerIsBlocking) {
            _legacyAsyncTaskManager.RegisterHandlersForPagePreRenderCompleteAsync();
        }

        // mark async point
        _legacyAsyncInfo.AsyncPointReached = true;

        // disable async operations after this point
        _context.SyncContext.Disable();

        // call into async subscribers
        _legacyAsyncInfo.CallHandlers(true /*onPageThread*/);

        return _legacyAsyncInfo.AsyncResult;
    }


    /// <internalonly/>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected void AsyncPageEndProcessRequest(IAsyncResult result) {
        // This method just dispatches to either the TAP or APM implementation, depending on the synchronization mode
        if (SynchronizationContextUtil.CurrentMode == SynchronizationContextMode.Legacy) {
            LegacyAsyncPageEndProcessRequest(result);
        }
        else {
            // EndTask() observes and throws any captured exceptions; also waits for asynchronous completion
            TaskAsyncHelper.EndTask(result);
        }
    }

    private void LegacyAsyncPageEndProcessRequest(IAsyncResult result) {
        if (_legacyAsyncInfo == null)
            return;

        Debug.Assert(_legacyAsyncInfo.AsyncResult == result);

        // End() observes and throws any captured exceptions
        _legacyAsyncInfo.AsyncResult.End();
    }

    public void AddOnPreRenderCompleteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler) {
        AddOnPreRenderCompleteAsync(beginHandler, endHandler, null);
    }

    public void AddOnPreRenderCompleteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
        if (beginHandler == null) {
            throw new ArgumentNullException("beginHandler");
        }

        if (endHandler == null) {
            throw new ArgumentNullException("endHandler");
        }

        if (SynchronizationContextUtil.CurrentMode == SynchronizationContextMode.Normal) {
            // If using the new synchronization patterns, go against the task manager directly
            RegisterAsyncTask(new PageAsyncTask(beginHandler, endHandler, null, state));
            return;
        }

        if (_legacyAsyncInfo == null) {
            if (this is IHttpAsyncHandler) {
                // could be called from ctor before process request
                _legacyAsyncInfo = new LegacyPageAsyncInfo(this);
            }
            else {
                // synchronous pages don't support add async handler
                throw new InvalidOperationException(SR.GetString(SR.Async_required));
            }
        }

        if (_legacyAsyncInfo.AsyncPointReached) {
            throw new InvalidOperationException(SR.GetString(SR.Async_addhandler_too_late));
        }

        _legacyAsyncInfo.AddHandler(beginHandler, endHandler, state);
    }


    /// <devdoc>
    ///    <para>Instructs any validation controls included on the page to validate their
    ///       assigned information for the incoming page request.</para>
    /// </devdoc>
    public virtual void Validate() {
        _validated = true;
        if (_validators != null) {
            for (int i = 0; i < Validators.Count; i++) {
                Validators[i].Validate();
            }
        }
    }


    public virtual void Validate(string validationGroup) {
        _validated = true;
        if (_validators != null) {
            ValidatorCollection validators = GetValidators(validationGroup);

            // VSWhidbey 207823: When ValidationGroup is the default empty string,
            // we should call the V1 method which could have been overridden so
            // the overridden method on user page wouldn't be missed.
            if (String.IsNullOrEmpty(validationGroup) &&
                _validators.Count == validators.Count) {
                Validate();
            }
            else {
                for (int i = 0; i < validators.Count; i++) {
                    validators[i].Validate();
                }
            }
        }
    }

    public ValidatorCollection GetValidators(string validationGroup) {
        if (validationGroup == null) {
            validationGroup = String.Empty;
        }

        ValidatorCollection validators = new ValidatorCollection();
        if (_validators != null) {
            for (int i = 0; i < Validators.Count; i++) {
                BaseValidator baseValidator = Validators[i] as BaseValidator;
                if (baseValidator != null) {
                    if (0 == String.Compare(baseValidator.ValidationGroup, validationGroup,
                                            StringComparison.Ordinal)) {
                        validators.Add(baseValidator);
                    }
                }
                else if (validationGroup.Length == 0) {
                    validators.Add(Validators[i]);
                }
            }
        }
        return validators;
    }


    /// <devdoc>
    ///    <para>Throws an exception if it is runtime and we are not currently rendering the form runat=server tag.
    ///          Most controls that post back or that use client script require to be in this tag to function, so
    ///          they can call this during rendering. At design time this will do nothing.</para>
    ///    <para>Custom Control creators should call this during render if they render any sort of input tag, if they call
    ///          GetPostBackEventReference, or if they emit client script. A composite control does not need to make this
    ///          call.</para>
    ///    <para>This method should not be overridden unless creating an alternative page framework.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public virtual void VerifyRenderingInServerForm(Control control) {
        // We only want to make this check if we are definitely at runtime
        if (Context == null || DesignMode) {
            return;
        }

        if (control == null) {
            throw new ArgumentNullException("control");
        }

        if (!_inOnFormRender && !IsCallback) {
            throw new HttpException(SR.GetString(SR.ControlRenderedOutsideServerForm, control.ClientID, control.GetType().Name));
        }
    }

    public PageAdapter PageAdapter {
        get {
            if(_pageAdapter == null) {
                ResolveAdapter();
                _pageAdapter = (PageAdapter)AdapterInternal;
            }
            return _pageAdapter;
        }
    }

    // 
    private String _relativeFilePath;

    internal String RelativeFilePath {
        get {
            if (_relativeFilePath == null) {
                String s = Context.Request.CurrentExecutionFilePath;
                String filePath = Context.Request.FilePath;

                if(filePath.Equals(s)) {
                    int slash = s.LastIndexOf('/');

                    if (slash >= 0) {
                        s = s.Substring(slash+1);
                    }
                    _relativeFilePath = s;
                }
                else {
                    _relativeFilePath = Server.UrlDecode(UrlPath.MakeRelative(filePath, s));
                }
            }
            return _relativeFilePath;
        }
    }

    private bool _designModeChecked = false;
    private bool _designMode = false;

    internal bool GetDesignModeInternal() {
        if(!_designModeChecked) {
            _designMode = (Site != null) ? Site.DesignMode : false;
            _designModeChecked = true;
        }
        return _designMode;
    }

    // For use by controls to store information with same lifetime as the request, for example, all radio buttons can
    // use this to store the dictionary of radio button groups.  The key should be a type.  For the example, the value associated with
    // the key System.Web.UI.WebControls.WmlRadioButtonAdapter is a NameValueCollection of RadioButtonGroups.
    private IDictionary _items;

    [
    Browsable(false)
    ]
    public IDictionary Items {
        get {
            if (_items == null) {
                _items = new HybridDictionary();
            }
            return _items;
        }
    }

    // Simplified data binding context stack
    private Stack _dataBindingContext;

    /// <devdoc>
    /// Creates a new context for databinding by pushing a new data item onto the databinding context stack.
    /// </devdoc>
    internal void PushDataBindingContext(object dataItem) {
        if (_dataBindingContext == null) {
            _dataBindingContext = new Stack();
        }
        _dataBindingContext.Push(dataItem);
    }

    /// <devdoc>
    /// Exits a databinding context by removing the current data item from the databinding context stack.
    /// </devdoc>
    internal void PopDataBindingContext() {
        Debug.Assert(_dataBindingContext != null);
        Debug.Assert(_dataBindingContext.Count > 0);
        _dataBindingContext.Pop();
    }


    /// <devdoc>
    /// Gets the current data item from the top of the databinding context stack.
    /// </devdoc>
    public object GetDataItem() {
        if ((_dataBindingContext == null) || (_dataBindingContext.Count == 0)) {
            throw new InvalidOperationException(SR.GetString(SR.Page_MissingDataBindingContext));
        }
        return _dataBindingContext.Peek();
    }

    internal static bool IsSystemPostField(string field) {
        return s_systemPostFields.Contains(field);
    }

    internal IScriptManager ScriptManager {
        get {
            return (IScriptManager)Items[typeof(IScriptManager)];
        }
    }

    private void ValidateRawUrlIfRequired() {
        // Only validate the RawUrl if we weren't asked to skip validation and the current validation mode says we should validate.
        bool validationRequired = !SkipFormActionValidation && CalculateEffectiveValidateRequest();

        if (validationRequired) {
            // Simply touching the RawUrl property getter is sufficient to perform validation.
            string unused = _request.RawUrl;
        }
    }

    // Needed to support Validators in AJAX 1.0 (Windows OS Bugs 2015831)
    #region Atlas ScriptManager Partial Rendering support
    internal bool IsPartialRenderingSupported {
        get {
            if (!_pageFlags[isPartialRenderingSupportedSet]) {
                Type scriptManagerType = ScriptManagerType;
                if (scriptManagerType != null) {
                    object scriptManager = Page.Items[scriptManagerType];
                    if (scriptManager != null) {
                        PropertyInfo supportsPartialRenderingProperty = scriptManagerType.GetProperty("SupportsPartialRendering");
                        if (supportsPartialRenderingProperty != null) {
                            object supportsPartialRenderingValue = supportsPartialRenderingProperty.GetValue(scriptManager, null);
                            _pageFlags[isPartialRenderingSupported] = (bool)supportsPartialRenderingValue;
                        }
                    }
                }
                _pageFlags[isPartialRenderingSupportedSet] = true;
            }
            return _pageFlags[isPartialRenderingSupported];
        }
    }

    internal Type ScriptManagerType {
        get {
            if (_scriptManagerType == null) {
                _scriptManagerType = BuildManager.GetType("System.Web.UI.ScriptManager", false);
            }
            return _scriptManagerType;
        }
        set {
            // Meant for unit testing
            _scriptManagerType = value;
        }
    }
    #endregion

#if DBG
    // Temporary debugging method

    /// <internalonly/>
    /// <devdoc>
    /// </devdoc>
    public virtual void WalkViewState(object viewState, Control control, int indentLevel) {
        if (viewState == null) {
            return;
        }
        object [] viewStateArray = (object [])viewState;
        object controlViewState = viewStateArray[0];
        IDictionary childViewState = (IDictionary)viewStateArray[1];

        string prefix = "";
        for (int i=0; i < indentLevel; i++) {
            prefix = prefix + "  ";
        }

        if (controlViewState == null) {
            System.Web.Util.Debug.Trace("tpeters", prefix + "ObjViewState: null");
        }
        else {
            System.Web.Util.Debug.Trace("tpeters", prefix + "ObjViewState: " + controlViewState.ToString());
        }

        if (childViewState != null) {
            for (IDictionaryEnumerator e = childViewState.GetEnumerator(); e.MoveNext();) {
                int index = (int) e.Key;
                object value = e.Value;

                if (control == null) {
                    System.Web.Util.Debug.Trace("tpeters", prefix + "Control index: " + index.ToString());
                    WalkViewState(value, null, indentLevel + 1);
                }
                else {

                    string s = "None";
                    bool recurse = false;
                    if (control.HasControls()) {
                        if (index < control.Controls.Count) {
                            s = control.Controls[index].ToString();
                            recurse = true;
                        }
                        else {
                            s = "out of range";
                        }
                    }
                    System.Web.Util.Debug.Trace("tpeters", prefix + "Control index: " + index.ToString() + " control: " + s);
                    if (recurse) {
                        WalkViewState(value, control.Controls[index], indentLevel + 1);
                    }
                }
            }
        }
    }

#endif // DBG
}

// Used to define the list of valid values of the location attribute of the
// OutputCache directive.

/// <devdoc>
///    <para>[To be supplied.]</para>
/// </devdoc>
public enum OutputCacheLocation {

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    Any,

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    Client,

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    Downstream,

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    Server,

    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    None,

    ServerAndClient
}

internal enum SmartNavigationSupport {
    NotDesiredOrSupported=0,   // The Page does not ask for SmartNav, or the browser doesn't support it
    Desired,        // The Page asks for SmartNavigation, but we have not checked browser support
    IE6OrNewer     // SmartNavigation supported by IE6 or newer browsers
}

}