C# HttpBrowser 跨进程访问，解决内存泄露问题

#undef DEBUG
using Microsoft.Win32;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AnfleCrawler.Common
{
    /// <summary>
    /// Chromium / CasperJS + PhantomJS
    /// http://pinvoke.net/index.aspx
    /// </summary>
    public sealed partial class HttpBrowser : IHttpClient
    {
        #region NestedTypes
        [Serializable]
        public class AjaxBlockEntity
        {
            internal const string AjaxBlock = "_AjaxBlock";
            public string ID { get; set; }
            public string Text { get; set; }
            public bool IsEvent { get; set; }
        }
        public class AjaxEventEntity : MarshalByRefObject
        {
            public string ListenerSelector { get; set; }
            public bool EntryCall { get; set; }
            public Action<string> FinalCallback { get; set; }
        }

        [ComVisible(true)]
        public sealed class STAContext : Disposable
        {
            #region Fields
            public volatile bool IsRedirect;
            //internal MessageLoopApartment _Apartment;
            private SynchronizedCollection<Tuple<HtmlElement, EventHandler>> _releaseSet;
            private AutoResetEvent _sendReceiveWaiter;
            private CountdownEvent _ajaxWaiter;
            private System.Threading.Timer _lazyTimer;

            internal volatile bool DoInvokeHtml;
            private volatile string _outerHtml;
            #endregion

            #region Properties
            public Uri RequestUrl { get; private set; }
            public HttpRequestContent RequestContent { get; private set; }
            internal AutoResetEvent WaitHandle { get; set; }

            internal AutoResetEvent SendReceiveWaiter
            {
                get
                {
                    if (_sendReceiveWaiter == null)
                    {
                        _sendReceiveWaiter = new AutoResetEvent(false);
                    }
                    return _sendReceiveWaiter;
                }
            }
            internal AjaxBlockEntity[] AjaxBlocks { get; private set; }
            internal CountdownEvent AjaxWaiter
            {
                get
                {
                    if (_ajaxWaiter == null)
                    {
                        _ajaxWaiter = new CountdownEvent(1);
                    }
                    return _ajaxWaiter;
                }
            }
            internal volatile bool IsProcessEvent;
            internal AjaxEventEntity AjaxEvent { get; set; }

            internal string OuterHtml
            {
                get
                {
                    DoInvokeHtml = true;
                    return _outerHtml;
                }
                set
                {
                    _outerHtml = value;
                }
            }
            #endregion

            #region Constructor
            internal STAContext(Uri url, HttpRequestContent content)
            {
                this.RequestUrl = url;
                this.RequestContent = content;
                string ablock;
                if (this.RequestContent != null && this.RequestContent.Form != null)
                {
                    if (!string.IsNullOrEmpty(ablock = this.RequestContent.Form.Get(AjaxBlockEntity.AjaxBlock)))
                    {
                        this.AjaxBlocks = JsonConvert.DeserializeObject<AjaxBlockEntity[]>(ablock);
                        this.RequestContent.Form.Remove(AjaxBlockEntity.AjaxBlock);
                    }
                }
                DoInvokeHtml = true;
            }

            protected override void DisposeInternal(bool disposing)
            {
                if (disposing)
                {
                    //if (_Apartment != null)
                    //{
                    //    _Apartment.Dispose();
                    //    _Apartment = null;
                    //}
                    if (_lazyTimer != null)
                    {
                        _lazyTimer.Dispose();
                        _lazyTimer = null;
                    }
                    if (this.WaitHandle != null)
                    {
                        this.WaitHandle.Dispose();
                        this.WaitHandle = null;
                    }

                    DisposeObject(_sendReceiveWaiter);
                    DisposeObject(_ajaxWaiter);
                }
            }
            #endregion

            #region Methods
            public void SetHtml(string html)
            {
                _outerHtml = html;
                DoInvokeHtml = false;
            }

            internal void RegisterLazyLoad(Action<object> func, object state)
            {
                if (_lazyTimer != null)
                {
                    return;
                }
                _lazyTimer = new System.Threading.Timer(x => STA_Run(func, x, this), state, 2000, Timeout.Infinite);
            }
            /// <summary>
            /// 另种思路，在每次加载完毕后delay
            /// </summary>
            internal void DelayLazyLoad()
            {
                if (_lazyTimer == null)
                {
                    return;
                }
                _lazyTimer.Change(2000, Timeout.Infinite);
            }

            /// <summary>
            /// STA
            /// </summary>
            /// <param name="node"></param>
            /// <param name="e"></param>
            internal void AjaxMark(HtmlElement node, EventHandler e)
            {
                if (_releaseSet == null)
                {
                    _releaseSet = new SynchronizedCollection<Tuple<HtmlElement, EventHandler>>();
                }
                var q = from t in _releaseSet
                        where t.Item1 == node
                        select t;
                if (q.Any())
                {
                    return;
                }
                _releaseSet.Add(Tuple.Create(node, e));
                node.AttachEventHandler("onpropertychange", e);
            }

            /// <summary>
            /// STA
            /// </summary>
            internal void AjaxUnmarks()
            {
                if (_releaseSet.IsNullOrEmpty())
                {
                    return;
                }
                foreach (var item in _releaseSet)
                {
                    var node = item.Item1;
                    node.DetachEventHandler("onpropertychange", item.Item2);
                }
                _releaseSet = null;
            }

            internal void _ReleaseMemory()
            {
                return;
#if !DEBUG
                var proc = Process.GetCurrentProcess();
                //128M
                if (proc.PrivateMemorySize64 <= 134217728L)
                {
                    return;
                }
                base.ReleaseMemory();
#endif
            }
            #endregion
        }
        #endregion

        #region Static
        public const string Callback_Snapshot = "_xSnapshot";

        static HttpBrowser()
        {
            SetBrowserFeatureControl();
            //NativeMethods.SetErrorMode(NativeMethods.ErrorModes.SYSTEM_DEFAULT);
            NativeMethods.SetErrorMode(NativeMethods.ErrorModes.SEM_FAILCRITICALERRORS | NativeMethods.ErrorModes.SEM_NOGPFAULTERRORBOX | NativeMethods.ErrorModes.SEM_NOOPENFILEERRORBOX);
        }

        /// <summary>
        /// http://msdn.microsoft.com/en-us/library/ee330720(v=vs.85).aspx
        /// </summary>
        private static void SetBrowserFeatureControl()
        {
            // FeatureControl settings are per-process
            string fileName = Path.GetFileName(Process.GetCurrentProcess().MainModule.FileName);
            string[] skip = new string[] { "devenv.exe", "XDesProc.exe" };
            if (skip.Any(p => p.Equals(fileName, StringComparison.OrdinalIgnoreCase)))
            {
                return;
            }

            SetBrowserFeatureControlKey("FEATURE_BROWSER_EMULATION", fileName, GetBrowserEmulationMode());
            SetBrowserFeatureControlKey("FEATURE_MANAGE_SCRIPT_CIRCULAR_REFS", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_GPU_RENDERING ", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_AJAX_CONNECTIONEVENTS", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_ENABLE_CLIPCHILDREN_OPTIMIZATION", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_DOMSTORAGE ", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_IVIEWOBJECTDRAW_DMLT9_WITH_GDI  ", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_NINPUT_LEGACYMODE", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_DISABLE_LEGACY_COMPRESSION", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_LOCALMACHINE_LOCKDOWN", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_BLOCK_LMZ_OBJECT", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_BLOCK_LMZ_SCRIPT", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_DISABLE_NAVIGATION_SOUNDS", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_SCRIPTURL_MITIGATION", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_SPELLCHECKING", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_STATUS_BAR_THROTTLING", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_TABBED_BROWSING", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_VALIDATE_NAVIGATE_URL", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_WEBOC_DOCUMENT_ZOOM", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_WEBOC_POPUPMANAGEMENT", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_WEBOC_MOVESIZECHILD", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_ADDON_MANAGEMENT", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_WEBSOCKET", fileName, 1);
            //SetBrowserFeatureControlKey("FEATURE_WINDOW_RESTRICTIONS ", fileName, 0);
            //SetBrowserFeatureControlKey("FEATURE_XMLHTTP", fileName, 1);
        }
        /// <summary>
        /// http://msdn.microsoft.com/en-us/library/ie/ee330730(v=vs.85).aspx
        /// </summary>
        /// <returns></returns>
        private static uint GetBrowserEmulationMode()
        {
            int browserVersion;
            using (var ieKey = Registry.LocalMachine.OpenSubKey(@"SOFTWAREMicrosoftInternet Explorer",
                RegistryKeyPermissionCheck.ReadSubTree, System.Security.AccessControl.RegistryRights.QueryValues))
            {
                var version = ieKey.GetValue("svcVersion") ?? ieKey.GetValue("Version");
                if (version == null)
                {
                    throw new ApplicationException("Microsoft Internet Explorer is required!");
                }
                int.TryParse(version.ToString().Split('.')[0], out browserVersion);
            }
            if (browserVersion < 8)
            {
                throw new ApplicationException("Microsoft Internet Explorer 8 is required!");
            }
            switch (browserVersion)
            {
                case 9:
                    return 9000;
                case 10:
                    return 10000;
                case 11:
                    return 11000;
                default:
                    return 8000;
            }
        }
        private static void SetBrowserFeatureControlKey(string feature, string appName, uint value)
        {
            using (var key = Registry.CurrentUser.CreateSubKey(
                String.Concat(@"SoftwareMicrosoftInternet ExplorerMainFeatureControl", feature),
                RegistryKeyPermissionCheck.ReadWriteSubTree))
            {
                key.SetValue(appName, value, RegistryValueKind.DWord);
            }
        }

        private static void STA_Run(Action<object> func, object state, STAContext context)
        {
            var sta = new Thread(arg =>
            {
                var set = (object[])arg;
                try
                {
                    var func2 = (Action<object>)set[0];
                    func2(set[1]);
                }
                catch (Exception ex)
                {
                    App.LogError(ex, "STA_Run");
                }
            }, 1024 * 512);   //1024 * 512, 默认1M
            sta.IsBackground = true;
            sta.SetApartmentState(ApartmentState.STA);
            try
            {
                sta.Start(new object[2] { func, state });
            }
            catch (OutOfMemoryException ex)
            {
                HandleException(ex);
            }

            //context._Apartment.Invoke(func, state);
        }

        public static void FillAjaxBlock(NameValueCollection form, AjaxBlockEntity[] set)
        {
            Contract.Requires(form != null);

            form[AjaxBlockEntity.AjaxBlock] = JsonConvert.SerializeObject(set, Formatting.None);
        }
        #endregion

        #region Fields
        private EndPoint _proxyAddr;
        private Lazy<IHttpClient> _lazyClient;
        private CookieContainer _cookieContainer;
        private Action<STAContext, HtmlDocument> _onLoad;
        #endregion

        #region Properties
        public int SendReceiveTimeout { get; set; }
        public ushort? RetryCount { get; set; }
        public TimeSpan? RetryWaitDuration { get; set; }
        public bool UseCookies { get; set; }
        public CookieContainer CookieContainer
        {
            get { return _cookieContainer; }
        }
        public string SaveFileDirectory { get; set; }
        /// <summary>
        /// 网页快照大小，Full Screenshot则设置Size.Empty
        /// </summary>
        public Size? Snapshot { get; set; }
        /// <summary>
        /// 供下载使用
        /// </summary>
        internal IHttpClient Client
        {
            get
            {
                var client = _lazyClient.Value;
                client.SendReceiveTimeout = this.SendReceiveTimeout;
                client.RetryCount = this.RetryCount;
                client.RetryWaitDuration = this.RetryWaitDuration;
                client.UseCookies = this.UseCookies;
                client.SaveFileDirectory = this.SaveFileDirectory;
                return client;
            }
        }
        #endregion

        #region Constructors
        public HttpBrowser()
        {
            this.SendReceiveTimeout = -1;
            _lazyClient = new Lazy<IHttpClient>(() => new HttpClient(), false);
            _cookieContainer = new CookieContainer();
            this.UseCookies = true;
        }
        /// <summary>
        /// crossLoad中如有跨域交互，请继承扩展IsolateProxy
        /// </summary>
        /// <param name="crossLoad"></param>
        public HttpBrowser(Action<STAContext, HtmlDocument> crossLoad)
            : this()
        {
            _onLoad = crossLoad;
        }
        #endregion

        #region Methods
        public void SetProxy(EndPoint address, NetworkCredential credential = null)
        {
            if (credential != null)
            {
                throw new NotSupportedException("credential");
            }

            if (IsSpawned)
            {
                _proxyAddr = address;
            }
            else
            {
#if DEBUG
                App.LogInfo("SetProxy HttpBrowser {0}", address);
#endif
                if (WinInetInterop.SetConnectionProxy(address.ToString()))
                {
                    App.LogInfo("SetProxy HttpBrowser {0} succeed", address);
                }
            }
        }
        internal void RestoreSystemProxy()
        {
            if (IsSpawned)
            {
                _proxyAddr = null;
            }
            else
            {
#if DEBUG
                App.LogInfo("RestoreSystemProxy HttpBrowser");
#endif
                if (WinInetInterop.RestoreSystemProxy())
                {
                    App.LogInfo("RestoreSystemProxy HttpBrowser succeed");
                }
            }
        }

        public string GetHtml(Uri requestUrl, HttpRequestContent content = null)
        {
            if (IsSpawned)
            {
                return SpawnedStart(_proxyAddr, requestUrl, content);
            }
            using (var arg = new STAContext(requestUrl, content))
            {
                arg.WaitHandle = new AutoResetEvent(false);
                this.STA_Run(arg);
                arg.WaitHandle.WaitOne();
                return arg.OuterHtml;
            }
        }

        public string GetHtml(Uri requestUrl, AjaxEventEntity local, HttpRequestContent content = null)
        {
            Contract.Requires(requestUrl != null);
            if (local == null)
            {
                return GetHtml(requestUrl, content);
            }

            using (var arg = new STAContext(requestUrl, content))
            {
                arg.AjaxEvent = local;
                arg.WaitHandle = new AutoResetEvent(false);
                this.STA_Run(arg);
                arg.WaitHandle.WaitOne();
                return arg.OuterHtml;
            }
        }

        public Stream GetStream(Uri requestUrl, HttpRequestContent content = null)
        {
            return this.Client.GetStream(requestUrl, content);
        }

        public void DownloadFile(Uri fileUrl, out string fileName)
        {
            this.Client.DownloadFile(fileUrl, out fileName);
        }
        #endregion

        #region Hepler
        /// <summary>
        /// 注入Script
        /// </summary>
        /// <param name="document"></param>
        /// <param name="js"></param>
        public void InjectScript(HtmlDocument document, string js)
        {
            Contract.Requires(document != null);

            if (!CheckDocument(document.Url))
            {
                App.LogInfo("HttpBrowser InjectScript Cancel");
                return;
            }
            var head = document.GetElementsByTagName("head")[0];
            var script = document.CreateElement("script");
            script.SetAttribute("type", "text/javascript");
            script.SetAttribute("text", js);
            head.AppendChild(script);
        }
        private bool CheckDocument(Uri documentUrl)
        {
            if (documentUrl != null && documentUrl.OriginalString.StartsWith("res://ieframe.dll", StringComparison.OrdinalIgnoreCase))
            {
                App.LogInfo("CheckDocument {0}", documentUrl);
                return false;
            }
            return true;
        }

        /// <summary>
        /// 设置ajax参数
        /// </summary>
        /// <param name="browser"></param>
        private void SetAjax(WebBrowser browser, bool isEvent)
        {
            var arg = (STAContext)browser.ObjectForScripting;
            if (arg.AjaxBlocks.IsNullOrEmpty())
            {
                return;
            }
            foreach (var block in arg.AjaxBlocks.Where(p => p.IsEvent == isEvent))
            {
                var node = browser.Document.GetElementById(block.ID);
                if (node == null)
                {
                    continue;
                }
                arg.AjaxWaiter.AddCount();
                arg.AjaxMark(node, (sender, e) =>
                {
                    node = browser.Document.GetElementById(block.ID);
                    if (node == null || block.Text == null
                        || (!block.Text.Equals(node.InnerText, StringComparison.OrdinalIgnoreCase)))
                    {
                        // bug 如果先Signal再AddCount就会出错
                        arg.AjaxWaiter.Signal();
                    }
                });
            }
            arg.AjaxWaiter.Signal();
        }
        /// <summary>
        /// 等待ajax执行
        /// </summary>
        /// <param name="arg"></param>
        private bool WaitAjax(STAContext arg)
        {
            if (arg.AjaxBlocks.IsNullOrEmpty())
            {
                return false;
            }
            int aTimeout = this.SendReceiveTimeout;
            if (aTimeout <= 0)
            {
                aTimeout = (int)TimeSpan.FromSeconds(60d).TotalMilliseconds;
            }
            if (!arg.AjaxWaiter.Wait(aTimeout))
            {
                App.LogInfo("HttpBrowser Ajax Timeout {0}", arg.RequestUrl);
                return false;
            }
            return true;
        }

        private void ProcessAjaxEvent(WebBrowser browser)
        {
            var arg = (STAContext)browser.ObjectForScripting;
            if (arg.AjaxEvent == null || string.IsNullOrEmpty(arg.AjaxEvent.ListenerSelector))
            {
                return;
            }

            arg.IsProcessEvent = true;
            if (arg.AjaxEvent.EntryCall && arg.AjaxEvent.FinalCallback != null)
            {
                InvokeHtml(browser);
                arg.AjaxEvent.FinalCallback(arg.OuterHtml);
            }
            object val = browser.Document.InvokeScript("Soubiscbot", new object[] { 0, arg.AjaxEvent.ListenerSelector });
            var set = val.ToString().Split(',');
            foreach (string id in set)
            {
                var node = browser.Document.GetElementById(id);
                if (node == null)
                {
                    continue;
                }
                arg.AjaxWaiter.Reset();
                SetAjax(browser, true);
                node.InvokeMember("click");
                bool isSet = WaitAjax(arg);
                Console.WriteLine("ProcessAjaxEvent isSet={0}", isSet);
                if (arg.AjaxEvent.FinalCallback != null)
                {
                    InvokeHtml(browser);
                    arg.AjaxEvent.FinalCallback(arg.OuterHtml);
                }
            }
            arg.IsProcessEvent = false;
        }

        /// <summary>
        /// 读取页面OuterHtml
        /// </summary>
        /// <param name="browser"></param>
        /// <returns></returns>
        private void InvokeHtml(WebBrowser browser)
        {
            var scripting = (STAContext)browser.ObjectForScripting;
            if (scripting == null)
            {
                throw new InvalidOperationException("InvokeHtml");
            }
            if (!scripting.DoInvokeHtml)
            {
                return;
            }
            scripting.OuterHtml = (string)browser.Document.InvokeScript("Soubiscbot");
        }
        #endregion

        #region STAThread
        private void STA_Run(STAContext context)
        {
            context._ReleaseMemory();
            //context._Apartment = new MessageLoopApartment();
            STA_Run(state =>
            {
                var browser = new WebBrowser()
                {
                    ScriptErrorsSuppressed = true,
                    IsWebBrowserContextMenuEnabled = false,
                    ObjectForScripting = state
                };
                browser.Navigating += browser_Navigating;
                browser.DocumentCompleted += browser_DocumentCompleted;
                browser.NewWindow += browser_NewWindow;
                if (this.Snapshot.HasValue)
                {
                    browser.ScrollBarsEnabled = false;
                    browser.Size = new Size(Screen.PrimaryScreen.WorkingArea.Width, 10240);
                    browser.Show();
                }
                else
                {
                    browser.Hide();
                }
                var arg = (STAContext)state;
                byte[] postData = null;
                string headers = null;
                if (arg.RequestContent != null)
                {
                    if (this.UseCookies)
                    {
                        if (arg.RequestContent.HasCookie)
                        {
                            _cookieContainer.Add(arg.RequestUrl, arg.RequestContent.Cookies);
                        }
                        string cookieHeader = arg.RequestContent.Headers[HttpRequestHeader.Cookie];
                        if (!string.IsNullOrEmpty(cookieHeader))
                        {
                            _cookieContainer.SetCookies(arg.RequestUrl, cookieHeader.Replace(';', ','));
                            arg.RequestContent.Headers.Remove(HttpRequestHeader.Cookie);
                        }
                        cookieHeader = _cookieContainer.GetCookieHeader(arg.RequestUrl);
                        if (cookieHeader.Length > 0)
                        {
                            arg.RequestContent.Headers[HttpRequestHeader.Cookie] = cookieHeader.Replace(',', ';');
                        }
                        //WinInetInterop.SaveCookies(_cookieContainer, absoluteUri);
                    }
                    else
                    {
                        arg.RequestContent.Headers[HttpRequestHeader.Cookie] = string.Empty;
                        //WinInetInterop.DeleteCache(WinInetInterop.CacheKind.Cookies);
                    }
                    if (arg.RequestContent.HasBody)
                    {
                        arg.RequestContent.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
                        postData = Encoding.UTF8.GetBytes(arg.RequestContent.GetFormString());
                    }
                    headers = arg.RequestContent.GetHeadersString();
                }
                browser.Navigate(arg.RequestUrl, "_self", postData, headers);

                STA_Run(STA_Wait, browser, arg);
                //会阻塞当前线程
                Application.Run();
            }, context, context);
        }
        private void STA_Wait(object state)
        {
            var browser = (WebBrowser)state;
#if DEBUG
            App.LogInfo("STA_Wait {0}", browser.Url);
#endif
            var arg = (STAContext)browser.ObjectForScripting;
            try
            {
                int srTimeout = this.SendReceiveTimeout;
                if (srTimeout > -1 && !arg.SendReceiveWaiter.WaitOne(srTimeout))
                {
                    //请求超时
                    browser.Invoke((Action)(() =>
                    {
                        if (browser.ReadyState != WebBrowserReadyState.Complete)
                        {
                            browser.Stop();
                            App.LogInfo("HttpBrowser SendReceive Timeout {0}", arg.RequestUrl);
                        }
                    }));
                }
                WaitAjax(arg);
            }
            catch (Exception ex)
            {
                App.LogError(ex, "HttpBrowser STA_Wait {0}", arg.RequestUrl);
                HandleException(ex);
            }
        }

        private void browser_NewWindow(object sender, System.ComponentModel.CancelEventArgs e)
        {
            var browser = (WebBrowser)sender;
            var node = browser.Document.ActiveElement;
            string link;
            if (node != null && !string.IsNullOrEmpty(link = node.GetAttribute("href")))
            {
                e.Cancel = true;
                browser.Navigate(link);
            }
        }
        private void browser_Navigating(object sender, WebBrowserNavigatingEventArgs e)
        {
            var browser = (WebBrowser)sender;
#if DEBUG
            App.LogInfo("browser_Navigating {0}", browser.Url);
#endif
            var arg = (STAContext)browser.ObjectForScripting;
            arg.DelayLazyLoad();
        }
        private void browser_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
        {
            var browser = (WebBrowser)sender;
#if DEBUG
            App.LogInfo("browser_DocumentCompleted {0}", browser.Url);
#endif
            var arg = (STAContext)browser.ObjectForScripting;
            try
            {
                //e.Url不会变res:// 
                if (!CheckDocument(browser.Url))
                {
                    App.LogInfo("HttpBrowser DocumentCompleted Cancel {0}", browser.Url);
                    return;
                }
                if (browser.ReadyState != WebBrowserReadyState.Complete)
                {
                    return;
                }

                //发生redirect或iframe load
                if (browser.Url != e.Url)
                {
                    App.LogInfo("HttpBrowser Redirect {0} to {1}", arg.RequestUrl, e.Url);
                }
                if (this.UseCookies)
                {
                    WinInetInterop.LoadCookies(_cookieContainer, browser.Document.Url);
                }
                InjectScript(browser.Document, @"if (typeof ($) == 'undefined') {
            var script = document.createElement('script');
            script.src = 'http://libs.baidu.com/jquery/1.9.0/jquery.js';
            document.getElementsByTagName('head')[0].appendChild(script);
        }
        function Soubiscbot(kind) {
            switch (kind) {
                case 0:
                    var set = [];
                    $(arguments[1]).each(function (i, o) {
                        var me = $(o);
                        var id = me.attr('id');
                        if (!id) {
                            id = Math.random();
                            me.attr('id', id);
                        }
                        set[i] = id;
                    });
                    return set.toString();
                    break;
                case 1:
                    try {
                        return arguments[1]();
                    }
                    catch (ex) {
                        return ex.toString();
                    }
                    break;
                default:
                    return document.documentElement.outerHTML;
                    break;
            }
        }");

                if (this.SendReceiveTimeout > -1)
                {
                    arg.SendReceiveWaiter.Set();
                }
                SetAjax(browser, false);
                if (_onLoad != null)
                {
                    _onLoad(arg, browser.Document);
                }
                if (arg.IsRedirect)
                {
                    STA_Run(STA_Wait, browser, arg);
                }
                else
                {
                    arg.RegisterLazyLoad(x =>
                    {
                        var b = (WebBrowser)x;
                        if (b.IsDisposed)
                        {
                            return;
                        }
                        b.Invoke((Action<WebBrowser>)ProcessAjaxEvent, b);
                        b.Invoke((Action<object>)Callback, b);
                    }, browser);
                }
            }
            catch (Exception ex)
            {
                App.LogError(ex, "HttpBrowser DocumentCompleted RequestUrl={0} BrowserUrl={1}", arg.RequestUrl, browser.Url);
                HandleException(ex);
            }
        }

        private static void HandleException(Exception ex)
        {
            if (ex is OutOfMemoryException || ex is AccessViolationException)
            {
                App.LogInfo("HttpBrowser auto exit {0}", ex.HResult);
                Environment.Exit(ex.HResult);
            }
        }
        #endregion

        #region Callback
        private void Callback(object state)
        {
            var browser = (WebBrowser)state;
#if DEBUG
            App.LogInfo("Callback {0}", browser.Url);
#endif
            var arg = (STAContext)browser.ObjectForScripting;
            if (!Monitor.TryEnter(arg))
            {
                return;
            }
            try
            {
#warning HACK
                if (this.Snapshot.HasValue)
                {
                    Thread.Sleep(4000);
                }
                browser.Invoke((Action)(() =>
                {
                    if (this.Snapshot.HasValue)
                    {
                        //Guid fileID = CryptoManaged.MD5Hash(browser.Url.OriginalString);//browser.Url为ResponseUrl
                        Guid fileID = Guid.NewGuid();
                        var js = new StringBuilder();
                        js.AppendFormat("document.body.setAttribute('{0}', '{1}');", Callback_Snapshot, fileID);
                        js.Append(@"    window.addEventListener('load', function () {
        window.scrollTo(0, document.documentElement.offsetHeight);
    });
");
                        browser.Document.InvokeScript("eval", new object[] { js.ToString() });
                        string savePath = Path.Combine(this.SaveFileDirectory, string.Format("{0}.png", fileID));
                        try
                        {
                            var shotSize = this.Snapshot.Value == Size.Empty ? browser.Document.Body.ScrollRectangle.Size : this.Snapshot.Value;
                            browser.Size = shotSize;
                            using (var img = new Bitmap(browser.Width, browser.Height))
                            {
                                //browser.DrawToBitmap(img, new Rectangle(Point.Empty, img.Size));
                                NativeMethods.DrawTo(browser.ActiveXInstance, img, Color.White);
                                img.Save(savePath, System.Drawing.Imaging.ImageFormat.Png);
                                App.LogInfo("xSnapshot {0} {1}", browser.Url, savePath);
                            }
                        }
                        catch (Exception ex)
                        {
                            App.LogError(ex, "xSnapshot {0} {1}", browser.Url, savePath);
                        }
                    }
                    InvokeHtml(browser);
                }));
            }
            catch (Exception ex)
            {
                App.LogError(ex, "HttpBrowser Callback {0}", arg.RequestUrl);
                HandleException(ex);
            }
            finally
            {
                Monitor.Exit(arg);
                STA_Exit(browser);
            }
        }

        /// <summary>
        /// !重要! 退出STAUI线程
        /// </summary>
        private void STA_Exit(WebBrowser browser)
        {
#if DEBUG
            App.LogInfo("STA_Exit {0}", browser.Url);
#endif
            RestoreSystemProxy();
            var arg = (STAContext)browser.ObjectForScripting;
            if (arg.WaitHandle != null)
            {
                arg.WaitHandle.Set();
            }
            try
            {
                browser.Stop();
                arg.AjaxUnmarks();
                //arg._Apartment.Dispose();
                browser.Invoke((Action)(() => Application.ExitThread()));
                browser.Dispose();
            }
            catch (SystemException ex)
            {
                //AccessViolationException
                //InvalidComObjectException
                App.LogError(ex, "HttpBrowser STA_Exit {0}", arg.RequestUrl);
            }
        }
        #endregion
    }
}

