Ewk_History_Item* ewk_history_item_new(const char* uri, const char* title)
{
WTF::String historyUri = WTF::String::fromUTF8(uri);
WTF::String historyTitle = WTF::String::fromUTF8(title);
WTF::RefPtr<WebCore::HistoryItem> core = WebCore::HistoryItem::create(historyUri, historyTitle, 0);
Ewk_History_Item* item = ewk_history_item_new_from_core(core.release().leakRef());
return item;
}
/**
* Create a new history item with given URI and title.
*
* @param uri where this resource is located.
* @param title resource title.
*
* @return newly allocated history item or @c NULL on errors. You must
* free this item with ewk_history_item_free().
*/
Ewk_History_Item* ewk_history_item_new(const char* uri, const char* title)
{
WTF::String u = WTF::String::fromUTF8(uri);
WTF::String t = WTF::String::fromUTF8(title);
WTF::RefPtr<WebCore::HistoryItem> core = WebCore::HistoryItem::create(u, t, 0);
Ewk_History_Item* item = _ewk_history_item_new(core.release().releaseRef());
return item;
}
WebCore::HistoryItem* WebKit::core(WebKitWebHistoryItem* webHistoryItem)
{
g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), NULL);
WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
WTF::RefPtr<WebCore::HistoryItem> historyItem = priv->historyItem;
return historyItem ? historyItem.get() : 0;
}
void Database::runTransaction(RefPtr<SQLTransactionCallback>&& callback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<VoidCallback>&& successCallback, bool readOnly, const ChangeVersionData* changeVersionData)
{
RefPtr<SQLTransaction> transaction = SQLTransaction::create(*this, WTF::move(callback), WTF::move(successCallback), errorCallback.copyRef(), readOnly);
RefPtr<SQLTransactionBackend> transactionBackend = runTransaction(transaction.release(), readOnly, changeVersionData);
if (!transactionBackend && errorCallback) {
WTF::RefPtr<SQLTransactionErrorCallback> errorCallbackProtector = WTF::move(errorCallback);
m_scriptExecutionContext->postTask([errorCallbackProtector](ScriptExecutionContext&) {
errorCallbackProtector->handleEvent(SQLError::create(SQLError::UNKNOWN_ERR, "database has been closed").get());
});
}
}
BaseSamplerNode* SamplerApollo::getSamplerNode(uint64_t identifier)
{
// cache the result
if (m_cachedSearchNode.get() && m_cachedSearchNode->identifier() == identifier)
return m_cachedSearchNode.get();
WTF::RefPtr<BaseSamplerNode> node = m_liveNodesByIdentifier.get(identifier);
if (!node.get())
node = m_deadNodesByIdentifier.get(identifier);
m_cachedSearchNode = node.get();
return node.get();
}
WebDOMRange* wxWebKitSelection::GetAsRange()
{
if (m_selection) {
WTF::RefPtr<WebCore::Range> range = m_selection->toNormalizedRange();
// keep it alive until it reaches wxWebKitDOMRange, which takes ownership
if (range) {
range->ref();
return new WebDOMRange(range.get());
}
}
return 0;
}
bool SecurityOrigin::canRequest(const KUrl& url) const
{
if (isUnique())
return false;
WTF::RefPtr<SecurityOrigin> targetOrigin = SecurityOrigin::create(url);
if (targetOrigin->isUnique())
return false;
// We call isSameSchemeHostPort here instead of canAccess because we want
// to ignore document.domain effects.
if (isSameSchemeHostPort(targetOrigin.get()))
return true;
return false;
}
UndoStepQt::UndoStepQt(WTF::RefPtr<UndoStep> step, QUndoCommand *parent)
: QUndoCommand(parent)
, m_step(step)
, m_first(true)
{
setText(undoNameForEditAction(step->editingAction()));
}
WTF::PassRefPtr<WebDebugListenerImpl> WebDebugListenerImpl::getInstance()
{
static bool preventSecondTry = false;
static WTF::RefPtr<WebDebugListenerImpl> htmlDebugListener;
if (!preventSecondTry && !htmlDebugListener.get()) {
preventSecondTry = true;
ASSERT(WebKitApollo::g_HostFunctions->getWebDebugListener);
WebDebugListener * debugger = WebKitApollo::g_HostFunctions->getWebDebugListener();
if (debugger) {
// debugger might be 0 when it's not activated;
htmlDebugListener = new WebDebugListenerImpl( debugger );
}
}
return htmlDebugListener.get();
}
void QQuickNetworkReply::send()
{
if (m_data.isNull())
return;
uint64_t smLength = 0;
const void* ptrData = 0;
QString stringData;
QByteArray byteArrayData;
if (m_data.type() == QVariant::String) {
stringData = m_data.toString();
ptrData = reinterpret_cast<const void*>(stringData.constData());
smLength = sizeof(QChar) * stringData.length();
setContentType(QLatin1String("text/html; charset=utf-16"));
} else {
if (!m_data.canConvert<QByteArray>())
return;
byteArrayData = m_data.toByteArray();
ptrData = byteArrayData.data();
smLength = byteArrayData.size();
}
if (contentType().isEmpty()) {
qWarning("QQuickNetworkReply::send - Cannot send raw data without a content type being specified!");
return;
}
WTF::RefPtr<WebKit::SharedMemory> sharedMemory = SharedMemory::create(smLength);
if (!sharedMemory)
return;
// The size of the allocated shared memory can be bigger than requested.
// Usually the size will be rounded up to the next multiple of a page size.
memcpy(sharedMemory->data(), ptrData, smLength);
if (sharedMemory->createHandle(m_networkReplyData->data().m_dataHandle, SharedMemory::ReadOnly)) {
m_networkReplyData->data().m_contentLength = smLength;
if (m_webViewExperimental)
m_webViewExperimental.data()->sendApplicationSchemeReply(this);
}
// After sending the reply data, we have to reinitialize the m_networkReplyData,
// to make sure we have a fresh SharesMemory::Handle.
m_networkReplyData = adoptRef(new WebKit::QtRefCountedNetworkReplyData);
}
void QQuickNetworkReply::send()
{
if (m_data.isNull())
return;
uint64_t smLength = 0;
const void* ptrData = 0;
QString stringData;
QByteArray byteArrayData;
if (m_data.type() == QVariant::String) {
stringData = m_data.toString();
ptrData = reinterpret_cast<const void*>(stringData.constData());
smLength = sizeof(QChar) * stringData.length();
} else {
if (!m_data.canConvert<QByteArray>())
return;
byteArrayData = m_data.toByteArray();
ptrData = byteArrayData.data();
smLength = byteArrayData.size();
}
WTF::RefPtr<WebKit::SharedMemory> sharedMemory = SharedMemory::create(smLength);
if (!sharedMemory)
return;
// The size of the allocated shared memory can be bigger than requested.
// Usually the size will be rounded up to the next multiple of a page size.
memcpy(sharedMemory->data(), ptrData, smLength);
if (sharedMemory->createHandle(m_networkReplyData->data().m_dataHandle, SharedMemory::ReadOnly)) {
m_networkReplyData->data().m_contentLength = smLength;
QObject* schemeParent = parent()->parent();
if (schemeParent) {
QQuickWebViewExperimental* webViewExperimental = qobject_cast<QQuickWebViewExperimental*>(schemeParent->parent());
if (webViewExperimental)
webViewExperimental->sendApplicationSchemeReply(this);
}
}
// After sending the reply data, we have to reinitialize the m_networkReplyData,
// to make sure we have a fresh SharesMemory::Handle.
m_networkReplyData = adoptRef(new WebKit::QtRefCountedNetworkReplyData);
}
void DumpRenderTreeSupportEfl::evaluateScriptInIsolatedWorld(const Evas_Object* ewkFrame, int worldID, JSObjectRef globalObject, const String& script)
{
WebCore::Frame* coreFrame = EWKPrivate::coreFrame(ewkFrame);
if (!coreFrame)
return;
// Comment from mac: Start off with some guess at a frame and a global object, we'll try to do better...!
WebCore::JSDOMWindow* anyWorldGlobalObject = coreFrame->script()->globalObject(WebCore::mainThreadNormalWorld());
// Comment from mac: The global object is probably a shell object? - if so, we know how to use this!
JSC::JSObject* globalObjectObj = toJS(globalObject);
if (!strcmp(globalObjectObj->classInfo()->className, "JSDOMWindowShell"))
anyWorldGlobalObject = static_cast<WebCore::JSDOMWindowShell*>(globalObjectObj)->window();
// Comment from mac: Get the frame from the global object we've settled on.
WebCore::Frame* globalFrame = anyWorldGlobalObject->impl()->frame();
if (!globalFrame)
return;
WebCore::ScriptController* proxy = globalFrame->script();
if (!proxy)
return;
static WTF::HashMap<int, WTF::RefPtr<WebCore::DOMWrapperWorld > > worldMap;
WTF::RefPtr<WebCore::DOMWrapperWorld> scriptWorld;
if (!worldID)
scriptWorld = WebCore::ScriptController::createWorld();
else {
WTF::HashMap<int, RefPtr<WebCore::DOMWrapperWorld > >::const_iterator it = worldMap.find(worldID);
if (it != worldMap.end())
scriptWorld = (*it).second;
else {
scriptWorld = WebCore::ScriptController::createWorld();
worldMap.set(worldID, scriptWorld);
}
}
// The code below is only valid for JSC, V8 specific code is to be added
// when V8 will be supported in EFL port. See Qt implemenation.
proxy->executeScriptInWorld(scriptWorld.get(), script, true);
}
static void unit_test()
{
LOGD("Entering history unit test!");
const char* test1 = new char[0];
WTF::RefPtr<WebCore::HistoryItem> item = WebCore::HistoryItem::create();
WebCore::HistoryItem* testItem = item.get();
testItem->setBridge(new WebHistoryItem(0));
LOG_ASSERT(!read_item_recursive(testItem, &test1, 0), "0 length array should fail!");
delete[] test1;
const char* test2 = new char[2];
LOG_ASSERT(!read_item_recursive(testItem, &test2, 2), "Small array should fail!");
delete[] test2;
LOG_ASSERT(!read_item_recursive(testItem, NULL, HISTORY_MIN_SIZE), "Null data should fail!");
// Original Url
char* test3 = new char[HISTORY_MIN_SIZE];
const char* ptr = (const char*)test3;
memset(test3, 0, HISTORY_MIN_SIZE);
*(int*)test3 = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length originalUrl should fail!");
// Url
int offset = 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length url should fail!");
// Title
offset += 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length title should fail!");
// Form content type
offset += 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length contentType should fail!");
// Form data
offset += 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length form data should fail!");
// Target
offset += 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length target should fail!");
offset += 4; // Scale
// Document state
offset += 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 length document state should fail!");
// Is target item
offset += 1;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(char*)(test3 + offset) = '!';
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "IsTargetItem should fail with ! as the value!");
// Child count
offset += 4;
memset(test3, 0, HISTORY_MIN_SIZE);
ptr = (const char*)test3;
*(int*)(test3 + offset) = 4000;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE), "4000 kids should fail!");
offset = 36;
// Test document state
delete[] test3;
test3 = new char[HISTORY_MIN_SIZE + sizeof(unsigned)];
memset(test3, 0, HISTORY_MIN_SIZE + sizeof(unsigned));
ptr = (const char*)test3;
*(int*)(test3 + offset) = 1;
*(int*)(test3 + offset + 4) = 20;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE + sizeof(unsigned)), "1 20 length document state string should fail!");
delete[] test3;
test3 = new char[HISTORY_MIN_SIZE + 2 * sizeof(unsigned)];
memset(test3, 0, HISTORY_MIN_SIZE + 2 * sizeof(unsigned));
ptr = (const char*)test3;
*(int*)(test3 + offset) = 2;
*(int*)(test3 + offset + 4) = 0;
*(int*)(test3 + offset + 8) = 20;
LOG_ASSERT(!read_item_recursive(testItem, &ptr, HISTORY_MIN_SIZE + 2 * sizeof(unsigned) ), "2 20 length document state string should fail!");
delete[] test3;
}
UndoStepQt::UndoStepQt(WTF::RefPtr<UndoStep> step)
: m_step(step)
, m_first(true)
{
m_text = undoNameForEditAction(step->editingAction());
}
static bool readItemRecursive(WebCore::HistoryItem* newItem,
const char** pData, int length)
{
if (!pData || length < HISTORY_MIN_SIZE) {
ALOGW("readItemRecursive() bad params; pData=%p length=%d", pData, length);
return false;
}
const char* data = *pData;
const char* end = data + length;
String content;
// Read the original url
if (readString(data, end, content, "Original url"))
newItem->setOriginalURLString(content);
else
return false;
// Read the url
if (readString(data, end, content, "Url"))
newItem->setURLString(content);
else
return false;
// Read the title
if (readString(data, end, content, "Title"))
newItem->setTitle(content);
else
return false;
// Generate a new ResourceRequest object for populating form information.
// Read the form content type
WTF::String formContentType;
if (!readString(data, end, formContentType, "Content type"))
return false;
// Read the form data size
unsigned formDataSize;
if (!readUnsigned(data, end, formDataSize, "Form data size"))
return false;
// Read the form data
WTF::RefPtr<WebCore::FormData> formData;
if (formDataSize) {
ALOGV("Reading Form data %d %.*s", formDataSize, formDataSize, data);
if ((end < data) || ((size_t)(end - data) < formDataSize)) {
ALOGW("\tNot enough data to read form data; returning");
return false;
}
formData = WebCore::FormData::create(data, formDataSize);
data += formDataSize;
// Read the identifier
int64_t id;
if (!readInt64(data, end, id, "Form id"))
return false;
if (id)
formData->setIdentifier(id);
}
// Set up the form info
if (formData != NULL) {
WebCore::ResourceRequest r;
r.setHTTPMethod("POST");
r.setHTTPContentType(formContentType);
r.setHTTPBody(formData);
newItem->setFormInfoFromRequest(r);
}
// Read the target
if (readString(data, end, content, "Target"))
newItem->setTarget(content);
else
return false;
AndroidWebHistoryBridge* bridge = newItem->bridge();
ALOG_ASSERT(bridge, "There should be a bridge object during inflate");
// Read the screen scale
float fValue;
if (readFloat(data, end, fValue, "Screen scale"))
bridge->setScale(fValue);
else
return false;
// Read the text wrap scale
if (readFloat(data, end, fValue, "Text wrap scale"))
bridge->setTextWrapScale(fValue);
else
return false;
// Read scroll position.
int scrollX;
if (!readInt(data, end, scrollX, "Scroll pos x"))
return false;
int scrollY;
if (!readInt(data, end, scrollY, "Scroll pos y"))
return false;
newItem->setScrollPoint(IntPoint(scrollX, scrollY));
// Read the document state
unsigned docStateCount;
if (!readUnsigned(data, end, docStateCount, "Doc state count"))
return false;
if (docStateCount) {
// Create a new vector and reserve enough space for the document state.
WTF::Vector<WTF::String> docState;
docState.reserveCapacity(docStateCount);
while (docStateCount--) {
// Read a document state string
if (readString(data, end, content, "Document state"))
docState.append(content);
else
return false;
}
newItem->setDocumentState(docState);
}
// Read is target item
bool c;
if (readBool(data, end, c, "Target item"))
newItem->setIsTargetItem(c);
else
return false;
// Read the child count
unsigned count;
if (!readUnsigned(data, end, count, "Child count"))
return false;
*pData = data;
if (count) {
while (count--) {
// No need to check the length each time because read_item_recursive
// will return null if there isn't enough data left to parse.
WTF::RefPtr<WebCore::HistoryItem> child = WebCore::HistoryItem::create();
// Set a bridge that will not call into java.
child->setBridge(new WebHistoryItem(static_cast<WebHistoryItem*>(bridge)));
// Read the child item.
if (!readItemRecursive(child.get(), pData, end - data))
return false;
child->bridge()->setActive();
newItem->addChildItem(child);
}
}
return true;
}