Continue() public méthode

Continue processing.
public Continue ( ) : void
Résultat void
        protected override bool ProcessRequest(CefRequest request, CefCallback callback)
        {
            if (request == null || callback == null)
            {
                return false;
            }
            try
            {
                uri = new Uri(request.Url);
            }
            catch (Exception)
            {
                API.Instance.Log("AssetSchemeHandler::ProcessRequest: Unable to parse path {0}", request.Url);
                return false;
            }

            Uri relativeUrl = new Uri(config.BrowserSourceSettings.Url);

            if (relativeUrl.LocalPath.Length == 1)
            {
                API.Instance.Log("AssetSchemeHandler::ProcessRequest: Invalid url (this shouldn't happen) {0}", relativeUrl);
                return false;
            }

            string relativePath = relativeUrl.LocalPath.Substring(1);
            string filename;
            try
            {
                filename = Path.GetFileName(relativePath);
                relativePath = Path.GetDirectoryName(relativePath);
            }
            catch (ArgumentException)
            {
                API.Instance.Log("AssetSchemeHandler::ProcessRequest: Unable to create absolute path from {0} and {1}", relativeUrl.LocalPath, uri.LocalPath);
                return false;
            }

            if (uri.LocalPath.Length == 1)
            {
                isAssetWrapping = true;

                string extension = Path.GetExtension(filename);
                if (extension.Length > 1 && extension.StartsWith("."))
                {
                    extension = extension.Substring(1);
                }

                string wrappedAssetMimeType;
                if (!MimeTypeManager.MimeTypes.TryGetValue(extension, out wrappedAssetMimeType))
                {
                    wrappedAssetMimeType = "text/html";
                }

                string resolvedTemplate = config.BrowserSourceSettings.Template;

                resolvedTemplate = resolvedTemplate.Replace("$(FILE)", filename);
                resolvedTemplate = resolvedTemplate.Replace("$(WIDTH)", config.BrowserSourceSettings.Width.ToString());
                resolvedTemplate = resolvedTemplate.Replace("$(HEIGHT)", config.BrowserSourceSettings.Height.ToString());
                resolvedTemplate = resolvedTemplate.Replace("$(MIMETYPE)", wrappedAssetMimeType);
                inputStream = new MemoryStream(Encoding.UTF8.GetBytes(resolvedTemplate));
            }
            else
            {
                isAssetWrapping = false;

                if (uri.LocalPath != null && uri.LocalPath.Length > 1)
                {
                    resolvedPath = uri.LocalPath.Substring(1);
                }
                else
                {
                    API.Instance.Log("AssetSchemeHandler::ProcessRequest: Unable to parse path {0}", request.Url);
                    return false;
                }

                bool isIgnoringIntercept = uri.Query != null && uri.Query.Length != 0;

                // if there is a query param, it should ignore interception
                if (!isIgnoringIntercept && config.BrowserSourceSettings.IsApplyingTemplate)
                {
                    resolvedPath = Path.Combine(relativePath, resolvedPath);
                }

                API.Instance.Log("AssetSchemeHandler::ProcessRequest handling file {0}", resolvedPath);

                try
                {
                    inputStream = new FileStream(resolvedPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                }
                catch (Exception e)
                {
                    if (inputStream != null)
                    {
                        inputStream.Dispose();
                        inputStream = null;
                    }

                    API.Instance.Log("AssetSchemeHandler::ProcessRequest of file {0} failed; {1}", resolvedPath, e.Message);
                    callback.Cancel();
                    return false;
                }
            }

            length = remaining = inputStream.Length;

            callback.Continue();
            return true;
        }
        protected override bool ProcessRequest(CefRequest request, CefCallback callback)
        {
            if (request == null || callback == null)
            {
                return false;
            }
            try
            {
                uri = new Uri(request.Url);
            }
            catch (Exception e)
            {
                API.Instance.Log("AssetSchemeHandler::ProcessRequest: Unable to parse path {0}", request.Url);
                return false;
            }

            if (uri.LocalPath.Length == 1)
            {
                isAssetWrapping = true;
                String resolvedTemplate = config.BrowserSourceSettings.Template;
                resolvedTemplate = resolvedTemplate.Replace("$(FILE)", config.BrowserSourceSettings.Url);
                resolvedTemplate = resolvedTemplate.Replace("$(WIDTH)", config.BrowserSourceSettings.Width.ToString());
                resolvedTemplate = resolvedTemplate.Replace("$(HEIGHT)", config.BrowserSourceSettings.Height.ToString());
                inputStream = new MemoryStream(Encoding.UTF8.GetBytes(resolvedTemplate));

            }
            else
            {
                isAssetWrapping = false;

                if (uri.LocalPath != null && uri.LocalPath.Length > 1)
                {
                    resolvedPath = uri.LocalPath.Substring(1);
                }
                else
                {
                    API.Instance.Log("AssetSchemeHandler::ProcessRequest: Unable to parse path {0}", request.Url);
                    return false;
                }

                try
                {
                    inputStream = new FileStream(resolvedPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                }
                catch (Exception e)
                {
                    if (inputStream != null)
                    {
                        inputStream.Dispose();
                        inputStream = null;
                    }

                    API.Instance.Log("AssetSchemeHandler::ProcessRequest of file {0} failed; {1}", resolvedPath, e.Message);
                    callback.Cancel();
                    return false;
                }
            }

            length = remaining = inputStream.Length;

            callback.Continue();
            return true;
        }