void PageSerializer::serializeFrame(Frame* frame)
{
Document* document = frame->document();
URL url = document->url();
if (!url.isValid() || url.isBlankURL()) {
// For blank frames we generate a fake URL so they can be referenced by their containing frame.
url = urlForBlankFrame(frame);
}
if (m_resourceURLs.contains(url)) {
// FIXME: We could have 2 frame with the same URL but which were dynamically changed and have now
// different content. So we should serialize both and somehow rename the frame src in the containing
// frame. Arg!
return;
}
Vector<Node*> nodes;
SerializerMarkupAccumulator accumulator(*this, *document, &nodes);
TextEncoding textEncoding(document->charset());
CString data;
if (!textEncoding.isValid()) {
// FIXME: iframes used as images trigger this. We should deal with them correctly.
return;
}
String text = accumulator.serializeNodes(*document->documentElement(), 0, IncludeNode);
CString frameHTML = textEncoding.encode(text, EntitiesForUnencodables);
m_resources->append(Resource(url, document->suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
m_resourceURLs.add(url);
for (Vector<Node*>::iterator iter = nodes.begin(); iter != nodes.end(); ++iter) {
Node* node = *iter;
if (!node->isElementNode())
continue;
Element* element = toElement(node);
// We have to process in-line style as it might contain some resources (typically background images).
if (element->isStyledElement())
retrieveResourcesForProperties(toStyledElement(element)->inlineStyle(), document);
if (isHTMLImageElement(element)) {
HTMLImageElement* imageElement = toHTMLImageElement(element);
URL url = document->completeURL(imageElement->getAttribute(HTMLNames::srcAttr));
CachedImage* cachedImage = imageElement->cachedImage();
addImageToResources(cachedImage, imageElement->renderer(), url);
} else if (element->hasTagName(HTMLNames::linkTag)) {
HTMLLinkElement* linkElement = toHTMLLinkElement(element);
if (CSSStyleSheet* sheet = linkElement->sheet()) {
URL url = document->completeURL(linkElement->getAttribute(HTMLNames::hrefAttr));
serializeCSSStyleSheet(sheet, url);
ASSERT(m_resourceURLs.contains(url));
}
} else if (isHTMLStyleElement(element)) {
if (CSSStyleSheet* sheet = toHTMLStyleElement(element)->sheet())
serializeCSSStyleSheet(sheet, URL());
}
}
for (Frame* childFrame = frame->tree().firstChild(); childFrame; childFrame = childFrame->tree().nextSibling())
serializeFrame(childFrame);
}
void ElementRuleCollector::matchAllRules(bool matchAuthorAndUserStyles, bool includeSMILProperties)
{
matchUARules();
// Now we check user sheet rules.
if (matchAuthorAndUserStyles)
matchUserRules(false);
// Now check author rules, beginning first with presentational attributes mapped from HTML.
if (m_element.isStyledElement()) {
StyledElement& styledElement = toStyledElement(m_element);
addElementStyleProperties(styledElement.presentationAttributeStyle());
// Now we check additional mapped declarations.
// Tables and table cells share an additional mapped rule that must be applied
// after all attributes, since their mapped style depends on the values of multiple attributes.
addElementStyleProperties(styledElement.additionalPresentationAttributeStyle());
if (styledElement.isHTMLElement()) {
bool isAuto;
TextDirection textDirection = toHTMLElement(styledElement).directionalityIfhasDirAutoAttribute(isAuto);
if (isAuto)
m_result.addMatchedProperties(textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
}
}
// Check the rules in author sheets next.
if (matchAuthorAndUserStyles)
matchAuthorRules(false);
if (matchAuthorAndUserStyles && m_element.isStyledElement()) {
StyledElement& styledElement = toStyledElement(m_element);
// Now check our inline style attribute.
if (styledElement.inlineStyle()) {
// Inline style is immutable as long as there is no CSSOM wrapper.
// FIXME: Media control shadow trees seem to have problems with caching.
bool isInlineStyleCacheable = !styledElement.inlineStyle()->isMutable() && !styledElement.isInShadowTree();
// FIXME: Constify.
addElementStyleProperties(styledElement.inlineStyle(), isInlineStyleCacheable);
}
// Now check SMIL animation override style.
if (includeSMILProperties && styledElement.isSVGElement())
addElementStyleProperties(toSVGElement(styledElement).animatedSMILStyleProperties(), false /* isCacheable */);
}
}
static PassRefPtr<InspectorObject> buildObjectForElementInfo(Node* node)
{
if (!node->isElementNode() || !node->document().frame())
return nullptr;
RefPtr<InspectorObject> elementInfo = InspectorObject::create();
Element* element = toElement(node);
bool isXHTML = element->document().isXHTMLDocument();
elementInfo->setString("tagName", isXHTML ? element->nodeName() : element->nodeName().lower());
elementInfo->setString("idValue", element->getIdAttribute());
HashSet<AtomicString> usedClassNames;
if (element->hasClass() && element->isStyledElement()) {
StringBuilder classNames;
const SpaceSplitString& classNamesString = toStyledElement(element)->classNames();
size_t classNameCount = classNamesString.size();
for (size_t i = 0; i < classNameCount; ++i) {
const AtomicString& className = classNamesString[i];
if (usedClassNames.contains(className))
continue;
usedClassNames.add(className);
classNames.append('.');
classNames.append(className);
}
elementInfo->setString("className", classNames.toString());
}
RenderElement* renderer = element->renderer();
Frame* containingFrame = node->document().frame();
FrameView* containingView = containingFrame->view();
IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : nullptr;
elementInfo->setString("nodeWidth", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), *modelObject) : boundingBox.width()));
elementInfo->setString("nodeHeight", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), *modelObject) : boundingBox.height()));
if (renderer->isRenderNamedFlowFragmentContainer()) {
RenderNamedFlowFragment* region = toRenderBlockFlow(renderer)->renderNamedFlowFragment();
if (region->isValid()) {
RenderFlowThread* flowThread = region->flowThread();
ASSERT(flowThread && flowThread->isRenderNamedFlowThread());
RefPtr<InspectorObject> regionFlowInfo = InspectorObject::create();
regionFlowInfo->setString("name", toRenderNamedFlowThread(flowThread)->flowThreadName());
regionFlowInfo->setArray("regions", buildObjectForCSSRegionsHighlight(region, flowThread));
elementInfo->setObject("regionFlowInfo", regionFlowInfo.release());
}
}
RenderFlowThread* containingFlowThread = renderer->flowThreadContainingBlock();
if (containingFlowThread && containingFlowThread->isRenderNamedFlowThread()) {
RefPtr<InspectorObject> contentFlowInfo = InspectorObject::create();
contentFlowInfo->setString("name", toRenderNamedFlowThread(containingFlowThread)->flowThreadName());
elementInfo->setObject("contentFlowInfo", contentFlowInfo.release());
}
#if ENABLE(CSS_SHAPES)
if (renderer->isBox()) {
RenderBox* renderBox = toRenderBox(renderer);
if (RefPtr<InspectorObject> shapeObject = buildObjectForShapeOutside(containingFrame, renderBox))
elementInfo->setObject("shapeOutsideInfo", shapeObject.release());
}
#endif
// Need to enable AX to get the computed role.
if (!WebCore::AXObjectCache::accessibilityEnabled())
WebCore::AXObjectCache::enableAccessibility();
if (AXObjectCache* axObjectCache = node->document().axObjectCache()) {
if (AccessibilityObject* axObject = axObjectCache->getOrCreate(node))
elementInfo->setString("role", axObject->computedRoleString());
}
return elementInfo.release();
}