DBO/xerobrowser
Archived
2
0
Fork 0
Code Issues 5 Pull requests Projects Releases Packages Wiki Activity Actions

Add project

Browse source
This commit is contained in:
Diamond Creeper 2023-02-20 23:24:10 +13:00
commit 7fcb279842
961 changed files with 370491 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

269
packages/CefSharp.Common.87.1.132/src/CefSharp/CefCustomScheme.cs vendored Normal file
View file

@ -0,0 +1,269 @@
// Copyright © 2014 The CefSharp Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
using System;
using System.Collections.Generic;
using System.Linq;
using CefSharp.Enums;
using CefSharp.Internals;
namespace CefSharp
{
/// <summary>
/// Used in conjunction with CefSettings.RegisterScheme to register a scheme.
/// You can register your own custom scheme e.g. custom:// if you are using a build in scheme
/// (http/https) then you should directly register your <see cref="ISchemeHandlerFactory"/> using
/// Cef.GetGlobalRequestContext().RegisterSchemeHandlerFactory - make sure the Global RequestContext has
/// been initialized before doing so, you can use <see cref="IBrowserProcessHandler.OnContextInitialized"/>
/// for notification of RequestContext initialization (Pass an IBrowserProcessHandler instance to Cef.Initialize)
/// </summary>
public sealed class CefCustomScheme
{
private SchemeOptions schemeOptions;
/// <summary>
/// Schema Name e.g. custom
/// </summary>
public string SchemeName { get; set; }
/// <summary>
/// Optional Domain Name. An empty value for a standard scheme
/// will cause the factory to match all domain names. The |domain_name| value
/// will be ignored for non-standard schemes.
/// </summary>
public string DomainName { get; set; }
/// <summary>
/// If true the scheme will be treated as a standard scheme.
/// Standard schemes are subject to URL canonicalization and parsing rules as
/// defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available
/// at http://www.ietf.org/rfc/rfc1738.txt
///
/// In particular, the syntax for standard scheme URLs must be of the form:
/// <pre>
/// [scheme]://[username]:[password]@[host]:[port]/[url-path]
/// </pre>
/// Standard scheme URLs must have a host component that is a fully qualified
/// domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of
/// RFC 1123. These URLs will be canonicalized to "scheme://host/path" in the
/// simplest case and "scheme://username:password@host:port/path" in the most
/// explicit case. For example, "scheme:host/path" and "scheme:///host/path"
/// will both be canonicalized to "scheme://host/path". The origin of a
/// standard scheme URL is the combination of scheme, host and port (i.e.,
/// "scheme://host:port" in the most explicit case).
///
/// For non-standard scheme URLs only the "scheme:" component is parsed and
/// canonicalized. The remainder of the URL will be passed to the handler
/// as-is. For example, "scheme:///some%20text" will remain the same.
/// Non-standard scheme URLs cannot be used as a target for form submission.
/// </summary>
public bool IsStandard
{
get { return schemeOptions.HasFlag(SchemeOptions.Standard); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.Standard;
}
else
{
schemeOptions &= ~SchemeOptions.Standard;
}
}
}
/// <summary>
/// If true the scheme will be treated as local (i.e. with the
/// same security rules as those applied to "file" URLs). Normal pages cannot
/// link to or access local URLs. Also, by default, local URLs can only perform
/// XMLHttpRequest calls to the same URL (origin + path) that originated the
/// request. To allow XMLHttpRequest calls from a local URL to other URLs with
/// the same origin set the CefSettings.file_access_from_file_urls_allowed
/// value to true. To allow XMLHttpRequest calls from a local URL to all
/// origins set the CefSettings.universal_access_from_file_urls_allowed value
/// to true.
/// </summary>
public bool IsLocal
{
get { return schemeOptions.HasFlag(SchemeOptions.Local); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.Local;
}
else
{
schemeOptions &= ~SchemeOptions.Local;
}
}
}
/// <summary>
/// If true the scheme will be treated as display-isolated.
/// This means that pages cannot display these URLs unless they are
/// from the same scheme. For example, pages in another origin cannot create
/// iframes or hyperlinks to URLs with this scheme.
/// </summary>
public bool IsDisplayIsolated
{
get { return schemeOptions.HasFlag(SchemeOptions.DisplayIsolated); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.DisplayIsolated;
}
else
{
schemeOptions &= ~SchemeOptions.DisplayIsolated;
}
}
}
/// <summary>
/// If true the scheme will be treated with the same security
/// rules as those applied to "https" URLs. For example, loading this scheme
/// from other secure schemes will not trigger mixed content warnings.
/// </summary>
public bool IsSecure
{
get { return schemeOptions.HasFlag(SchemeOptions.Secure); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.Secure;
}
else
{
schemeOptions &= ~SchemeOptions.Secure;
}
}
}
/// <summary>
/// If true the scheme can be sent CORS requests.
/// This value should be true in most cases where IsStandard is true.
/// </summary>
public bool IsCorsEnabled
{
get { return schemeOptions.HasFlag(SchemeOptions.CorsEnabled); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.CorsEnabled;
}
else
{
schemeOptions &= ~SchemeOptions.CorsEnabled;
}
}
}
/// <summary>
/// If true the scheme can bypass Content-Security-Policy(CSP) checks.
/// This value should be false in most cases where IsStandard is true.
/// </summary>
public bool IsCSPBypassing
{
get { return schemeOptions.HasFlag(SchemeOptions.CspBypassing); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.CspBypassing;
}
else
{
schemeOptions &= ~SchemeOptions.CspBypassing;
}
}
}
/// <summary>
/// If true the scheme can perform Fetch API requests.
/// </summary>
public bool IsFetchEnabled
{
get { return schemeOptions.HasFlag(SchemeOptions.FetchEnabled); }
set
{
if (value)
{
schemeOptions |= SchemeOptions.FetchEnabled;
}
else
{
schemeOptions &= ~SchemeOptions.FetchEnabled;
}
}
}
/// <summary>
/// Factory Class that creates <see cref="IResourceHandler"/> instances
/// for handling scheme requests. Leave this null if you wish to manually register the
/// scheme handler with the relevant RequestContext.
/// </summary>
public ISchemeHandlerFactory SchemeHandlerFactory { get; set; }
/// <summary>
/// Gets the underlying scheme options that represents
/// </summary>
public SchemeOptions Options
{
get { return schemeOptions; }
}
/// <summary>
/// Creates a new CefCustomScheme.
/// </summary>
public CefCustomScheme()
{
schemeOptions = SchemeOptions.Standard | SchemeOptions.Secure | SchemeOptions.CorsEnabled;
}
/// <summary>
/// Creates a new CefCustomScheme.
/// </summary>
/// <param name="schemeName">scheme name</param>
/// <param name="options">scheme options</param>
public CefCustomScheme(string schemeName, SchemeOptions options)
{
SchemeName = schemeName;
schemeOptions = options;
}
/// <summary>
/// Method used internally
/// </summary>
/// <param name="args">command line arguments</param>
/// <returns>list of scheme objects</returns>
public static List<CefCustomScheme> ParseCommandLineArguments(IEnumerable<string> args)
{
var schemes = args.GetArgumentValue(CefSharpArguments.CustomSchemeArgument);
var customSchemes = new List<CefCustomScheme>();
if (!string.IsNullOrEmpty(schemes))
{
schemes.Split(';').ToList().ForEach(x =>
{
var tokens = x.Split('|');
var schemeName = tokens[0];
var schemeOptions = SchemeOptions.None;
Enum.TryParse(tokens[1], out schemeOptions);
var customScheme = new CefCustomScheme(schemeName, schemeOptions);
customSchemes.Add(customScheme);
});
}
return customSchemes;
}
}
}