/// <inheritdoc cref="IBrowser.NewContextAsync"/>
public async Task <IBrowserContext> NewContextAsync(BrowserContextOptions options = null)
{
string browserContextId = (await _session.SendAsync(new TargetCreateBrowserContextRequest()).ConfigureAwait(false)).BrowserContextId;
var context = CreateBrowserContext(browserContextId, options);
await context.InitializeAsync().ConfigureAwait(false);
_contexts.Add(browserContextId, context);
return(context);
}
public async Task <T> EvaluateAsync <T>(ExecutionContext context, bool returnByValue, string script, object[] args)
{
string suffix = $"//# sourceURL={EvaluationScriptUrl}";
RemoteObject remoteObject = null;
if (script.IsJavascriptFunction())
{
RuntimeCallFunctionOnResponse result = null;
try
{
result = await _client.SendAsync(new RuntimeCallFunctionOnRequest
{
FunctionDeclaration = $"{script}\n{suffix}\n",
ExecutionContextId = ContextId,
Arguments = args.Select(a => FormatArgument(a, context)).ToArray(),
ReturnByValue = returnByValue,
AwaitPromise = true,
UserGesture = true,
}).ConfigureAwait(false);
}
catch (Exception ex)
{
result = RewriteError(ex);
}
if (result.ExceptionDetails != null)
{
throw new PlaywrightSharpException($"Evaluation failed: {result.ExceptionDetails.ToExceptionMessage()}");
}
remoteObject = result.Result;
}
else
{
string expressionWithSourceUrl = _sourceUrlRegex.IsMatch(script) ? script : script + '\n' + suffix;
var result = await _client.SendAsync(new RuntimeEvaluateRequest
{
Expression = expressionWithSourceUrl,
ContextId = ContextId,
ReturnByValue = returnByValue,
AwaitPromise = true,
UserGesture = true,
}).ConfigureAwait(false);
if (result.ExceptionDetails != null)
{
throw new PlaywrightSharpException($"Evaluation failed: {result.ExceptionDetails.ToExceptionMessage()}");
}
remoteObject = result.Result;
}
return((T)(returnByValue ? GetValueFromRemoteObject <T>(remoteObject) : context.CreateHandle(remoteObject)));
}
internal Task StartAsync(CoverageStartOptions options)
{
if (_enabled)
{
throw new InvalidOperationException("JSCoverage is already enabled");
}
_resetOnNavigation = options.ResetOnNavigation;
_reportAnonymousScripts = options.ReportAnonymousScripts;
_enabled = true;
_scriptURLs.Clear();
_scriptSources.Clear();
_client.MessageReceived += Client_MessageReceived;
return(Task.WhenAll(
_client.SendAsync(new ProfilerEnableRequest()),
_client.SendAsync(new ProfilerStartPreciseCoverageRequest
{
CallCount = false,
Detailed = true,
}),
_client.SendAsync(new DebuggerEnableRequest()),
_client.SendAsync(new DebuggerSetSkipAllPausesRequest
{
Skip = true,
})));
}
public async Task AbortAsync(RequestAbortErrorCode errorCode = RequestAbortErrorCode.Failed)
{
try
{
await _client.SendAsync(new FetchFailRequestRequest
{
RequestId = InterceptionId,
ErrorReason = errorCode.ToErrorReasonProtocol(),
}).ConfigureAwait(false);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
/// <inheritdoc cref="IBrowser.StopTracingAsync"/>
public async Task <string> StopTracingAsync()
{
var taskWrapper = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously);
async void EventHandler(object sender, IChromiumEvent e)
{
try
{
if (e is TracingTracingCompleteChromiumEvent tracingTracingComplete)
{
string stream = tracingTracingComplete.Stream;
string tracingData = await ProtocolStreamReader.ReadProtocolStreamStringAsync(_tracingClient, stream, _tracingPath).ConfigureAwait(false);
_client.MessageReceived -= EventHandler;
taskWrapper.TrySetResult(tracingData);
}
}
catch (Exception ex)
{
string message = $"Tracing failed to process the tracing complete. {ex.Message}. {ex.StackTrace}";
System.Diagnostics.Debug.WriteLine(ex);
_tracingClient.OnClosed(message);
}
}
_tracingClient.MessageReceived += EventHandler;
await _tracingClient.SendAsync(new TracingEndRequest()).ConfigureAwait(false);
_tracingRecording = false;
return(await taskWrapper.Task.ConfigureAwait(false));
}
public async Task <IAXNode> FindElementAsync(ElementHandle element)
{
var remoteObject = element.RemoteObject;
var result = await _client.SendAsync(new DOMDescribeNodeRequest { ObjectId = remoteObject.ObjectId }).ConfigureAwait(false);
var needle = Find(node => node.Payload.BackendDOMNodeId == result.Node.BackendNodeId);
return(needle);
}
internal static async Task <string> ReadProtocolStreamStringAsync(ChromiumSession client, string handle, string path)
{
var result = new StringBuilder();
var fs = !string.IsNullOrEmpty(path) ? AsyncFileHelper.CreateStream(path, FileMode.Create) : null;
try
{
bool eof = false;
while (!eof)
{
var response = await client.SendAsync(new IOReadRequest
{
Handle = handle,
}).ConfigureAwait(false);
eof = response.Eof.Value;
result.Append(response.Data);
if (fs != null)
{
var data = Encoding.UTF8.GetBytes(response.Data);
await fs.WriteAsync(data, 0, data.Length).ConfigureAwait(false);
}
}
await client.SendAsync(new IOCloseRequest
{
Handle = handle,
}).ConfigureAwait(false);
return(result.ToString());
}
finally
{
fs?.Dispose();
}
}
internal static async Task <byte[]> ReadProtocolStreamByteAsync(ChromiumSession client, string handle, string path)
{
IEnumerable <byte> result = null;
bool eof = false;
var fs = !string.IsNullOrEmpty(path) ? AsyncFileHelper.CreateStream(path, FileMode.Create) : null;
try
{
while (!eof)
{
var response = await client.SendAsync(new IOReadRequest
{
Handle = handle,
}).ConfigureAwait(false);
eof = response.Eof.Value;
var data = Convert.FromBase64String(response.Data);
result = result == null ? data : result.Concat(data);
if (fs != null)
{
await fs.WriteAsync(data, 0, data.Length).ConfigureAwait(false);
}
}
await client.SendAsync(new IOCloseRequest
{
Handle = handle,
}).ConfigureAwait(false);
return(result.ToArray());
}
finally
{
fs?.Dispose();
}
}
public async Task <byte[]> GenerateAsync(string file, PdfOptions options)
{
double paperWidth = PaperFormat.Letter.Width;
double paperHeight = PaperFormat.Letter.Height;
if (options.Format != null)
{
paperWidth = options.Format.Width;
paperHeight = options.Format.Height;
}
else
{
if (options.Width != null)
{
paperWidth = ConvertPrintParameterToInches(options.Width);
}
if (options.Height != null)
{
paperHeight = ConvertPrintParameterToInches(options.Height);
}
}
double marginTop = ConvertPrintParameterToInches(options.MarginOptions.Top);
double marginLeft = ConvertPrintParameterToInches(options.MarginOptions.Left);
double marginBottom = ConvertPrintParameterToInches(options.MarginOptions.Bottom);
double marginRight = ConvertPrintParameterToInches(options.MarginOptions.Right);
var result = await _client.SendAsync(new PagePrintToPDFRequest
{
TransferMode = "ReturnAsStream",
Landscape = options.Landscape,
DisplayHeaderFooter = options.DisplayHeaderFooter,
HeaderTemplate = options.HeaderTemplate,
FooterTemplate = options.FooterTemplate,
PrintBackground = options.PrintBackground,
Scale = options.Scale,
PaperWidth = paperWidth,
PaperHeight = paperHeight,
MarginTop = marginTop,
MarginBottom = marginBottom,
MarginLeft = marginLeft,
MarginRight = marginRight,
PageRanges = options.PageRanges,
PreferCSSPageSize = options.PreferCSSPageSize,
}).ConfigureAwait(false);
return(await ProtocolStreamReader.ReadProtocolStreamByteAsync(_client, result.Stream, file).ConfigureAwait(false));
}
internal static async Task ReleaseObjectAsync(ChromiumSession client, IRemoteObject remoteObject)
{
if (string.IsNullOrEmpty(remoteObject.ObjectId))
{
return;
}
try
{
await client.SendAsync(new RuntimeReleaseObjectRequest
{
ObjectId = remoteObject.ObjectId,
}).ConfigureAwait(false);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
internal Task StartAsync(CoverageStartOptions options)
{
if (_enabled)
{
throw new InvalidOperationException("CSSCoverage is already enabled");
}
_resetOnNavigation = options.ResetOnNavigation;
_enabled = true;
_stylesheetURLs.Clear();
_stylesheetSources.Clear();
_client.MessageReceived += Client_MessageReceived;
return(Task.WhenAll(
_client.SendAsync(new DOMEnableRequest()),
_client.SendAsync(new CSSEnableRequest()),
_client.SendAsync(new CSSStartRuleUsageTrackingRequest())));
}
/// <inheritdoc cref="IBrowserContextDelegate.NewPageAsync"/>
public async Task <IPage> NewPageAsync()
{
var createTargetRequest = new TargetCreateTargetRequest
{
Url = "about:blank",
};
if (_contextId != null)
{
createTargetRequest.BrowserContextId = _contextId;
}
string targetId = (await _client.SendAsync(createTargetRequest)
.ConfigureAwait(false)).TargetId;
var target = _browser.TargetsMap[targetId];
await target.InitializedTask.ConfigureAwait(false);
return(await target.GetPageAsync().ConfigureAwait(false));
}
/// <inheritdoc cref="IBrowser.StartTracingAsync(IPage, TracingOptions)"/>
public Task StartTracingAsync(IPage page, TracingOptions options = null)
{
if (_tracingRecording)
{
throw new InvalidOperationException("Cannot start recording trace while already recording trace.");
}
_tracingClient = page != null ? ((ChromiumPage)((Page)page).Delegate).Client : _client;
var defaultCategories = new List <string>
{
"-*",
"devtools.timeline",
"v8.execute",
"disabled-by-default-devtools.timeline",
"disabled-by-default-devtools.timeline.frame",
"toplevel",
"blink.console",
"blink.user_timing",
"latencyInfo",
"disabled-by-default-devtools.timeline.stack",
"disabled-by-default-v8.cpu_profiler",
};
var categories = options?.Categories ?? defaultCategories;
if (options?.Screenshots == true)
{
categories.Add("disabled-by-default-devtools.screenshot");
}
_tracingPath = options?.Path;
_tracingRecording = true;
return(_tracingClient.SendAsync(new TracingStartRequest
{
TransferMode = "ReturnAsStream",
Categories = string.Join(", ", categories),
}));
}
internal Task InitializeAsync() => _client.SendAsync(new NetworkEnableRequest());
