void WebUrlLoaderClient::cancelSslCertError(int cert_error)
{
base::Thread* thread = ioThread();
if (isActive() && thread && !m_request->isFinished() )
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::cancelSslCertError, cert_error));
this->Release();
}
void WebUrlLoaderClient::sslClientCert(EVP_PKEY* pkey, net::X509Certificate* chain)
{
base::Thread* thread = ioThread();
scoped_refptr<net::X509Certificate> scopedChain(chain);
if (isActive() && thread)
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::sslClientCert, pkey, scopedChain));
this->Release();
}
void WebUrlLoaderClient::pauseLoad(bool pause)
{
if (!isActive())
return;
base::Thread* thread = ioThread();
if (thread)
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::pauseLoad, pause));
}
bool WebUrlLoaderClient::start(bool isMainResource, bool isMainFrame, bool sync, WebRequestContext* context)
{
base::Thread* thread = ioThread();
if (!thread) {
return false;
}
m_isMainResource = isMainResource;
m_isMainFrame = isMainFrame;
m_sync = sync;
if (m_sync) {
AutoLock autoLock(*syncLock());
m_request->setSync(sync);
m_request->setRequestContext(context);
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::start));
// Run callbacks until the queue is exhausted and m_finished is true.
// Sometimes, a sync load can wait forever and lock up the WebCore thread,
// here we use TimedWait() with multiple tries to avoid locking.
const int kMaxNumTimeout = 3;
const int kCallbackWaitingTime = 10;
int num_timeout = 0;
while(!m_finished) {
while (!m_queue.empty()) {
OwnPtr<Task> task(m_queue.front());
m_queue.pop_front();
task->Run();
}
if (m_finished) break;
syncCondition()->TimedWait(base::TimeDelta::FromSeconds(kCallbackWaitingTime));
if (m_queue.empty()) {
ALOGE("Synchronous request timed out after %d seconds for the %dth try, URL: %s",
kCallbackWaitingTime, num_timeout, m_request->getUrl().c_str());
num_timeout++;
if (num_timeout >= kMaxNumTimeout) {
cancel();
m_resourceHandle = 0;
return false;
}
}
}
// This may be the last reference to us, so we may be deleted now.
// Don't access any more member variables after releasing this reference.
m_resourceHandle = 0;
} else {
// Asynchronous start.
// Important to set this before the thread starts so it has a reference and can't be deleted
// before the task starts running on the IO thread.
m_request->setRequestContext(context);
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::start));
}
return true;
}
void WebUrlLoaderClient::cancelAuth()
{
if (!isActive())
return;
base::Thread* thread = ioThread();
if (!thread) {
return;
}
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::cancelAuth));
}
void WebUrlLoaderClient::cancel()
{
if (!isActive())
return;
m_cancelling = true;
base::Thread* thread = ioThread();
if (thread)
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::cancel));
}
void WebUrlLoaderClient::setAuth(const std::string& username, const std::string& password)
{
if (!isActive())
return;
base::Thread* thread = ioThread();
if (!thread) {
return;
}
string16 username16 = ASCIIToUTF16(username);
string16 password16 = ASCIIToUTF16(password);
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::setAuth, username16, password16));
}
void WebUrlLoaderClient::willSendRequest(PassOwnPtr<WebResponse> webResponse)
{
if (!isActive())
return;
KURL url = webResponse->createKurl();
OwnPtr<WebCore::ResourceRequest> resourceRequest(new WebCore::ResourceRequest(url));
m_resourceHandle->client()->willSendRequest(m_resourceHandle.get(), *resourceRequest, webResponse->createResourceResponse());
// WebKit may have killed the request.
if (!isActive())
return;
// Like Chrome, we only follow the redirect if WebKit left the URL unmodified.
if (url == resourceRequest->url()) {
ioThread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::followDeferredRedirect));
} else {
cancel();
}
}
int main(int argc, char *argv[]) {
boost::asio::io_service ioService;
std::unique_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(ioService));
std::thread ioThread([&] () {
ioService.run();
});
for (int i=0; i<1000; i++) {
std::shared_ptr<std::promise<bool>> prom(new std::promise<bool>());
std::future<bool> fut = prom->get_future();
ioService.post([prom]() {
prom->set_value(true);
});
assert(fut.get());
}
work.reset();
ioThread.join();
}
AsyncFileWriter::AsyncFileWriter(folly::File&& file)
: file_{std::move(file)}, ioThread_([this] { ioThread(); }) {}
WebUrlLoaderClient::WebUrlLoaderClient(WebFrame* webFrame, WebCore::ResourceHandle* resourceHandle, const WebCore::ResourceRequest& resourceRequest)
: m_webFrame(webFrame)
, m_resourceHandle(resourceHandle)
, m_isMainResource(false)
, m_isMainFrame(false)
, m_isCertMimeType(false)
, m_cancelling(false)
, m_sync(false)
, m_finished(false)
{
m_webFrame->ref();
bool block = webFrame->blockNetworkLoads() && (resourceRequest.url().protocolIs("http") || resourceRequest.url().protocolIs("https"));
WebResourceRequest webResourceRequest(resourceRequest, block);
UrlInterceptResponse* intercept = webFrame->shouldInterceptRequest(resourceRequest.url().string());
if (intercept) {
m_request = new WebRequest(this, webResourceRequest, intercept);
return;
}
m_request = new WebRequest(this, webResourceRequest);
// Set uploads before start is called on the request
if (resourceRequest.httpBody() && !(webResourceRequest.method() == "GET" || webResourceRequest.method() == "HEAD")) {
Vector<FormDataElement>::iterator iter;
Vector<FormDataElement> elements = resourceRequest.httpBody()->elements();
for (iter = elements.begin(); iter != elements.end(); iter++) {
FormDataElement element = *iter;
switch (element.m_type) {
case FormDataElement::data:
if (!element.m_data.isEmpty()) {
// WebKit sometimes gives up empty data to append. These aren't
// necessary so we just optimize those out here.
base::Thread* thread = ioThread();
if (thread) {
Vector<char>* data = new Vector<char>(element.m_data);
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::appendBytesToUpload, data));
}
}
break;
case FormDataElement::encodedFile:
{
// Chromium check if it is a directory by checking
// element.m_fileLength, that doesn't work in Android
std::string filename = element.m_filename.utf8().data();
if (filename.size()) {
// Change from a url string to a filename
if (filename.find("file://") == 0) // Found at pos 0
filename.erase(0, 7);
base::Thread* thread = ioThread();
if (thread)
thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(m_request.get(), &WebRequest::appendFileToUpload, filename));
}
}
break;
#if ENABLE(BLOB)
case FormDataElement::encodedBlob:
ALOG_ASSERT(false, "Unexpected use of FormDataElement::encodedBlob");
break;
#endif // ENABLE(BLOB)
default:
ALOG_ASSERT(false, "Unexpected default case in WebUrlLoaderClient.cpp");
break;
}
}
}
}