#region Spawned Process
        public bool IsSpawned { get; set; }

        internal string SpawnedStart(EndPoint proxy, Uri requestUrl, HttpRequestContent content)
        {
#if DEBUG
            App.LogInfo("SpawnedStart: Proxy={0}	Url={1}", proxy, requestUrl);
#endif
            bool hasValue = content != null;
            var stream = Serializer.Serialize(Tuple.Create(proxy, requestUrl,
                hasValue ? content.Headers : null,
                hasValue ? content.Form : null));
            RestoreSystemProxy();
            string[] args = Environment.GetCommandLineArgs();
            string arg = string.Format("x#{0}", Convert.ToBase64String(stream.ToArray()));
            var proc = Process.Start(new ProcessStartInfo(args[0], arg)
            {
                RedirectStandardOutput = true,
                UseShellExecute = false,
            });
            string html = proc.StandardOutput.ReadToEnd();
            if (!proc.WaitForExit(120 * 1000))
            {
                proc.Kill();
            }
            proc.Close();
            return html;
        }

        public static bool SpawnedMain()
        {
            string[] args = Environment.GetCommandLineArgs();
            if (!(args.Length > 1 && args[1].StartsWith("x#")))
            {
                return false;
            }
            var stream = new MemoryStream(Convert.FromBase64String(args[1].Substring(2)));
            var arg = (Tuple<EndPoint, Uri, WebHeaderCollection, NameValueCollection>)Serializer.Deserialize(stream);
            var client = (IHttpClient)new HttpBrowser();
            if (arg.Item1 != null)
            {
                client.SetProxy(arg.Item1);
            }
            string html = client.GetHtml(arg.Item2, new HttpRequestContent()
            {
                Headers = arg.Item3,
                Form = arg.Item4
            });
            Console.WriteLine(html);
            return true;
        }
        #endregion