static Boolean shouldUseCredentialStorageCallback(CFURLConnectionRef conn, const void* clientInfo)
{
#if LOG_DISABLED
UNUSED_PARAM(conn);
#endif
ResourceHandle* handle = const_cast<ResourceHandle*>(static_cast<const ResourceHandle*>(clientInfo));
LOG(Network, "CFNet - shouldUseCredentialStorage(conn=%p, handle=%p) (%s)", conn, handle, handle->firstRequest().url().string().utf8().data());
if (!handle)
return false;
return handle->shouldUseCredentialStorage();
}
static void didReceiveData(CFURLConnectionRef conn, CFDataRef data, CFIndex originalLength, const void* clientInfo)
{
#if LOG_DISABLED
UNUSED_PARAM(conn);
#endif
ResourceHandle* handle = static_cast<ResourceHandle*>(const_cast<void*>(clientInfo));
const UInt8* bytes = CFDataGetBytePtr(data);
CFIndex length = CFDataGetLength(data);
LOG(Network, "CFNet - didReceiveData(conn=%p, handle=%p, bytes=%ld) (%s)", conn, handle, length, handle->firstRequest().url().string().utf8().data());
if (handle->client())
handle->client()->didReceiveData(handle, (const char*)bytes, length, originalLength);
}
void IconLoader::didFail(SubresourceLoader* resourceLoader, const ResourceError&)
{
LOG(IconDatabase, "IconLoader::didFail() - Loader %p", resourceLoader);
// Until <rdar://problem/5463392> is resolved and we can properly cancel SubresourceLoaders when they get an error response,
// we need to be prepared to receive this call even after we've "finished loading" once.
// After it is resolved, we can restore an assertion that the load is in progress if ::didFail() is called
if (m_loadIsInProgress) {
ASSERT(resourceLoader == m_resourceLoader);
ResourceHandle* handle = resourceLoader->handle();
finishLoading(handle ? handle->request().url() : KURL(), 0);
}
}
static void didFail(CFURLConnectionRef conn, CFErrorRef error, const void* clientInfo)
{
#if LOG_DISABLED
UNUSED_PARAM(conn);
#endif
ResourceHandle* handle = static_cast<ResourceHandle*>(const_cast<void*>(clientInfo));
LOG(Network, "CFNet - didFail(conn=%p, handle=%p, error = %p) (%s)", conn, handle, error, handle->firstRequest().url().string().utf8().data());
if (handle->quickLookHandle())
handle->quickLookHandle()->didFail();
if (handle->client())
handle->client()->didFail(handle, ResourceError(error));
}
static void didReceiveDataArray(CFURLConnectionRef conn, CFArrayRef dataArray, const void* clientInfo)
{
#if LOG_DISABLED
UNUSED_PARAM(conn);
#endif
ResourceHandle* handle = static_cast<ResourceHandle*>(const_cast<void*>(clientInfo));
if (!handle->client())
return;
LOG(Network, "CFNet - didReceiveDataArray(conn=%p, handle=%p, arrayLength=%ld) (%s)", conn, handle, CFArrayGetCount(dataArray), handle->firstRequest().url().string().utf8().data());
if (handle->quickLookHandle() && handle->quickLookHandle()->didReceiveDataArray(dataArray))
return;
handle->handleDataArray(dataArray);
}
void termite::addSpriteFrameTexture(Sprite* sprite,
ResourceHandle texHandle, bool destroy /*= false*/, const vec2_t pivot /*= vec2_t(0, 0)*/,
const vec2_t topLeftCoords /*= vec2_t(0, 0)*/, const vec2_t bottomRightCoords /*= vec2_t(1.0f, 1.0f)*/,
const char* frameTag /*= nullptr*/)
{
if (texHandle.isValid()) {
assert(getResourceLoadState(texHandle) != ResourceLoadState::LoadInProgress);
SpriteFrame* frame = new(sprite->frames.push()) SpriteFrame();
if (frame) {
frame->texHandle = texHandle;
frame->destroyResource = destroy;
frame->pivot = pivot;
frame->frame = rect_t(topLeftCoords, bottomRightCoords);
frame->tagHash = !frameTag ? 0 : tinystl::hash_string(frameTag, strlen(frameTag)) ;
Texture* tex = getResourcePtr<Texture>(texHandle);
frame->sourceSize = vec2_t(float(tex->info.width), float(tex->info.height));
frame->posOffset = vec2_t(0, 0);
frame->sizeOffset = vec2_t(1.0f, 1.0f);
frame->rotOffset = 0;
frame->pixelRatio = ((bottomRightCoords.x - topLeftCoords.x)*frame->sourceSize.x) /
((bottomRightCoords.y - topLeftCoords.y)*frame->sourceSize.y);
}
}
}
void termite::addSpriteFrameAll(Sprite* sprite, ResourceHandle ssHandle, bool destroy)
{
if (ssHandle.isValid()) {
assert(getResourceLoadState(ssHandle) != ResourceLoadState::LoadInProgress);
SpriteSheet* sheet = getResourcePtr<SpriteSheet>(ssHandle);
SpriteFrame* frames = sprite->frames.pushMany(sheet->numFrames);
for (int i = 0, c = sheet->numFrames; i < c; i++) {
const SpriteSheetFrame& sheetFrame = sheet->frames[i];
SpriteFrame* frame = new(&frames[i]) SpriteFrame();
frame->texHandle = sheet->texHandle;
frame->ssHandle = ssHandle;
frame->nameHash = sheetFrame.filenameHash;
frame->tagHash = 0;
frame->destroyResource = destroy;
frame->pivot = sheetFrame.pivot;
frame->frame = sheetFrame.frame;
frame->sourceSize = sheetFrame.sourceSize;
frame->posOffset = sheetFrame.posOffset;
frame->sizeOffset = sheetFrame.sizeOffset;
frame->rotOffset = sheetFrame.rotOffset;
frame->pixelRatio = sheetFrame.pixelRatio;
}
}
}
/*
* This is being called for each HTTP header in the response. This includes '\r\n'
* for the last line of the header.
*
* We will add each HTTP Header to the ResourceResponse and on the termination
* of the header (\r\n) we will parse Content-Type and Content-Disposition and
* update the ResourceResponse and then send it away.
*
*/
static size_t headerCallback(char* ptr, size_t size, size_t nmemb, void* data)
{
ResourceHandle* job = static_cast<ResourceHandle*>(data);
ResourceHandleInternal* d = job->getInternal();
unsigned int totalSize = size * nmemb;
ResourceHandleClient* client = d->client();
if (!client) {
return totalSize;
}
String header(static_cast<const char*>(ptr), totalSize);
/*
* a) We can finish and send the ResourceResponse
* b) We will add the current header to the HTTPHeaderMap of the ResourceResponse
*/
if (header == String("\r\n")) {
CURL* h = d->m_handle;
CURLcode err;
double contentLength = 0;
err = curl_easy_getinfo(h, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &contentLength);
d->m_response.setExpectedContentLength(static_cast<long long int>(contentLength));
const char* hdr;
err = curl_easy_getinfo(h, CURLINFO_EFFECTIVE_URL, &hdr);
d->m_response.setUrl(KURL(hdr));
long httpCode = 0;
err = curl_easy_getinfo(h, CURLINFO_RESPONSE_CODE, &httpCode);
d->m_response.setHTTPStatusCode(httpCode);
d->m_response.setMimeType(extractMIMETypeFromMediaType(d->m_response.httpHeaderField("Content-Type")));
d->m_response.setTextEncodingName(extractCharsetFromMediaType(d->m_response.httpHeaderField("Content-Type")));
d->m_response.setSuggestedFilename(filenameFromHTTPContentDisposition(d->m_response.httpHeaderField("Content-Disposition")));
client->didReceiveResponse(job, d->m_response);
} else {
int splitPos = header.find(":");
if (splitPos != -1)
d->m_response.setHTTPHeaderField(header.left(splitPos), header.substring(splitPos+1).stripWhiteSpace());
}
return totalSize;
}
void IconLoader::didReceiveResponse(SubresourceLoader* resourceLoader, const ResourceResponse& response)
{
// If we got a status code indicating an invalid response, then lets
// ignore the data and not try to decode the error page as an icon.
int status = response.httpStatusCode();
// SAMSUNG CHANGE : not sending favicon request once 404 not found error received for the favicon.
m_status = response.httpStatusCode();
// SAMSUNG CHANGE
LOG(IconDatabase, "IconLoader::didReceiveResponse() - Loader %p, response %i", resourceLoader, status);
if (status && (status < 200 || status > 299)) {
ResourceHandle* handle = resourceLoader->handle();
finishLoading(handle ? handle->firstRequest().url() : KURL(), 0);
}
}
static void gotChunkCallback(SoupMessage* msg, SoupBuffer* chunk, gpointer data)
{
if (!SOUP_STATUS_IS_SUCCESSFUL(msg->status_code))
return;
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
if (d->m_cancelled)
return;
ResourceHandleClient* client = handle->client();
if (!client)
return;
client->didReceiveData(handle, chunk->data, chunk->length, false);
}
static void didReceiveResponse(CFURLConnectionRef conn, CFURLResponseRef cfResponse, const void* clientInfo)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(const_cast<void*>(clientInfo));
LOG(Network, "CFNet - didReceiveResponse(conn=%p, handle=%p) (%s)", conn, handle, handle->firstRequest().url().string().utf8().data());
if (!handle->client())
return;
#if PLATFORM(MAC)
// Avoid MIME type sniffing if the response comes back as 304 Not Modified.
CFHTTPMessageRef msg = wkGetCFURLResponseHTTPResponse(cfResponse);
int statusCode = msg ? CFHTTPMessageGetResponseStatusCode(msg) : 0;
if (statusCode != 304)
adjustMIMETypeIfNecessary(cfResponse);
#else
if (!CFURLResponseGetMIMEType(cfResponse)) {
// We should never be applying the default MIMEType if we told the networking layer to do content sniffing for handle.
ASSERT(!handle->shouldContentSniff());
setDefaultMIMEType(cfResponse);
}
#endif
handle->setQuickLookHandle(QuickLookHandle::create(handle, conn, cfResponse));
if (handle->quickLookHandle())
cfResponse = handle->quickLookHandle()->cfResponse();
handle->client()->didReceiveResponse(handle, cfResponse);
}
void ResourceHandleManager::slotMimetype(KIO::Job* kioJob, const QString& type)
{
ResourceHandle* job = 0;
// Check if we know about 'kioJob'...
QMap<KIO::Job*, ResourceHandle*>::const_iterator it = m_kioToJobMap.find(kioJob);
if (it != m_kioToJobMap.end())
job = it.value();
if (!job)
return;
ResourceHandleInternal* d = job->getInternal();
if (!d || !d->m_client)
return;
d->m_mimetype = type;
}
/* This is called to obtain HTTP POST or PUT data.
Iterate through FormData elements and upload files.
Carefully respect the given buffer size and fill the rest of the data at the next calls.
*/
size_t readCallback(void* ptr, size_t size, size_t nmemb, void* data)
{
ResourceHandle* job = static_cast<ResourceHandle*>(data);
ResourceHandleInternal* d = job->getInternal();
if (d->m_cancelled)
return 0;
if (!size || !nmemb)
return 0;
size_t sent = d->m_formDataStream.read(ptr, size, nmemb);
// Something went wrong so cancel the job.
if (!sent)
job->cancel();
return sent;
}
static CFURLRequestRef willSendRequest(CFURLConnectionRef conn, CFURLRequestRef cfRequest, CFURLResponseRef cfRedirectResponse, const void* clientInfo)
{
#if LOG_DISABLED
UNUSED_PARAM(conn);
#endif
ResourceHandle* handle = static_cast<ResourceHandle*>(const_cast<void*>(clientInfo));
if (!cfRedirectResponse) {
CFRetain(cfRequest);
return cfRequest;
}
LOG(Network, "CFNet - willSendRequest(conn=%p, handle=%p) (%s)", conn, handle, handle->firstRequest().url().string().utf8().data());
ResourceRequest request;
if (cfRedirectResponse) {
CFHTTPMessageRef httpMessage = CFURLResponseGetHTTPResponse(cfRedirectResponse);
if (httpMessage && CFHTTPMessageGetResponseStatusCode(httpMessage) == 307) {
RetainPtr<CFStringRef> lastHTTPMethod = handle->lastHTTPMethod().createCFString();
RetainPtr<CFStringRef> newMethod = adoptCF(CFURLRequestCopyHTTPRequestMethod(cfRequest));
if (CFStringCompareWithOptions(lastHTTPMethod.get(), newMethod.get(), CFRangeMake(0, CFStringGetLength(lastHTTPMethod.get())), kCFCompareCaseInsensitive)) {
RetainPtr<CFMutableURLRequestRef> mutableRequest(AdoptCF, CFURLRequestCreateMutableCopy(0, cfRequest));
wkSetRequestStorageSession(handle->storageSession(), mutableRequest.get());
CFURLRequestSetHTTPRequestMethod(mutableRequest.get(), lastHTTPMethod.get());
FormData* body = handle->firstRequest().httpBody();
if (!equalIgnoringCase(handle->firstRequest().httpMethod(), "GET") && body && !body->isEmpty())
WebCore::setHTTPBody(mutableRequest.get(), body);
String originalContentType = handle->firstRequest().httpContentType();
if (!originalContentType.isEmpty())
CFURLRequestSetHTTPHeaderFieldValue(mutableRequest.get(), CFSTR("Content-Type"), originalContentType.createCFString().get());
request = mutableRequest.get();
}
}
}
if (request.isNull())
request = cfRequest;
// Should not set Referer after a redirect from a secure resource to non-secure one.
if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https"))
request.clearHTTPReferrer();
handle->willSendRequest(request, cfRedirectResponse);
if (request.isNull())
return 0;
cfRequest = request.cfURLRequest();
CFRetain(cfRequest);
return cfRequest;
}
static void gotHeadersCallback(SoupMessage* msg, gpointer data)
{
if (!SOUP_STATUS_IS_SUCCESSFUL(msg->status_code))
return;
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
if (d->m_cancelled)
return;
ResourceHandleClient* client = handle->client();
if (!client)
return;
fillResponseFromMessage(msg, &d->m_response);
client->didReceiveResponse(handle, d->m_response);
soup_message_set_flags(msg, SOUP_MESSAGE_OVERWRITE_CHUNKS);
}
// called with data after all headers have been processed via headerCallback
static size_t writeCallback(void* ptr, size_t size, size_t nmemb, void* data)
{
ResourceHandle* job = static_cast<ResourceHandle*>(data);
ResourceHandleInternal* d = job->getInternal();
int totalSize = size * nmemb;
// this shouldn't be necessary but apparently is. CURL writes the data
// of html page even if it is a redirect that was handled internally
// can be observed e.g. on gmail.com
CURL* h = d->m_handle;
long httpCode = 0;
CURLcode err = curl_easy_getinfo(h, CURLINFO_RESPONSE_CODE, &httpCode);
if (CURLE_OK == err && httpCode >= 300 && httpCode < 400)
return totalSize;
if (d->client())
d->client()->didReceiveData(job, static_cast<char*>(ptr), totalSize, 0);
return totalSize;
}
CFCachedURLResponseRef willCacheResponse(CFURLConnectionRef conn, CFCachedURLResponseRef cachedResponse, const void* clientInfo)
{
ResourceHandle* handle = (ResourceHandle*)clientInfo;
CacheStoragePolicy policy = static_cast<CacheStoragePolicy>(CFCachedURLResponseGetStoragePolicy(cachedResponse));
if (handle->client())
handle->client()->willCacheResponse(handle, policy);
if (static_cast<CFURLCacheStoragePolicy>(policy) != CFCachedURLResponseGetStoragePolicy(cachedResponse))
cachedResponse = CFCachedURLResponseCreateWithUserInfo(kCFAllocatorDefault,
CFCachedURLResponseGetWrappedResponse(cachedResponse),
CFCachedURLResponseGetReceiverData(cachedResponse),
CFCachedURLResponseGetUserInfo(cachedResponse),
static_cast<CFURLCacheStoragePolicy>(policy));
CFRetain(cachedResponse);
return cachedResponse;
}
// called with data after all headers have been processed via headerCallback
static size_t writeCallback(void* ptr, size_t size, size_t nmemb, void* data)
{
networkCounter.stopCounting();
ResourceHandle* job = static_cast<ResourceHandle*>(data);
ResourceHandleInternal* d = job->getInternal();
if (d->m_cancelled) {
networkCounter.startCounting();
return 0;
}
size_t totalSize = size * nmemb;
// this shouldn't be necessary but apparently is. CURL writes the data
// of html page even if it is a redirect that was handled internally
// can be observed e.g. on gmail.com
CURL* h = d->m_handle;
long httpCode = 0;
CURLcode err = curl_easy_getinfo(h, CURLINFO_RESPONSE_CODE, &httpCode);
if (CURLE_OK == err && httpCode >= 300 && httpCode < 400) {
networkCounter.startCounting();
return totalSize;
}
// since the code in headerCallback will not have run for local files
// the code to set the URL and fire didReceiveResponse is never run,
// which means the ResourceLoader's response does not contain the URL.
// Run the code here for local files to resolve the issue.
// TODO: See if there is a better approach for handling this.
if (!d->m_response.responseFired()) {
const char* hdr;
err = curl_easy_getinfo(h, CURLINFO_EFFECTIVE_URL, &hdr);
d->m_response.setUrl(KURL(hdr));
if (d->client())
d->client()->didReceiveResponse(job, d->m_response);
d->m_response.setResponseFired(true);
}
if (d->client())
d->client()->didReceiveData(job, static_cast<char*>(ptr), totalSize, 0);
networkCounter.startCounting();
return totalSize;
}
void ResourceManager::HandleNextRequest() {
if (m_Stream->CanLoad() && !m_ReqStack.IsEmpty()) {
ResourceLoadReq req = m_ReqStack.GetFront();
ResourceHandle handle = GetResource(req.path);
// Checks if the file has already been loaded into the manager
if (!handle.IsValid()) {
bool res = m_Stream->LoadDataFromFile(req.path, req.type);
if (!res) {
LOG_ERROR("ResourceManager: File \'%s\' could not be found", req.path);
}
}
else {
LOG_ERROR("ResourceManager: File \'%s\' is already loaded", req.path);
}
m_ReqStack.Pop();
}
}
CFURLRequestRef willSendRequest(CFURLConnectionRef conn, CFURLRequestRef cfRequest, CFURLResponseRef cfRedirectResponse, const void* clientInfo)
{
ResourceHandle* handle = (ResourceHandle*)clientInfo;
if (!cfRedirectResponse) {
CFRetain(cfRequest);
return cfRequest;
}
LOG(Network, "CFNet - willSendRequest(conn=%p, handle=%p) (%s)", conn, handle, handle->request().url().string().utf8().data());
ResourceRequest request(cfRequest);
if (handle->client())
handle->client()->willSendRequest(handle, request, cfRedirectResponse);
cfRequest = request.cfURLRequest();
CFRetain(cfRequest);
return cfRequest;
}
// Called each time the message is going to be sent again except the first time.
// It's used mostly to let webkit know about redirects.
static void restartedCallback(SoupMessage* msg, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
if (d->m_cancelled)
return;
char* uri = soup_uri_to_string(soup_message_get_uri(msg), false);
String location = String(uri);
g_free(uri);
KURL newURL = KURL(handle->request().url(), location);
ResourceRequest request = handle->request();
ResourceResponse response;
request.setURL(newURL);
request.setHTTPMethod(msg->method);
fillResponseFromMessage(msg, &response);
// Should not set Referer after a redirect from a secure resource to non-secure one.
if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https")) {
request.clearHTTPReferrer();
soup_message_headers_remove(msg->request_headers, "Referer");
}
if (d->client())
d->client()->willSendRequest(handle, request, response);
if (d->m_cancelled)
return;
#ifdef HAVE_LIBSOUP_2_29_90
// Update the first party in case the base URL changed with the redirect
String firstPartyString = request.firstPartyForCookies().string();
if (!firstPartyString.isEmpty()) {
GOwnPtr<SoupURI> firstParty(soup_uri_new(firstPartyString.utf8().data()));
soup_message_set_first_party(d->m_msg, firstParty.get());
}
#endif
}
// Called each time the message is going to be sent again except the first time.
// It's used mostly to let webkit know about redirects.
static void restartedCallback(SoupMessage* msg, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
if (d->m_cancelled)
return;
char* uri = soup_uri_to_string(soup_message_get_uri(msg), false);
String location = String(uri);
g_free(uri);
KURL newURL = KURL(handle->request().url(), location);
ResourceRequest request = handle->request();
ResourceResponse response;
request.setURL(newURL);
fillResponseFromMessage(msg, &response);
if (d->client())
d->client()->willSendRequest(handle, request, response);
}
void Application::run()
{
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
mWnd = glfwCreateWindow(WIDTH, HEIGHT, "ImaginaryY", nullptr, nullptr);
glfwMakeContextCurrent(mWnd);
glfwSwapInterval(0);
mRenderer.init();
ResourceHandle<ImageAtlas> cs = mResourceManager.getFreeHandle<ImageAtlas>("ComicSans atlas");
cs.get()->create(256, 256, Image::Format::R8);
mComicSansFont.create("ComicSans.ttf", 25, cs);
setupGraphic();
mPlayerHP.create("100", mComicSansFont);
mEnemyHP.create("100", mComicSansFont);
// Setup matrices and other
mPlayer.setPos(glm::vec3(0.0f, 0.0f, 0.0f));
mPlayer.setSpeed(1.5f);
mEnemy.setStartPos(glm::vec3(2.0f, 0.0f, 2.0f));
mEnemy.setSpeed(1.0f);
mCameraPos = glm::vec3(0.0f, 0.0f, 0.0f);
mProjMatrix = glm::perspective(
glm::radians(90.0f), // Fov
WIDTH / static_cast<float>(HEIGHT), // Aspect ratio
1.0f, // Near clip
1000.0f // Far clip
);
mOrthoMatrix = glm::ortho(0.0f, static_cast<float>(WIDTH), 0.0f, static_cast<float>(HEIGHT));
startLoop();
glfwDestroyWindow(mWnd);
}
static CFCachedURLResponseRef willCacheResponse(CFURLConnectionRef, CFCachedURLResponseRef cachedResponse, const void* clientInfo)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(const_cast<void*>(clientInfo));
#if PLATFORM(WIN)
if (handle->client() && !handle->client()->shouldCacheResponse(handle, cachedResponse))
return 0;
#else
CFCachedURLResponseRef newResponse = handle->client()->willCacheResponse(handle, cachedResponse);
if (newResponse != cachedResponse)
return newResponse;
#endif
CacheStoragePolicy policy = static_cast<CacheStoragePolicy>(CFCachedURLResponseGetStoragePolicy(cachedResponse));
if (handle->client())
handle->client()->willCacheResponse(handle, policy);
if (static_cast<CFURLCacheStoragePolicy>(policy) != CFCachedURLResponseGetStoragePolicy(cachedResponse)) {
RetainPtr<CFArrayRef> receiverData(AdoptCF, CFCachedURLResponseCopyReceiverDataArray(cachedResponse));
cachedResponse = CFCachedURLResponseCreateWithDataArray(kCFAllocatorDefault,
CFCachedURLResponseGetWrappedResponse(cachedResponse),
receiverData.get(),
CFCachedURLResponseGetUserInfo(cachedResponse),
static_cast<CFURLCacheStoragePolicy>(policy));
} else
CFRetain(cachedResponse);
return cachedResponse;
}
void ResourceHandleManager::slotResult(KJob* kjob)
{
KIO::Job* kioJob = qobject_cast<KIO::Job*>(kjob);
if (!kioJob)
return;
ResourceHandle* job = 0;
// Check if we know about 'kioJob'...
QMap<KIO::Job*, ResourceHandle*>::const_iterator it = m_kioToJobMap.find(kioJob);
if (it != m_kioToJobMap.end())
job = it.value();
if (!job)
return;
job->setError(kjob->error());
remove(job);
ASSERT(m_frameClient);
m_frameClient->checkLoaded();
}
// Called at the end of the message, with all the necessary about the last informations.
// Doesn't get called for redirects.
static void finishedCallback(SoupSession *session, SoupMessage* msg, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
// TODO: maybe we should run this code even if there's no client?
if (!handle)
return;
ResourceHandleInternal* d = handle->getInternal();
// The message has been handled.
d->m_msg = NULL;
ResourceHandleClient* client = handle->client();
if (!client)
return;
if (d->m_cancelled)
return;
if (SOUP_STATUS_IS_TRANSPORT_ERROR(msg->status_code)) {
char* uri = soup_uri_to_string(soup_message_get_uri(msg), FALSE);
ResourceError error("webkit-network-error", ERROR_TRANSPORT, uri, String::fromUTF8(msg->reason_phrase));
g_free(uri);
client->didFail(handle, error);
return;
} else if (!SOUP_STATUS_IS_SUCCESSFUL(msg->status_code)) {
fillResponseFromMessage(msg, &d->m_response);
client->didReceiveResponse(handle, d->m_response);
// WebCore might have cancelled the job in the while
if (d->m_cancelled)
return;
if (msg->response_body->data)
client->didReceiveData(handle, msg->response_body->data, msg->response_body->length, true);
}
client->didFinishLoading(handle);
}
CURL* curlHandle(const Document* document)
{
if (document == NULL)
return NULL;
DocumentLoader* docLoader = document->loader();
if (docLoader == NULL)
return NULL;
ResourceLoader* resLoader = docLoader->mainResourceLoader();
if (resLoader == NULL)
return NULL;
ResourceHandle* handle = resLoader->handle();
if (handle == NULL)
return NULL;
ResourceHandleInternal* d = handle->getInternal();
if (d == NULL)
return NULL;
return d->m_handle;
}
static GtkWidget* currentToplevelCallback(WebKitSoupAuthDialog* feature, SoupMessage* message, gpointer userData)
{
gpointer messageData = g_object_get_data(G_OBJECT(message), "resourceHandle");
if (!messageData)
return NULL;
ResourceHandle* handle = static_cast<ResourceHandle*>(messageData);
if (!handle)
return NULL;
ResourceHandleInternal* d = handle->getInternal();
if (!d)
return NULL;
WebKit::FrameNetworkingContextGtk* context = static_cast<WebKit::FrameNetworkingContextGtk*>(d->m_context.get());
if (!context)
return NULL;
if (!context->coreFrame())
return NULL;
GtkWidget* toplevel = gtk_widget_get_toplevel(GTK_WIDGET(context->coreFrame()->page()->chrome()->platformPageClient()));
return widgetIsOnscreenToplevelWindow(toplevel) ? toplevel : 0;
}
/*static void webkit_web_view_settings_notify(WebKitWebView* webView, GParamSpec* pspec, gpointer userdata)
{
printf("##########%s:%d (%s)\n", __FILE__, __LINE__, WTF_PRETTY_FUNCTION );
const gchar* name = g_intern_string(pspec->name);
printf("name = %s\n", name);
}*/
static GtkWidget* currentToplevelCallback(WebKitSoupAuthDialog* feature, SoupMessage* message, gpointer userData)
{
gpointer messageData = g_object_get_data(G_OBJECT(message), "resourceHandle");
if (!messageData)
return NULL;
ResourceHandle* handle = static_cast<ResourceHandle*>(messageData);
if (!handle)
return NULL;
ResourceHandleInternal* d = handle->getInternal();
if (!d)
return NULL;
WebCore::Frame* frame = d->m_frame;
if (!frame)
return NULL;
GtkWidget* toplevel = gtk_widget_get_toplevel(GTK_WIDGET(frame->page()->chrome()->platformPageClient()));
if (GTK_WIDGET_TOPLEVEL(toplevel))
return toplevel;
else
return NULL;
}
wxTreeItemId ResourcesPage::addResource(const ResourceHandle& handle)
{
Resource* res = handle.Resolve();
if( !res ) return nullptr;
if( resourceIds.find(res) != resourceIds.end() )
return nullptr;
ResourceGroup group = res->getResourceGroup();
const Path& resPath = res->getPath();
wxTreeItemId id = AppendItem(resGroupIds[group], resPath, 0 );
resourceIds[res] = id;
return id;
}
