protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback)
{
// Backwards compatibility. ProcessRequest will be called.
callback.Dispose();
handleRequest = false;
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var fileAbsolutePath = u.AbsolutePath;
var file = u.Authority + fileAbsolutePath;
if (string.IsNullOrEmpty(Path.GetFileName(file)))
{
file = Path.Combine(file, "index.html");
}
_totalBytesRead = 0;
_chromelyResource.Content = null;
_completed = false;
if (ProcessAssmblyEmbeddedFile(request.Url, file, fileAbsolutePath, callback))
{
return(true);
}
if (ProcessLocalFile(file, callback))
{
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var isCustomScheme = _config?.UrlSchemes?.IsUrlRegisteredCustomScheme(request.Url);
if (isCustomScheme.HasValue && isCustomScheme.Value)
{
Task.Run(() =>
{
using (callback)
{
try
{
var uri = new Uri(request.Url);
var path = uri.LocalPath;
var response = new ChromelyResponse();
if (string.IsNullOrEmpty(path))
{
response.ReadyState = (int)ReadyState.ResponseIsReady;
response.Status = (int)System.Net.HttpStatusCode.BadRequest;
response.StatusText = "Bad Request";
_chromelyResponse = response;
}
else
{
var parameters = request.Url.GetParameters();
var postData = GetPostData(request);
_chromelyResponse = _requestTaskRunner.Run(request.Method, path, parameters, postData);
string jsonData = _chromelyResponse.Data.EnsureResponseDataIsJsonFormat();
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
}
catch (Exception exception)
{
Logger.Instance.Log.Error(exception);
_chromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
finally
{
callback.Continue();
}
}
});
return(true);
}
Logger.Instance.Log.Error($"Url {request.Url} is not of a registered custom scheme.");
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
_totalBytesRead = 0;
_fileBytes = null;
_completed = false;
var fileInfo = new FileInfo(file);
// Check if file exists
if (!fileInfo.Exists)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.FileNotFound, file, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
callback.Continue();
}
// Check if file exists but empty
else if (fileInfo.Length == 0)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.ZeroFileSize, file, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
callback.Continue();
}
else
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
_statusCode = ResourceConstants.StatusOK;
_statusText = ResourceConstants.StatusOKText;
}
catch (Exception exception)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.FileProcessingError, file, exception, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
uri = new Uri(request.Url);
fileName = uri.AbsolutePath;
// if url is blocked
/*if (!myForm.IsURLOk(request.Url)) {
*
* // return true so it does not open up
* return true;
* }*/
// if url is browser file
if (uri.Host == "storage")
{
fileName = appPath + uri.Host + fileName;
if (File.Exists(fileName))
{
Task.Factory.StartNew(() => {
using (callback)
{
//var bytes = Encoding.UTF8.GetBytes(resource);
//stream = new MemoryStream(bytes);
FileStream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
// mimeType = CefResourceHandler.GetMimeType(Path.GetExtension(fileName));
stream = fStream;
callback.Continue();
}
});
return(true);
}
}
// if url is request for icon of another file
if (uri.Host == "fileicon")
{
Task.Factory.StartNew(() => {
using (callback)
{
stream = FileIconUtils.GetFileIcon(fileName, FileIconSize.Large);
// mimeType = ResourceHandler.GetMimeType(".png");
callback.Continue();
}
});
return(true);
}
// by default reject
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
if (!this.PrepareRequest(request))
{
return(false);
}
_cancellationTokenSource = new CancellationTokenSource();
_dataStream = null;
GetResource();
return(true);
async void GetResource()
{
try
{
if (await LoadResourceData(_cancellationTokenSource.Token))
{
_dataStream = await GetResourceDataStream(_cancellationTokenSource.Token);
}
}
catch (TaskCanceledException)
{
Logger.Instance.Log.Info("The request was canceled.");
}
catch (Exception ex) when(ex.Message == "The request was aborted: The request was canceled.")
{
Logger.Instance.Log.Info("The request was canceled.");
}
catch (Exception ex)
{
Logger.Instance.Log.Error(ex, "Exception thrown while loading resource");
}
finally
{
callback.Continue();
callback.Dispose();
}
}
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
_totalBytesRead = 0;
_fileBytes = null;
_completed = false;
// Check if file exists and not empty
var fileInfo = new FileInfo(file);
if ((fileInfo.Exists) && fileInfo.Length > 0)
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
}
catch (Exception exception)
{
Logger.Instance.Log.Error(exception);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback)
{
//Dispose the callback as it's an unmanaged resource, we don't need it in this case
callback.Dispose();
if (stream == null)
{
bytesRead = 0;
return(false);
}
//Data out represents an underlying buffer (typically 32kb in size).
var buffer = new byte[response.Length];
bytesRead = stream.Read(buffer, 0, buffer.Length);
response.Write(buffer, 0, buffer.Length);
return(bytesRead > 0);
}
/// <summary>
/// The process request.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
bool isCustomScheme = UrlSchemeProvider.IsUrlOfRegisteredCustomScheme(request.Url);
if (isCustomScheme)
{
Task.Run(() =>
{
using (callback)
{
try
{
mChromelyResponse = RequestTaskRunner.Run(request);
string jsonData = mChromelyResponse.Data.EnsureResponseIsJsonFormat();
mResponseBytes = Encoding.UTF8.GetBytes(jsonData);
}
catch (Exception exception)
{
Log.Error(exception);
mChromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
finally
{
callback.Continue();
}
}
});
return(true);
}
Log.Error($"Url {request.Url} is not of a registered custom scheme.");
callback.Dispose();
return(false);
}
/// <summary>
/// The process request.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
this.mTotalBytesRead = 0;
this.mFileBytes = null;
this.mCompleted = false;
if (File.Exists(file))
{
Task.Factory.StartNew(() =>
{
using (callback)
{
try
{
this.mFileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
this.mMime = MimeMapper.GetMimeType(extension);
}
catch (Exception exception)
{
Log.Error(exception);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback)
{
callback.Dispose();
if (Response == null)
{
bytesRead = 0;
return(false);
}
var buffer = new byte[response.Length];
bytesRead = Response.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
return(false);
}
response.Write(buffer, 0, buffer.Length);
return(bytesRead > 0);
}
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback)
{
callback.Dispose();
if (Stream == null)
{
bytesRead = 0;
return(false);
}
var buffer = new byte[response.Length];
bytesRead = Stream.Read(buffer, 0, buffer.Length);
response.Write(buffer, 0, buffer.Length);
if (Stream.Position >= Stream.Length - 1 && bytesRead == 0)
{
Stream.Close();
LogManager.CefLog("Closed file stream!");
}
return(bytesRead > 0);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
bool isCustomScheme = UrlSchemeProvider.IsUrlOfRegisteredCustomScheme(request.Url);
if (isCustomScheme)
{
Task.Factory.StartNew(() =>
{
using (callback)
{
try
{
m_chromelyResponse = CefGlueRequestTaskRunner.Run(request);
}
catch (Exception exception)
{
Log.Error(exception);
m_chromelyResponse = new ChromelyResponse();
m_chromelyResponse.Status = (int)HttpStatusCode.BadRequest;
m_chromelyResponse.Data = "An error occured.";
}
finally
{
callback.Continue();
}
}
});
return(true);
}
Log.Error(string.Format("Url {0} is not of a registered custom scheme.", request.Url));
callback.Dispose();
return(false);
}
/// <summary>
/// The process request.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
//var baseRelative = _baseDir.Replace("\\", "/");
var u = new Uri(request.Url);
var file = Path.Join(AppDomain.CurrentDomain.BaseDirectory, _appDirectory, u.AbsolutePath);
//if (first == null)
//{
// first = Path.GetDirectoryName(file);
//}
//else
//{
// file = Path.Join(first, u.AbsolutePath);
//}
this.mTotalBytesRead = 0;
this.mFileBytes = null;
this.mCompleted = false;
if (File.Exists(file))
{
Task.Factory.StartNew(() =>
{
using (callback)
{
try
{
this.mFileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
Log.Info(extension);
if (extension == ".wasm")
{
this.mMime = "application/wasm";
}
else if (extension == ".dll")
{
this.mMime = "application/octet-stream";
}
else if (extension == ".json")
{
this.mMime = "application/json";
}
else if (extension == ".woff" || extension == ".woff2")
{
this.mMime = "application/font-woff";
}
else
{
this.mMime = MimeMapper.GetMimeType(extension);
}
}
catch (Exception exception)
{
Log.Error(exception);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
_totalBytesRead = 0;
_fileBytes = null;
_completed = false;
var fileInfo = new FileInfo(file);
// Check if file exists
if (!fileInfo.Exists)
{
var status = ResourceFileStatus.FileNotFound.GetStatus();
_status = status.Item1;
_statusText = status.Item2;
_fileBytes = _statusText.GetMemoryStream();
Logger.Instance.Log.LogWarning($"File: {file}: {_statusText}");
callback.Continue();
}
// Check if file exists but empty
else if (fileInfo.Length == 0)
{
var status = ResourceFileStatus.ZeroFileSize.GetStatus();
_status = status.Item1;
_statusText = status.Item2;
_fileBytes = _statusText.GetMemoryStream();
Logger.Instance.Log.LogWarning($"File: {file}: {_statusText}");
callback.Continue();
}
else
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
var status = ResourceFileStatus.FileFound.GetStatus();
_status = status.Item1;
_statusText = status.Item2;
}
catch (Exception exception)
{
var status = ResourceFileStatus.FileProcessingError.GetStatus();
_status = status.Item1;
_statusText = status.Item2;
_fileBytes = _statusText.GetMemoryStream();
Logger.Instance.Log.LogError(exception, exception.Message);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var isSchemeRegistered = _requestSchemeProvider?.IsSchemeRegistered(request.Url);
if (isSchemeRegistered.HasValue && isSchemeRegistered.Value)
{
var uri = new Uri(request.Url);
var path = uri.LocalPath;
bool isRequestAsync = _routeProvider.IsActionRouteAsync(path);
if (isRequestAsync)
{
ProcessRequestAsync(path);
}
else
{
ProcessRequest(path);
}
return(true);
}
else
{
_chromelyResponse = _chromelyErrorHandler.HandleRouteNotFound(request.Identifier.ToString(), request.Url);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
callback.Dispose();
return(false);
#region Process Request
void ProcessRequest(string path)
{
Task.Run(() =>
{
using (callback)
{
try
{
if (string.IsNullOrWhiteSpace(path))
{
_chromelyResponse = _chromelyErrorHandler.HandleRouteNotFound(request.Identifier.ToString(), path);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
else
{
var parameters = request.Url.GetParameters(request.ReferrerURL);
var postData = GetPostData(request);
var jsonRequest = _serializerUtil.ObjectToJson(request);
_chromelyResponse = _requestTaskRunner.Run(request.Identifier.ToString(), path, parameters, postData, jsonRequest);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
}
catch (Exception exception)
{
var chromelyRequest = new ChromelyRequest()
{
Id = request.Identifier.ToString(), RouteUrl = request.Url
};
_chromelyResponse = _chromelyErrorHandler.HandleError(chromelyRequest, exception);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
finally
{
callback.Continue();
}
}
});
}
#endregion
#region Process Request Async
void ProcessRequestAsync(string path)
{
Task.Run(async() =>
{
using (callback)
{
try
{
if (string.IsNullOrWhiteSpace(path))
{
_chromelyResponse = _chromelyErrorHandler.HandleRouteNotFound(request.Identifier.ToString(), path);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
else
{
var parameters = request.Url.GetParameters(request.ReferrerURL);
var postData = GetPostData(request);
var jsonRequest = _serializerUtil.ObjectToJson(request);
_chromelyResponse = await _requestTaskRunner.RunAsync(request.Identifier.ToString(), path, parameters, postData, jsonRequest);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
}
catch (Exception exception)
{
var chromelyRequest = new ChromelyRequest()
{
Id = request.Identifier.ToString(), RouteUrl = request.Url
};
_chromelyResponse = _chromelyErrorHandler.HandleError(chromelyRequest, exception);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
finally
{
callback.Continue();
}
}
});
}
#endregion
}
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback)
{
// if no data stream was specified, then nothing to read
// and we should stop reading.
// return false to indicate this.
if (_dataStream == null)
{
bytesRead = 0;
callback.Continue();
callback.Dispose();
return(false);
}
// when this is second call of ReadResponse, _bytesRead will be set to non negative number
if (_bytesRead >= 0)
{
WriteReadBytes(out bytesRead);
callback.Dispose();
return(bytesRead != 0); //If read 0 bytes, then we should return in false
}
bytesRead = 0;
_ = ReadDataAsync();
return(true);
// Copies read bytes into response and return true, if data is completed, owtherwize returns false
async Task ReadDataAsync()
{
try
{
if (_rentedBuffer == null)
{
_rentedBuffer = ArrayPool <byte> .Shared.Rent(_bufferSize);
}
//await _semaphore.WaitAsync();
_bytesRead = await _dataStream.ReadAsync(_rentedBuffer, 0, Math.Min(bytesToRead, _bufferSize), _cancellationTokenSource.Token);
//_semaphore.Release();
}
catch (TaskCanceledException)
{
FreeResources();
_bytesRead = 0;
Logger.Instance.Log.Warn("Cancellation requested");
}
// Sometimes cef disposes object, before it is cancelled
// then this exception is thrown
// and i don't know how to fix this :(
catch (ObjectDisposedException)
{
FreeResources();
_bytesRead = 0;
Logger.Instance.Log.Warn("Cancellation requested");
}
catch (Exception ex)
{
FreeResources();
_bytesRead = 0;
Logger.Instance.Log.Error(ex, "Exception thrown while loading resource");
}
finally
{
callback.Continue();
callback.Dispose();
}
}
bool WriteReadBytes(out int bytesAlreadyRead)
{
if (_bytesRead == 0) //if 0 bytes read, then no data was read and we should complete request
{
bytesAlreadyRead = 0;
this.FreeResources();
return(true);
}
if (_bytesRead > 0) //writing read bytes into a buffer if there was something
{
response.Write(_rentedBuffer, 0, _bytesRead);
}
bytesAlreadyRead = _bytesRead; //incrementing counters
_totalRead += _bytesRead;
// Setting read bytes count to -1 to indicate, that nothing left to write
// End on next call Read from source should be performed
_bytesRead = -1;
var dataSize = this.GetDataSize();
// If datasize is known and we already read that amount, then stoping
bool completed = dataSize >= 0 && _totalRead == dataSize;
// if we completed data reading, freeing resources imediatly,
// because this ReadResponse will never be called again
// and any open file will left open forever
if (completed)
{
this.FreeResources();
}
return(completed);
}
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var uri = new Uri(request.Url);
var scheme = _config.UrlSchemes.GetScheme(request.Url);
var isFolderResourceScheme = scheme != null && scheme.IsUrlSchemeFolderResource();
var u = new Uri(request.Url);
var file = isFolderResourceScheme
? scheme.GetResourceFolderFile(u.AbsolutePath)
: u.Authority + u.AbsolutePath;
_totalBytesRead = 0;
_chromelyResource.Content = null;
_completed = false;
_fileInfo = new FileInfo(file);
// Check if file exists
if (!_fileInfo.Exists)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo);
callback.Continue();
}
// Check if file exists but empty
else if (_fileInfo.Length == 0)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo);
callback.Continue();
}
else
{
Task.Run(() =>
{
using (callback)
{
try
{
var fileBytes = File.ReadAllBytes(file);
_chromelyResource.Content = new MemoryStream(fileBytes);
string extension = Path.GetExtension(file);
_chromelyResource.MimeType = MimeMapper.GetMimeType(extension);
_chromelyResource.StatusCode = ResourceConstants.StatusOK;
_chromelyResource.StatusText = ResourceConstants.StatusOKText;
}
catch (Exception exception)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback)
{
bytesRead = 0;
callback.Dispose();
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var isSchemeRegistered = _requestSchemeProvider?.IsSchemeRegistered(request.Url);
if (isSchemeRegistered.HasValue && isSchemeRegistered.Value)
{
var uri = new Uri(request.Url);
var path = uri.LocalPath;
bool isRequestAsync = _routeProvider.IsActionRouteAsync(path);
if (isRequestAsync)
{
ProcessRequestAsync(path);
}
else
{
ProcessRequest(path);
}
return(true);
}
Logger.Instance.Log.LogWarning($"Url {request.Url} is not of a registered custom scheme.");
callback.Dispose();
return(false);
#region Process Request
void ProcessRequest(string path)
{
Task.Run(() =>
{
using (callback)
{
try
{
var response = new ChromelyResponse();
if (string.IsNullOrEmpty(path))
{
response.ReadyState = (int)ReadyState.ResponseIsReady;
response.Status = (int)HttpStatusCode.BadRequest;
response.StatusText = "Bad Request";
_chromelyResponse = response;
}
else
{
var parameters = request.Url.GetParameters();
var postData = GetPostData(request);
var jsonRequest = _serializerUtil.ObjectToJson(request);
_chromelyResponse = _requestTaskRunner.Run(request.Identifier.ToString(), path, parameters, postData, jsonRequest);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
}
catch (Exception exception)
{
Logger.Instance.Log.LogError(exception, exception.Message);
_chromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
finally
{
callback.Continue();
}
}
});
}
#endregion
#region Process Request Async
void ProcessRequestAsync(string path)
{
Task.Run(async() =>
{
using (callback)
{
try
{
var response = new ChromelyResponse();
if (string.IsNullOrEmpty(path))
{
response.ReadyState = (int)ReadyState.ResponseIsReady;
response.Status = (int)System.Net.HttpStatusCode.BadRequest;
response.StatusText = "Bad Request";
_chromelyResponse = response;
}
else
{
var parameters = request.Url.GetParameters();
var postData = GetPostData(request);
var jsonRequest = _serializerUtil.ObjectToJson(request);
_chromelyResponse = await _requestTaskRunner.RunAsync(request.Identifier.ToString(), path, parameters, postData, jsonRequest);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
}
catch (Exception exception)
{
Logger.Instance.Log.LogError(exception, exception.Message);
_chromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
finally
{
callback.Continue();
}
}
});
}
#endregion
}
