void setDataToClipBoard(WTF::String& format , WTF::String& data){
LOGD(" setDataToClipBoard : Enter");
JNIEnv* env = JSC::Bindings::getJNIEnv();
if(env == NULL || format.isEmpty() || data.isEmpty())
return;
jstring jFormat = env->NewString((jchar*) format.characters(), format.length());
jstring jData = env->NewString((jchar*) data.characters(), data.length());
if((m_javaGlueForPasteBoard.object(env).get() == NULL )||(m_javaGlueForPasteBoard.m_setDataToClipBoard == 0 ))
{
LOGD(" setDataToClipBoard : return with out copy");
return;
}
env->CallVoidMethod(m_javaGlueForPasteBoard.object(env).get(),
m_javaGlueForPasteBoard.m_setDataToClipBoard , jFormat , jData);
env->DeleteLocalRef(jFormat);
env->DeleteLocalRef(jData);
checkException(env);
}
void MediaPlayerPrivate::load(const WTF::String& url)
{
WTF::String modifiedUrl(url);
if (modifiedUrl.startsWith("local://")) {
KURL kurl = KURL(KURL(), modifiedUrl);
kurl.setProtocol("file");
WTF::String tempPath(BlackBerry::Platform::Settings::instance()->applicationLocalDirectory().c_str());
tempPath.append(kurl.path());
kurl.setPath(tempPath);
modifiedUrl = kurl.string();
}
if (modifiedUrl.startsWith("file://")) {
// The QNX Multimedia Framework cannot handle filenames containing URL escape sequences.
modifiedUrl = decodeURLEscapeSequences(modifiedUrl);
}
void* tabId = m_webCorePlayer->mediaPlayerClient()->mediaPlayerHostWindow()->platformPageClient();
int playerID = m_webCorePlayer->mediaPlayerClient()->mediaPlayerHostWindow()->platformPageClient()->playerID();
deleteGuardedObject(m_platformPlayer);
#if USE(ACCELERATED_COMPOSITING)
m_platformPlayer = PlatformPlayer::create(this, tabId, true, modifiedUrl.utf8().data());
#else
m_platformPlayer = PlatformPlayer::create(this, tabId, false, modifiedUrl.utf8().data());
#endif
WTF::String cookiePairs;
if (!url.isEmpty())
cookiePairs = cookieManager().getCookie(KURL(ParsedURLString, url.utf8().data()), WithHttpOnlyCookies);
if (!cookiePairs.isEmpty() && cookiePairs.utf8().data())
m_platformPlayer->load(playerID, modifiedUrl.utf8().data(), m_webCorePlayer->userAgent().utf8().data(), cookiePairs.utf8().data());
else
m_platformPlayer->load(playerID, modifiedUrl.utf8().data(), m_webCorePlayer->userAgent().utf8().data(), 0);
}
PassRefPtr<DocumentFragment> Pasteboard::documentFragment(Frame* frame, PassRefPtr<Range> context, bool allowPlainText, bool& chosePlainText)
{
LOGD("documentFragment");
chosePlainText = false;
String dataFormat = "HTML";
String imageFormat = "IMAGE";
String markup;
KURL srcURL;
markup = android::getHTML();
if(!markup.isEmpty()) {
RefPtr<DocumentFragment> fragment =
createFragmentFromMarkup(frame->document(), markup, srcURL, FragmentScriptingNotAllowed);
if (fragment)
return fragment.release();
}
else if (allowPlainText) {
WTF::String markup = android::getText();//ChromiumBridge::clipboardReadPlainText(buffer);
if (!markup.isEmpty()) {
chosePlainText = true;
RefPtr<DocumentFragment> fragment =
createFragmentFromText(context.get(), markup);
if (fragment)
return fragment.release();
}
}
return 0;
}
void QNetworkReplyHandler::sendResponseIfNeeded()
{
ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());
if (m_replyWrapper->reply()->error() && m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).isNull())
return;
ResourceHandleClient* client = m_resourceHandle->client();
if (!client)
return;
WTF::String mimeType = m_replyWrapper->mimeType();
if (mimeType.isEmpty()) {
// let's try to guess from the extension
mimeType = MIMETypeRegistry::getMIMETypeForPath(m_replyWrapper->reply()->url().path());
}
KURL url(m_replyWrapper->reply()->url());
ResourceResponse response(url, mimeType.lower(),
m_replyWrapper->reply()->header(QNetworkRequest::ContentLengthHeader).toLongLong(),
m_replyWrapper->encoding(), String());
if (url.isLocalFile()) {
client->didReceiveResponse(m_resourceHandle, response);
return;
}
// The status code is equal to 0 for protocols not in the HTTP family.
int statusCode = m_replyWrapper->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (url.protocolIsInHTTPFamily()) {
String suggestedFilename = filenameFromHTTPContentDisposition(QString::fromLatin1(m_replyWrapper->reply()->rawHeader("Content-Disposition")));
if (!suggestedFilename.isEmpty())
response.setSuggestedFilename(suggestedFilename);
else {
Vector<String> extensions = MIMETypeRegistry::getExtensionsForMIMEType(mimeType);
if (extensions.isEmpty())
response.setSuggestedFilename(url.lastPathComponent());
else {
// If the suffix doesn't match the MIME type, correct the suffix.
QString filename = url.lastPathComponent();
const String suffix = QMimeDatabase().suffixForFileName(filename);
if (!extensions.contains(suffix)) {
filename.chop(suffix.length());
filename += MIMETypeRegistry::getPreferredExtensionForMIMEType(mimeType);
}
response.setSuggestedFilename(filename);
}
}
response.setHTTPStatusCode(statusCode);
response.setHTTPStatusText(m_replyWrapper->reply()->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray().constData());
// Add remaining headers.
foreach (const QNetworkReply::RawHeaderPair& pair, m_replyWrapper->reply()->rawHeaderPairs())
response.setHTTPHeaderField(QString::fromLatin1(pair.first), QString::fromLatin1(pair.second));
}
MediaPlayer::SupportsType MediaPlayerPrivate::supportsType(const WTF::String& type, const WTF::String& codecs, const KURL& url)
{
bool isRTSP = url.protocolIs("rtsp");
if (!isRTSP && (type.isNull() || type.isEmpty())) {
LOG(Media, "MediaPlayer does not support type; type is null or empty.");
return MediaPlayer::IsNotSupported;
}
// spec says we should not return "probably" if the codecs string is empty
if (isRTSP || PlatformPlayer::mimeTypeSupported(type.ascii().data())) {
LOG(Media, "MediaPlayer supports type %s.", isRTSP ? "rtsp" : type.ascii().data());
return codecs.isEmpty() ? MediaPlayer::MayBeSupported : MediaPlayer::IsSupported;
}
LOG(Media, "MediaPlayer does not support type %s.", type.ascii().data());
return MediaPlayer::IsNotSupported;
}
static WTF::String urlSuitableForTestResult(const WTF::String& uriString)
{
if (uriString.isEmpty() || !uriString.startsWith("file://"))
return uriString;
const size_t index = uriString.reverseFind('/');
return (index == WTF::notFound) ? uriString : uriString.substring(index + 1);
}
bool WebSettings::isSupportedObjectMIMEType(const WTF::String& mimeType)
{
if (mimeType.isEmpty())
return false;
if (!s_supportedObjectMIMETypes)
return false;
return s_supportedObjectMIMETypes->contains(getNormalizedMIMEType(mimeType));
}
/**
* webkit_get_web_database_directory_path:
*
* Returns the current path to the directory WebKit will write Web
* Database databases. By default this path will be in the user data
* directory.
*
* Returns: the current database directory path
*
* Since: 1.1.14
**/
G_CONST_RETURN gchar* webkit_get_web_database_directory_path()
{
#if ENABLE(DATABASE)
WTF::String path = WebCore::DatabaseTracker::tracker().databaseDirectoryPath();
if (path.isEmpty())
return "";
g_free(webkit_database_directory_path);
webkit_database_directory_path = g_strdup(path.utf8().data());
return webkit_database_directory_path;
#else
return "";
#endif
}
/**
* webkit_web_database_get_display_name:
* @webDatabase: a #WebKitWebDatabase
*
* Returns the name of the #WebKitWebDatabase as seen by the user.
*
* Returns: the name of the database as seen by the user.
*
* Since: 1.1.14
**/
G_CONST_RETURN gchar* webkit_web_database_get_display_name(WebKitWebDatabase* webDatabase)
{
g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);
#if ENABLE(DATABASE)
WebKitWebDatabasePrivate* priv = webDatabase->priv;
WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin));
WTF::String displayName = details.displayName();
if (displayName.isEmpty())
return "";
g_free(priv->displayName);
priv->displayName = g_strdup(displayName.utf8().data());
return priv->displayName;
#else
return "";
#endif
}
static void onConsoleMessage(Ewk_View_Smart_Data*, const char* message, unsigned int lineNumber, const char*)
{
// Tests expect only the filename part of local URIs
WTF::String newMessage = message;
if (!newMessage.isEmpty()) {
const size_t fileProtocol = newMessage.find("file://");
if (fileProtocol != WTF::notFound)
newMessage = newMessage.left(fileProtocol) + urlSuitableForTestResult(newMessage.substring(fileProtocol));
}
// Ignore simple translation-related messages and unnecessary messages
if (newMessage.contains("Localized string") || newMessage.contains("Protocol Error: the message is for non-existing domain 'Profiler'"))
return;
printf("CONSOLE MESSAGE: ");
if (lineNumber)
printf("line %u: ", lineNumber);
printf("%s\n", newMessage.utf8().data());
}
/**
* webkit_web_database_get_filename:
* @webDatabase: a #WebKitWebDatabase
*
* Returns the absolute filename to the #WebKitWebDatabase file on disk.
*
* Returns: the absolute filename of the database
*
* Since: 1.1.14
**/
G_CONST_RETURN gchar* webkit_web_database_get_filename(WebKitWebDatabase* webDatabase)
{
g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL);
#if ENABLE(DATABASE)
WebKitWebDatabasePrivate* priv = webDatabase->priv;
WTF::String coreName = WTF::String::fromUTF8(priv->name);
WTF::String corePath = WebCore::DatabaseTracker::tracker().fullPathForDatabase(core(priv->origin), coreName);
if (corePath.isEmpty())
return"";
g_free(priv->filename);
priv->filename = g_strdup(corePath.utf8().data());
return priv->filename;
#else
return "";
#endif
}
const string WebResponse::resolveMimeType(const string& url, const string& old_mime)
{
// Use "text/html" as a default (matching the behaviour of the Apache
// HTTP stack -- see guessMimeType() in LoadListener.java).
string mimeType = old_mime.length() ? old_mime : "text/html";
// Try to guess a better MIME type from the URL. We call
// getMIMETypeForExtension rather than getMIMETypeForPath because the
// latter defaults to "application/octet-stream" on failure.
WebCore::KURL kurl(WebCore::ParsedURLString, url.c_str());
WTF::String path = kurl.path();
size_t extensionPos = path.reverseFind('.');
if (extensionPos != WTF::notFound) {
// We found a file extension.
path.remove(0, extensionPos + 1);
// TODO: Should use content-disposition instead of url if it is there
WTF::String mime = WebCore::MIMETypeRegistry::getMIMETypeForExtension(path);
if (!mime.isEmpty()) {
// Great, we found a MIME type.
mimeType = std::string(mime.utf8().data(), mime.length());
}
}
return mimeType;
}
bool SelectionHandler::findNextString(const WTF::String& searchString)
{
if (searchString.isEmpty()) {
cancelSelection();
return false;
}
ASSERT(m_webPage->m_page);
m_webPage->m_page->unmarkAllTextMatches();
bool result = m_webPage->m_page->findString(searchString, WTF::TextCaseInsensitive, WebCore::FindDirectionForward, true /*should wrap*/);
if (result && m_webPage->focusedOrMainFrame()->selection()->selectionType() == VisibleSelection::NoSelection) {
// Word was found but could not be selected on this page.
result = m_webPage->m_page->markAllMatchesForText(searchString, WTF::TextCaseInsensitive, true /*should highlight*/, 0 /*limit to match 0 = unlimited*/);
}
// Defocus the input field if one is active.
if (m_webPage->m_inputHandler->isInputMode())
m_webPage->m_inputHandler->nodeFocused(0);
return result;
}
void MediaPlayerPrivate::load(const WTF::String& url)
{
WTF::String modifiedUrl(url);
if (modifiedUrl.startsWith("local://")) {
KURL kurl = KURL(KURL(), modifiedUrl);
kurl.setProtocol("file");
WTF::String tempPath(BlackBerry::Platform::Settings::instance()->applicationLocalDirectory().c_str());
tempPath.append(kurl.path());
kurl.setPath(tempPath);
modifiedUrl = kurl.string();
}
// filesystem: URLs refer to entities in the Web File System (WFS) and are
// intended to be useable by HTML 5 media elements directly. Unfortunately
// the loader for our media player is implemented in a separate process and
// does not have access to WFS, so we translate to a file:// URL. Normally
// this would be a security violation, but since the MediaElement has
// already done a security check on the filesystem: URL as part of the
// media resource selection algorithm, we should be OK here.
if (modifiedUrl.startsWith("filesystem:")) {
KURL kurl = KURL(KURL(), modifiedUrl);
KURL mediaURL;
WTF::String fsPath;
FileSystemType fsType;
WebFileSystem::Type type;
// Extract the root and file paths from WFS
DOMFileSystemBase::crackFileSystemURL(kurl, fsType, fsPath);
if (fsType == FileSystemTypeTemporary)
type = WebFileSystem::Temporary;
else
type = WebFileSystem::Persistent;
WTF::String fsRoot = BlackBerry::Platform::WebFileSystem::rootPathForWebFileSystem(type);
// Build a BlackBerry::Platform::SecurityOrigin from the document's
// WebCore::SecurityOrigin and serialize it to build the last
// path component
WebCore::SecurityOrigin* wkOrigin = m_webCorePlayer->mediaPlayerClient()->mediaPlayerOwningDocument()->securityOrigin();
BlackBerry::Platform::SecurityOrigin bbOrigin(wkOrigin->protocol(), wkOrigin->host(), wkOrigin->port());
WTF::String secOrigin(bbOrigin.serialize('_'));
// Build a file:// URL from the path components and extract it to
// a string for further processing
mediaURL.setProtocol("file");
mediaURL.setPath(fsRoot + "/" + secOrigin + "/" + fsPath);
modifiedUrl = mediaURL.string();
} else if (modifiedUrl.startsWith("file://") || modifiedUrl.startsWith("data:")) {
// The QNX Multimedia Framework cannot handle filenames or data containing URL escape sequences.
modifiedUrl = decodeURLEscapeSequences(modifiedUrl);
}
void* tabId = m_webCorePlayer->mediaPlayerClient()->mediaPlayerHostWindow()->platformPageClient();
int playerID = m_webCorePlayer->mediaPlayerClient()->mediaPlayerHostWindow()->platformPageClient()->playerID();
bool isVideo = m_webCorePlayer->mediaPlayerClient()->mediaPlayerIsVideo();
deleteGuardedObject(m_platformPlayer);
#if USE(ACCELERATED_COMPOSITING)
m_platformPlayer = PlatformPlayer::create(this, tabId, isVideo, true, modifiedUrl);
#else
m_platformPlayer = PlatformPlayer::create(this, tabId, isVideo, false, modifiedUrl);
#endif
WTF::String cookiePairs;
if (!url.isEmpty())
cookiePairs = cookieManager().getCookie(KURL(ParsedURLString, url), WithHttpOnlyCookies);
m_platformPlayer->load(playerID, modifiedUrl, m_webCorePlayer->userAgent(), cookiePairs);
}
static void writeItem(WTF::Vector<char>& vector, WebCore::HistoryItem* item)
{
// Original url
writeString(vector, item->originalURLString());
// Url
writeString(vector, item->urlString());
// Title
writeString(vector, item->title());
// Form content type
writeString(vector, item->formContentType());
// Form data
const WebCore::FormData* formData = item->formData();
if (formData) {
WTF::String flattenedFormData = formData->flattenToString();
writeString(vector, flattenedFormData);
if (!flattenedFormData.isEmpty()) {
// save the identifier as it is not included in the flatten data
int64_t id = formData->identifier();
vector.append((char*)&id, sizeof(int64_t));
}
} else
writeString(vector, WTF::String()); // Empty constructor does not allocate a buffer.
// Target
writeString(vector, item->target());
AndroidWebHistoryBridge* bridge = item->bridge();
ALOG_ASSERT(bridge, "We should have a bridge here!");
// Screen scale
const float scale = bridge->scale();
ALOGV("Writing scale %f", scale);
vector.append((char*)&scale, sizeof(float));
const float textWrapScale = bridge->textWrapScale();
ALOGV("Writing text wrap scale %f", textWrapScale);
vector.append((char*)&textWrapScale, sizeof(float));
// Scroll position.
const int scrollX = item->scrollPoint().x();
vector.append((char*)&scrollX, sizeof(int));
const int scrollY = item->scrollPoint().y();
vector.append((char*)&scrollY, sizeof(int));
// Document state
const WTF::Vector<WTF::String>& docState = item->documentState();
WTF::Vector<WTF::String>::const_iterator end = docState.end();
unsigned stateSize = docState.size();
ALOGV("Writing docState %d", stateSize);
vector.append((char*)&stateSize, sizeof(unsigned));
for (WTF::Vector<WTF::String>::const_iterator i = docState.begin(); i != end; ++i) {
writeString(vector, *i);
}
// Is target item
ALOGV("Writing isTargetItem %d", item->isTargetItem());
vector.append((char)item->isTargetItem());
// Children count
unsigned childCount = item->children().size();
ALOGV("Writing childCount %d", childCount);
vector.append((char*)&childCount, sizeof(unsigned));
}
void QNetworkReplyHandler::sendResponseIfNeeded()
{
m_shouldSendResponse = (m_loadMode != LoadNormal);
if (m_shouldSendResponse)
return;
if (m_reply->error() && !ignoreHttpError(m_reply, m_responseDataSent))
return;
if (m_responseSent || !m_resourceHandle)
return;
m_responseSent = true;
ResourceHandleClient* client = m_resourceHandle->client();
if (!client)
return;
WTF::String contentType = m_reply->header(QNetworkRequest::ContentTypeHeader).toString();
WTF::String encoding = extractCharsetFromMediaType(contentType);
WTF::String mimeType = extractMIMETypeFromMediaType(contentType);
if (mimeType.isEmpty()) {
// let's try to guess from the extension
QString extension = m_reply->url().path();
int index = extension.lastIndexOf(QLatin1Char('.'));
if (index > 0) {
extension = extension.mid(index + 1);
mimeType = MIMETypeRegistry::getMIMETypeForExtension(extension);
}
}
KURL url(m_reply->url());
ResourceResponse response(url, mimeType.lower(),
m_reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(),
encoding, String());
if (url.isLocalFile()) {
client->didReceiveResponse(m_resourceHandle, response);
return;
}
// The status code is equal to 0 for protocols not in the HTTP family.
int statusCode = m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (url.protocolInHTTPFamily()) {
String suggestedFilename = filenameFromHTTPContentDisposition(QString::fromAscii(m_reply->rawHeader("Content-Disposition")));
if (!suggestedFilename.isEmpty())
response.setSuggestedFilename(suggestedFilename);
else
response.setSuggestedFilename(url.lastPathComponent());
response.setHTTPStatusCode(statusCode);
response.setHTTPStatusText(m_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray().constData());
// Add remaining headers.
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
foreach (const QNetworkReply::RawHeaderPair& pair, m_reply->rawHeaderPairs()) {
response.setHTTPHeaderField(QString::fromAscii(pair.first), QString::fromAscii(pair.second));
}
#else
foreach (const QByteArray& headerName, m_reply->rawHeaderList()) {
response.setHTTPHeaderField(QString::fromAscii(headerName), QString::fromAscii(m_reply->rawHeader(headerName)));
}
#endif
}