bool WebPageSerializerImpl::serialize()
{
if (!m_framesCollected)
collectTargetFrames();
bool didSerialization = false;
KURL mainURL = m_specifiedWebLocalFrameImpl->frame()->document()->url();
for (unsigned i = 0; i < m_frames.size(); ++i) {
WebLocalFrameImpl* webFrame = m_frames[i];
Document* document = webFrame->frame()->document();
const KURL& url = document->url();
if (!url.isValid() || !m_localLinks.contains(url.string()))
continue;
didSerialization = true;
const WTF::TextEncoding& textEncoding = document->encoding().isValid() ? document->encoding() : UTF8Encoding();
String directoryName = url == mainURL ? m_localDirectoryName : "";
SerializeDomParam param(url, textEncoding, document, directoryName);
Element* documentElement = document->documentElement();
if (documentElement)
buildContentForNode(documentElement, ¶m);
encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, ¶m, ForceFlush);
}
ASSERT(m_dataBuffer.isEmpty());
m_client->didSerializeDataForFrame(KURL(), WebCString("", 0), WebPageSerializerClient::AllFramesAreFinished);
return didSerialization;
}
bool WebPageSerializerImpl::serialize()
{
bool didSerialization = false;
KURL mainURL = m_specifiedWebLocalFrameImpl->frame()->document()->url();
WebLocalFrameImpl* webFrame = m_specifiedWebLocalFrameImpl;
Document* document = webFrame->frame()->document();
const KURL& url = document->url();
if (url.isValid() && m_localLinks.contains(url.string())) {
didSerialization = true;
const WTF::TextEncoding& textEncoding = document->encoding().isValid() ? document->encoding() : UTF8Encoding();
String directoryName = url == mainURL ? m_localDirectoryName : "";
SerializeDomParam param(url, textEncoding, document, directoryName);
Element* documentElement = document->documentElement();
if (documentElement)
buildContentForNode(documentElement, ¶m);
encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, ¶m, ForceFlush);
} else {
// Report empty contents for invalid URLs.
m_client->didSerializeDataForFrame(
url, WebCString(),
WebPageSerializerClient::CurrentFrameIsFinished);
}
ASSERT(m_dataBuffer.isEmpty());
return didSerialization;
}
bool WebFrameSerializerImpl::serialize()
{
bool didSerialization = false;
Document* document = m_specifiedWebLocalFrameImpl->frame()->document();
const KURL& url = document->url();
if (url.isValid()) {
didSerialization = true;
const WTF::TextEncoding& textEncoding = document->encoding().isValid() ? document->encoding() : UTF8Encoding();
if (textEncoding.isNonByteBasedEncoding()) {
const UChar byteOrderMark = 0xFEFF;
m_dataBuffer.append(byteOrderMark);
}
SerializeDomParam param(url, textEncoding, document);
Element* documentElement = document->documentElement();
if (documentElement)
buildContentForNode(documentElement, ¶m);
encodeAndFlushBuffer(WebFrameSerializerClient::CurrentFrameIsFinished, ¶m, ForceFlush);
} else {
// Report empty contents for invalid URLs.
m_client->didSerializeDataForFrame(
WebCString(), WebFrameSerializerClient::CurrentFrameIsFinished);
}
DCHECK(m_dataBuffer.isEmpty());
return didSerialization;
}
bool WebPageSerializerImpl::serialize()
{
// Collect target frames.
if (!m_framesCollected)
collectTargetFrames();
bool didSerialization = false;
// Get KURL for main frame.
KURL mainPageURL = m_specifiedWebFrameImpl->frame()->loader()->url();
// Go through all frames for serializing DOM for whole page, include
// sub-frames.
for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) {
// Get current serializing frame.
WebFrameImpl* currentFrame = m_frames[i];
// Get current using document.
Document* currentDoc = currentFrame->frame()->document();
// Get current frame's URL.
const KURL& currentFrameURL = currentFrame->frame()->loader()->url();
// Check whether we have done this document.
if (currentFrameURL.isValid() && m_localLinks.contains(currentFrameURL.string())) {
// A new document, we will serialize it.
didSerialization = true;
// Get target encoding for current document.
String encoding = currentFrame->frame()->loader()->writer()->encoding();
// Create the text encoding object with target encoding.
TextEncoding textEncoding(encoding);
// Construct serialize parameter for late processing document.
SerializeDomParam param(currentFrameURL,
encoding.length() ? textEncoding : UTF8Encoding(),
currentDoc,
currentFrameURL == mainPageURL ? m_localDirectoryName : "");
// Process current document.
Element* rootElement = currentDoc->documentElement();
if (rootElement)
buildContentForNode(rootElement, ¶m);
// Flush the remainder data and finish serializing current frame.
encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished,
¶m,
1);
}
}
// We have done call frames, so we send message to embedder to tell it that
// frames are finished serializing.
ASSERT(m_dataBuffer.isEmpty());
m_client->didSerializeDataForFrame(KURL(),
WebCString("", 0),
WebPageSerializerClient::AllFramesAreFinished);
return didSerialization;
}
void WebFrameSerializerImpl::encodeAndFlushBuffer(
WebFrameSerializerClient::FrameSerializationStatus status,
SerializeDomParam* param,
FlushOption flushOption)
{
// Data buffer is not full nor do we want to force flush.
if (flushOption != ForceFlush && m_dataBuffer.length() <= dataBufferCapacity)
return;
String content = m_dataBuffer.toString();
m_dataBuffer.clear();
CString encodedContent = param->textEncoding.encode(content, WTF::EntitiesForUnencodables);
// Send result to the client.
m_client->didSerializeDataForFrame(WebCString(encodedContent), status);
}
void WebPageSerializer::serialize(WebView* view, WebVector<WebPageSerializer::Resource>* resourcesParam)
{
Vector<SerializedResource> resources;
PageSerializer serializer(&resources);
serializer.serialize(toWebViewImpl(view)->page());
Vector<Resource> result;
for (Vector<SerializedResource>::const_iterator iter = resources.begin(); iter != resources.end(); ++iter) {
Resource resource;
resource.url = iter->url;
resource.mimeType = iter->mimeType.ascii();
// FIXME: we are copying all the resource data here. Idealy we would have a WebSharedData().
resource.data = WebCString(iter->data->data(), iter->data->size());
result.append(resource);
}
*resourcesParam = result;
}
void WebPageSerializerImpl::encodeAndFlushBuffer(
WebPageSerializerClient::PageSerializationStatus status,
SerializeDomParam* param,
FlushOption flushOption)
{
// Data buffer is not full nor do we want to force flush.
if (flushOption != ForceFlush && m_dataBuffer.length() <= dataBufferCapacity)
return;
String content = m_dataBuffer.toString();
m_dataBuffer = StringBuilder();
// Convert the unicode content to target encoding
CString encodedContent = param->textEncoding.encode(
content.characters(), content.length(), EntitiesForUnencodables);
// Send result to the client.
m_client->didSerializeDataForFrame(param->url,
WebCString(encodedContent.data(), encodedContent.length()),
status);
}
WebCString WebPageSerializer::serializeToMHTMLUsingBinaryEncoding(WebView* view)
{
RefPtr<SharedBuffer> mhtml = serializePageToMHTML(toWebViewImpl(view)->page(), MHTMLArchive::UseBinaryEncoding);
// FIXME: we are copying all the data here. Idealy we would have a WebSharedData().
return WebCString(mhtml->data(), mhtml->size());
}
WebCString WebPageSerializer::serializeToMHTMLUsingBinaryEncoding(WebView* view)
{
RefPtr<SharedBuffer> mhtml = MHTMLArchive::generateMHTMLDataUsingBinaryEncoding(static_cast<WebViewImpl*>(view)->page());
// FIXME: we are copying all the data here. Idealy we would have a WebSharedData().
return WebCString(mhtml->data(), mhtml->size());
}
void WebFontInfo::fallbackFontForChar(WebUChar32 c, const char* preferredLocale, WebFallbackFont* fallbackFont)
{
FcCharSet* cset = FcCharSetCreate();
FcCharSetAddChar(cset, c);
FcPattern* pattern = FcPatternCreate();
FcValue fcvalue;
fcvalue.type = FcTypeCharSet;
fcvalue.u.c = cset;
FcPatternAdd(pattern, FC_CHARSET, fcvalue, FcFalse);
fcvalue.type = FcTypeBool;
fcvalue.u.b = FcTrue;
FcPatternAdd(pattern, FC_SCALABLE, fcvalue, FcFalse);
if (preferredLocale) {
FcLangSet* langset = FcLangSetCreate();
FcLangSetAdd(langset, reinterpret_cast<const FcChar8 *>(preferredLocale));
FcPatternAddLangSet(pattern, FC_LANG, langset);
FcLangSetDestroy(langset);
}
FcConfigSubstitute(0, pattern, FcMatchPattern);
FcDefaultSubstitute(pattern);
FcResult result;
FcFontSet* fontSet = FcFontSort(0, pattern, 0, 0, &result);
FcPatternDestroy(pattern);
FcCharSetDestroy(cset);
if (!fontSet) {
fallbackFont->name = WebCString();
fallbackFont->isBold = false;
fallbackFont->isItalic = false;
return;
}
// Older versions of fontconfig have a bug where they cannot select
// only scalable fonts so we have to manually filter the results.
for (int i = 0; i < fontSet->nfont; ++i) {
FcPattern* current = fontSet->fonts[i];
FcBool isScalable;
if (FcPatternGetBool(current, FC_SCALABLE, 0, &isScalable) != FcResultMatch
|| !isScalable)
continue;
// fontconfig can also return fonts which are unreadable
FcChar8* cFilename;
if (FcPatternGetString(current, FC_FILE, 0, &cFilename) != FcResultMatch)
continue;
if (access(reinterpret_cast<char*>(cFilename), R_OK))
continue;
const char* fontFilename = reinterpret_cast<char*>(cFilename);
fallbackFont->filename = WebCString(fontFilename, strlen(fontFilename));
// Index into font collection.
int ttcIndex;
if (FcPatternGetInteger(current, FC_INDEX, 0, &ttcIndex) != FcResultMatch && ttcIndex < 0)
continue;
fallbackFont->ttcIndex = ttcIndex;
FcChar8* familyName;
if (FcPatternGetString(current, FC_FAMILY, 0, &familyName) == FcResultMatch) {
const char* charFamily = reinterpret_cast<char*>(familyName);
fallbackFont->name = WebCString(charFamily, strlen(charFamily));
}
int weight;
if (FcPatternGetInteger(current, FC_WEIGHT, 0, &weight) == FcResultMatch)
fallbackFont->isBold = weight >= FC_WEIGHT_BOLD;
else
fallbackFont->isBold = false;
int slant;
if (FcPatternGetInteger(current, FC_SLANT, 0, &slant) == FcResultMatch)
fallbackFont->isItalic = slant != FC_SLANT_ROMAN;
else
fallbackFont->isItalic = false;
FcFontSetDestroy(fontSet);
return;
}
FcFontSetDestroy(fontSet);
}
