protected override void OnLoadEnd(CefBrowser browser, CefFrame frame, int httpStatusCode)
 {
     if (OnLoadEndEvent != null)
     {
         OnLoadEndEvent(browser, frame, httpStatusCode);
     }
 }

		public LoadErrorEventArgs(CefFrame frame, CefErrorCode errorCode, string errorText, string failedUrl)
		{
			Frame = frame;
			ErrorCode = errorCode;
			ErrorText = errorText;
			FailedUrl = failedUrl;
		}

        private Task<IWebBrowserWindowProvider> InitTask(string fullpath, IWebSessionLogger logger)
        {
            TaskCompletionSource<IWebBrowserWindowProvider> tcs = new TaskCompletionSource<IWebBrowserWindowProvider>();
            Task.Run(async () =>
            {
                var cefWindowInfo = CefWindowInfo.Create();
                cefWindowInfo.SetAsWindowless(IntPtr.Zero, true);

                //// Settings for the browser window itself (e.g. enable JavaScript?).
                var cefBrowserSettings = new CefBrowserSettings();

                // Initialize some the cust interactions with the browser process.
                var cefClient = new TestCefClient();

                // Start up the browser instance.
                CefBrowserHost.CreateBrowser(cefWindowInfo, cefClient, cefBrowserSettings, fullpath);

                _CefBrowser = await cefClient.GetLoadedBrowserAsync();

                _CefFrame = _CefBrowser.GetMainFrame();
                _TestCefGlueHTMLWindowProvider = new TestCefGlueHTMLWindowProvider(_CefFrame, cefClient);
                tcs.SetResult(_TestCefGlueHTMLWindowProvider);
            });

            return tcs.Task;
        }

 protected override void OnAddressChange( CefBrowser browser, CefFrame frame, string url )
 {
     if( frame.IsMain )
     {
         owner.OnAddressChanged( url );
     }
 }

        internal IWebView GetContext(CefFrame frame)
        {
            var taskCompletionSource = _TaskCompletionSources.GetOrDefault(frame.Identifier);
            if (taskCompletionSource != null)
                return taskCompletionSource.Task.Result;

            return _Associated.GetOrDefault(frame.Identifier);
        }

        protected override void OnLoadStart(CefBrowser browser, CefFrame frame)
        {
            base.OnLoadStart(browser, frame);

            var message = CefProcessMessage.Create("SetOverlayAPI");
            message.Arguments.SetString(0, frame.Name);
            browser.SendProcessMessage(CefProcessId.Renderer, message);
        }

 public OnGetResourceHandlerEventArgs(string _id, CefBrowser _browser, CefFrame _frame, CefRequest _request)
 {
     id = _id;
     browser = _browser;
     frame = _frame;
     request = _request;
     DelegateRequest = false; //Default do not delegate, allow CEF to handle using network
 }

 internal void EnsureLoaded(CefFrame frame)
 {
     var view = GetContext(frame);
     if (view != null)
         return;
     var taskCompletionSource = new TaskCompletionSource<IWebView>();
     _TaskCompletionSources.Add(frame.Identifier, taskCompletionSource);
     //run dummy script to load context
     frame.ExecuteJavaScript("(function(){})()", string.Empty, 0);
 }

        protected override bool OnBeforeNavigation(CefBrowser browser, CefFrame frame, CefRequest request, CefNavigationType navigationType, bool isRedirect)
        {
            Console.WriteLine("OnBeforeNavigation: Request.Url={0} NavigationType={1} IsRedirect={2}",
                request.Url,
                navigationType,
                isRedirect
                );

            return false;
        }

 internal OnQueryEventArgs(CefBrowser _browser, CefFrame _frame, long _queryId, string _request, bool _persistent, CefMessageRouterBrowserSide.Callback _callback)
 {
     browser = _browser;
     frame = _frame;
     queryId = _queryId;
     request = _request;
     persistent = _persistent;
     callback = _callback;
     Handled = false; //default return value
 }

 internal void Associate(CefBrowser browser, CefFrame frame, CefV8Context context)
 {
     var webView = new CefV8_WebView(context,context.GetTaskRunner());
     var taskCompletionSource =  _TaskCompletionSources.GetOrDefault(frame.Identifier);  
     if (taskCompletionSource!=null)
     {
         _TaskCompletionSources.Remove(frame.Identifier);
         taskCompletionSource.TrySetResult(webView);
     }
     _Associated.Add(frame.Identifier, webView);  
 }

        protected override bool OnBeforePopup( CefBrowser browser, CefFrame frame, string targetUrl, string targetFrameName, CefPopupFeatures popupFeatures, CefWindowInfo windowInfo, ref CefClient client, CefBrowserSettings settings, ref bool noJavascriptAccess )
        {
            var e = new BeforePopupEventArgs( frame, targetUrl, targetFrameName, popupFeatures, windowInfo, client, settings,
                     noJavascriptAccess );

            this.owner.OnBeforePopup( e );

            client = e.Client;
            noJavascriptAccess = e.NoJavascriptAccess;

            return e.Handled;
        }

        public override bool OnQuery(CefBrowser browser, CefFrame frame, long queryId, string request, bool persistent, CefMessageRouterBrowserSide.Callback callback)
        {
            Debug.WriteLine(DBGPREFIX + "OnQuery called, [" + queryId + " " + (persistent ? "" : "not" + " persistent]: ") + request);
	        var handler = OnQueryEvent;
	        if (handler != null)
	        {
                Debug.WriteLine(DBGPREFIX + "OnQuery Delegate");
		        var e = new OnQueryEventArgs(browser, frame, queryId, request, persistent, callback);
		        handler(this, e);
                return e.Handled;
	        }
            return false;
        }

        public BeforePopupEventArgs(
			CefFrame frame,
			string targetUrl,
			string targetFrameName,
			CefPopupFeatures popupFeatures,
			CefWindowInfo windowInfo,
			CefClient client,
			CefBrowserSettings settings,
			bool noJavascriptAccess)
        {
            Frame = frame;
            TargetUrl = targetUrl;
            TargetFrameName = targetFrameName;
            PopupFeatures = popupFeatures;
            WindowInfo = windowInfo;
            Client = client;
            Settings = settings;
            NoJavascriptAccess = noJavascriptAccess;
        }

        protected override CefResourceHandler GetResourceHandler(CefBrowser browser, CefFrame frame, CefRequest request)
        {
            Debug.WriteLine(DBGPREFIX + "OnGetResourceHandler called for URL: " + request.Url);
	        var handler = OnGetResourceHandlerEvent;
	        if (handler != null)
	        {
                LVCefRequest lvCefRequest = new LVCefRequest(OnProcessRequestEvent, OnCancelEvent);
                Debug.WriteLine(DBGPREFIX + "OnGetResourceHandler for URL: " + request.Url + " assigned id " + lvCefRequest.id);
		        var e = new OnGetResourceHandlerEventArgs(lvCefRequest.id, browser, frame, request);
		        handler(this, e);

                if (e.DelegateRequest)
                {
                    Debug.WriteLine(DBGPREFIX + "OnGetResourceHandler for id " + lvCefRequest.id + " to be delegated");
                    return lvCefRequest;
                }
	        }
            Debug.WriteLine(DBGPREFIX + "OnGetResourceHandler for URL: " + request.Url + " to be handled normally by CEF");
            return null;
        }

 /// <summary>
 /// Called when a frame's address has changed.
 /// </summary>
 protected virtual void OnAddressChange(CefBrowser browser, CefFrame frame, string url)
 {
 }

 protected override void OnContextReleased(CefBrowser browser, CefFrame frame, CefV8Context context)
 {
     Debug.WriteLine(DBGPREFIX + "OnContextReleased called");
     _messageRouter.OnContextReleased(browser, frame, context);
 }

 protected override void OnLoadError(CefBrowser browser, CefFrame frame, CefErrorCode errorCode, string errorText, string failedUrl)
 {
     base.OnLoadError(browser, frame, errorCode, errorText, failedUrl);
 }

 protected override void OnLoadEnd(CefBrowser browser, CefFrame frame, int httpStatusCode)
 {
     base.OnLoadEnd(browser, frame, httpStatusCode);
     _LoadEnded.TrySetResult(browser);
 }

 /// <summary>
 /// Called on the IO thread before a new popup window is created. The |browser|
 /// and |frame| parameters represent the source of the popup request. The
 /// |target_url| and |target_frame_name| values may be empty if none were
 /// specified with the request. The |popupFeatures| structure contains
 /// information about the requested popup window. To allow creation of the
 /// popup window optionally modify |windowInfo|, |client|, |settings| and
 /// |no_javascript_access| and return false. To cancel creation of the popup
 /// window return true. The |client| and |settings| values will default to the
 /// source browser's values. The |no_javascript_access| value indicates whether
 /// the new browser window should be scriptable and in the same process as the
 /// source browser.
 /// </summary>
 protected virtual bool OnBeforePopup(CefBrowser browser, CefFrame frame, string targetUrl, string targetFrameName, CefPopupFeatures popupFeatures, CefWindowInfo windowInfo, ref CefClient client, CefBrowserSettings settings, ref bool noJavascriptAccess)
 {
     return false;
 }