void WMLPElement::insertedIntoDocument()
{
WMLElement::insertedIntoDocument();
// If not explicitly specified, the linewrap mode is identical to
// the line-wrap mode of the previous paragraph in the text flow of
// a card. The default mode for the first paragraph in a card is wrap.
if (!m_mode.isEmpty())
return;
RefPtr<NodeList> nodeList = document()->getElementsByTagName("p");
if (!nodeList)
return;
unsigned length = nodeList->length();
if (length < 2)
return;
// Assure we're the last inserted paragraph element
// This only works while parsing, otherwhise this statement is never true.
if (nodeList->item(length - 1) != this)
return;
WMLPElement* lastParagraph = static_cast<WMLPElement*>(nodeList->item(length - 2));
ASSERT(lastParagraph);
String lastMode = lastParagraph->getAttribute(modeAttr);
if (lastMode.isEmpty() || lastMode == "wrap") // Default value, do nothing.
return;
setAttribute(modeAttr, lastMode);
}
SVGFontElement* FontResource::getSVGFontById(const String& fontName) const
{
RefPtr<HTMLCollection> collection = m_externalSVGDocument->getElementsByTagNameNS(SVGNames::fontTag.namespaceURI(), SVGNames::fontTag.localName());
if (!collection)
return 0;
unsigned collectionLength = collection->length();
if (!collectionLength)
return 0;
#ifndef NDEBUG
for (unsigned i = 0; i < collectionLength; ++i) {
ASSERT(collection->item(i));
ASSERT(isSVGFontElement(collection->item(i)));
}
#endif
if (fontName.isEmpty())
return toSVGFontElement(collection->item(0));
for (unsigned i = 0; i < collectionLength; ++i) {
SVGFontElement* element = toSVGFontElement(collection->item(i));
if (element->getIdAttribute() == fontName)
return element;
}
return 0;
}
SVGFontElement* CachedFont::getSVGFontById(const String& fontName) const
{
ASSERT(m_isSVGFont);
RefPtr<NodeList> list = m_externalSVGDocument->getElementsByTagNameNS(SVGNames::fontTag.namespaceURI(), SVGNames::fontTag.localName());
if (!list)
return 0;
unsigned listLength = list->length();
if (!listLength)
return 0;
#ifndef NDEBUG
for (unsigned i = 0; i < listLength; ++i) {
ASSERT(list->item(i));
ASSERT(list->item(i)->hasTagName(SVGNames::fontTag));
}
#endif
if (fontName.isEmpty())
return static_cast<SVGFontElement*>(list->item(0));
for (unsigned i = 0; i < listLength; ++i) {
SVGFontElement* element = static_cast<SVGFontElement*>(list->item(i));
if (element->getIdAttribute() == fontName)
return element;
}
return 0;
}
bool HTMLObjectElement::shouldAllowQuickTimeClassIdQuirk()
{
// This site-specific hack maintains compatibility with Mac OS X Wiki Server,
// which embeds QuickTime movies using an object tag containing QuickTime's
// ActiveX classid. Treat this classid as valid only if OS X Server's unique
// 'generator' meta tag is present. Only apply this quirk if there is no
// fallback content, which ensures the quirk will disable itself if Wiki
// Server is updated to generate an alternate embed tag as fallback content.
if (!document()->page()
|| !document()->page()->settings()->needsSiteSpecificQuirks()
|| hasFallbackContent()
|| !equalIgnoringCase(classId(), "clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B"))
return false;
RefPtr<NodeList> metaElements = document()->getElementsByTagName(HTMLNames::metaTag.localName());
unsigned length = metaElements->length();
for (unsigned i = 0; i < length; ++i) {
ASSERT(metaElements->item(i)->isHTMLElement());
HTMLMetaElement* metaElement = static_cast<HTMLMetaElement*>(metaElements->item(i));
if (equalIgnoringCase(metaElement->name(), "generator") && metaElement->content().startsWith("Mac OS X Server Web Services Server", false))
return true;
}
return false;
}
void FEBlend::platformApplySoftware()
{
FilterEffect* in = inputEffect(0);
FilterEffect* in2 = inputEffect(1);
ASSERT(m_mode > FEBLEND_MODE_UNKNOWN);
ASSERT(m_mode <= FEBLEND_MODE_LIGHTEN);
Uint8ClampedArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<Uint8ClampedArray> srcPixelArrayA = in->asPremultipliedImage(effectADrawingRect);
IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
RefPtr<Uint8ClampedArray> srcPixelArrayB = in2->asPremultipliedImage(effectBDrawingRect);
unsigned pixelArrayLength = srcPixelArrayA->length();
ASSERT(pixelArrayLength == srcPixelArrayB->length());
for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
unsigned char alphaA = srcPixelArrayA->item(pixelOffset + 3);
unsigned char alphaB = srcPixelArrayB->item(pixelOffset + 3);
for (unsigned channel = 0; channel < 3; ++channel) {
unsigned char colorA = srcPixelArrayA->item(pixelOffset + channel);
unsigned char colorB = srcPixelArrayB->item(pixelOffset + channel);
unsigned char result;
switch (m_mode) {
case FEBLEND_MODE_NORMAL:
result = normal(colorA, colorB, alphaA, alphaB);
break;
case FEBLEND_MODE_MULTIPLY:
result = multiply(colorA, colorB, alphaA, alphaB);
break;
case FEBLEND_MODE_SCREEN:
result = screen(colorA, colorB, alphaA, alphaB);
break;
case FEBLEND_MODE_DARKEN:
result = darken(colorA, colorB, alphaA, alphaB);
break;
case FEBLEND_MODE_LIGHTEN:
result = lighten(colorA, colorB, alphaA, alphaB);
break;
case FEBLEND_MODE_UNKNOWN:
default:
result = 0;
break;
}
dstPixelArray->set(pixelOffset + channel, result);
}
unsigned char alphaR = 255 - ((255 - alphaA) * (255 - alphaB)) / 255;
dstPixelArray->set(pixelOffset + 3, alphaR);
}
}
WMLCardElement* WMLCardElement::determineActiveCard(Document* doc)
{
WMLPageState* pageState = wmlPageStateForDocument(doc);
if (!pageState)
return 0;
RefPtr<NodeList> nodeList = doc->getElementsByTagName("card");
if (!nodeList)
return 0;
unsigned length = nodeList->length();
if (length < 1)
return 0;
// Figure out the new target card
String cardName = doc->url().fragmentIdentifier();
WMLCardElement* activeCard = findNamedCardInDocument(doc, cardName);
if (activeCard) {
// Hide all cards - except the destination card - in document
for (unsigned i = 0; i < length; ++i) {
WMLCardElement* card = static_cast<WMLCardElement*>(nodeList->item(i));
if (card == activeCard)
card->showCard();
else
card->hideCard();
}
} else {
// If the target URL didn't contain a fragment identifier, activeCard
// is 0, and has to be set to the first card element in the deck.
activeCard = static_cast<WMLCardElement*>(nodeList->item(0));
activeCard->showCard();
}
// Assure destination card is visible
ASSERT(activeCard->isVisible());
ASSERT(activeCard->attached());
ASSERT(activeCard->renderer());
// Update the document title
doc->setTitle(activeCard->title());
#if ENABLE(WMLSCRIPT)
static_cast<WMLDocument*>(doc)->setActiveCardId(activeCard->getIDAttribute()) ;
#endif
// SAMSUNG_WML_FIXES+
// Set the active activeCard in the Document object
static_cast<WMLDocument*>(doc)->setActiveCard(activeCard);
// Set the active activeCard in the WMLPageState object
//pageState->setActiveCard(activeCard);
// SAMSUNG_WML_FIXES-
return activeCard;
}
static PassRefPtr<CSSMutableStyleDeclaration> styleFromMatchedRulesForElement(Element* element, bool authorOnly = true)
{
RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create();
RefPtr<CSSRuleList> matchedRules = element->document()->styleSelector()->styleRulesForElement(element, authorOnly);
if (matchedRules) {
for (unsigned i = 0; i < matchedRules->length(); i++) {
if (matchedRules->item(i)->type() == CSSRule::STYLE_RULE) {
RefPtr<CSSMutableStyleDeclaration> s = static_cast<CSSStyleRule*>(matchedRules->item(i))->style();
style->merge(s.get(), true);
}
}
}
return style.release();
}
void WebPageSerializerImpl::collectTargetFrames()
{
ASSERT(!m_framesCollected);
m_framesCollected = true;
// First, process main frame.
m_frames.append(m_specifiedWebFrameImpl);
// Return now if user only needs to serialize specified frame, not including
// all sub-frames.
if (!m_recursiveSerialization)
return;
// Collect all frames inside the specified frame.
for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) {
WebFrameImpl* currentFrame = m_frames[i];
// Get current using document.
Document* currentDoc = currentFrame->frame()->document();
// Go through sub-frames.
RefPtr<HTMLCollection> all = currentDoc->all();
for (unsigned i = 0; Node* node = all->item(i); i++) {
if (!node->isHTMLElement())
continue;
Element* element = toElement(node);
WebFrameImpl* webFrame =
WebFrameImpl::fromFrameOwnerElement(element);
if (webFrame)
m_frames.append(webFrame);
}
}
}
void WMLCardElement::insertedIntoDocument()
{
WMLElement::insertedIntoDocument();
Document* document = this->document();
// The first card inserted into a document, is visible by default.
if (!m_isVisible) {
RefPtr<NodeList> nodeList = document->getElementsByTagName("card");
if (nodeList && nodeList->length() == 1 && nodeList->item(0) == this) {
m_isVisible = true;
// SAMSUNG_WML_FIXES+
#ifdef ANDROID_META_SUPPORT
// fit wml sites directly in the screen
if (Page *p = document->page())
p->settings()->setMetadataSettings("width", "device-width");
if (FrameView* frameView = document->view())
android::WebViewCore::getWebViewCore(frameView)->updateViewport();
#endif
// SAMSUNG_WML_FIXES+
}
}
// For the WML layout tests we embed WML content in a XHTML document. Navigating to different cards
// within the same deck has a different behaviour in HTML than in WML. HTML wants to "scroll to anchor"
// (see FrameLoader) but WML wants a reload. Notify the root document of the layout test that we want
// to mimic WML behaviour. This is rather tricky, but has been tested extensively. Usually it's not possible
// at all to embed WML in HTML, it's not designed that way, we're just "abusing" it for dynamically created layout tests.
if (document->page() && document->page()->mainFrame()) {
Document* rootDocument = document->page()->mainFrame()->document();
if (rootDocument && rootDocument != document)
rootDocument->setContainsWMLContent(true);
}
}
WebString WebDocument::applicationID() const
{
const char* kChromeApplicationHeader = "x-chrome-application";
// First check if the document's response included a header indicating the
// application it should go with.
const Document* document = constUnwrap<Document>();
Frame* frame = document->frame();
if (!frame)
return WebString();
DocumentLoader* loader = frame->loader()->documentLoader();
if (!loader)
return WebString();
WebString headerValue =
loader->response().httpHeaderField(kChromeApplicationHeader);
if (!headerValue.isEmpty())
return headerValue;
// Otherwise, fall back to looking for the meta tag.
RefPtr<NodeList> metaTags =
const_cast<Document*>(document)->getElementsByTagName("meta");
for (unsigned i = 0; i < metaTags->length(); ++i) {
Element* element = static_cast<Element*>(metaTags->item(i));
if (element->getAttribute("http-equiv").lower() ==
kChromeApplicationHeader) {
return element->getAttribute("value");
}
}
return WebString();
}
void MediaStreamFrameController::streamGenerated(int requestId, const String& label, PassRefPtr<MediaStreamTrackList> tracksParam)
{
// Don't assert since the request can have been aborted as a result of embedder detachment.
if (!m_requests.contains(requestId))
return;
ASSERT(m_requests.get(requestId)->isGenerateStreamRequest());
ASSERT(!label.isNull());
ASSERT(tracksParam);
RefPtr<MediaStreamTrackList> tracks = tracksParam;
for (unsigned i = 0; i < tracks->length(); ++i) {
int trackClientId = m_clients.getNextId();
RefPtr<MediaStreamTrack> track = tracks->item(i);
track->associateFrameController(this, trackClientId);
m_clients.add(trackClientId, track.get());
}
RefPtr<GenerateStreamRequest> streamRequest = static_cast<GenerateStreamRequest*>(m_requests.get(requestId).get());
RefPtr<LocalMediaStream> generatedStream = LocalMediaStream::create(this, label, tracks.release());
m_streams.add(label, generatedStream.get());
m_requests.remove(requestId);
streamRequest->successCallback()->handleEvent(generatedStream.get());
}
QVariantList DumpRenderTreeSupportQt::nodesFromRect(const QVariantMap& document, int x, int y, unsigned top, unsigned right, unsigned bottom, unsigned left, bool ignoreClipping)
{
QVariantList res;
Document* doc = getCoreDocumentFromVariantMap(document);
if (!doc)
return res;
RefPtr<NodeList> nodes = doc->nodesFromRect(x, y, top, right, bottom, left, ignoreClipping);
for (unsigned i = 0; i < nodes->length(); i++) {
// QWebElement will be null if the Node is not an HTML Element
if (nodes->item(i)->isHTMLElement())
res << QVariant::fromValue(QWebElement(nodes->item(i)));
else
res << QVariant::fromValue(QDRTNode(nodes->item(i)));
}
return res;
}
bool InspectorStyleSheet::ensureSourceData(Node* ownerNode)
{
if (m_parsedStyleSheet->hasSourceData())
return true;
if (!m_parsedStyleSheet->hasText())
return false;
RefPtr<CSSStyleSheet> newStyleSheet = CSSStyleSheet::create(ownerNode);
CSSParser p;
StyleRuleRangeMap ruleRangeMap;
p.parseSheet(newStyleSheet.get(), m_parsedStyleSheet->text(), 0, &ruleRangeMap);
OwnPtr<ParsedStyleSheet::SourceData> rangesVector(new ParsedStyleSheet::SourceData());
for (unsigned i = 0, length = newStyleSheet->length(); i < length; ++i) {
CSSStyleRule* rule = InspectorCSSAgent::asCSSStyleRule(newStyleSheet->item(i));
if (!rule)
continue;
StyleRuleRangeMap::iterator it = ruleRangeMap.find(rule);
if (it != ruleRangeMap.end())
rangesVector->append(it->second);
}
m_parsedStyleSheet->setSourceData(rangesVector.release());
return m_parsedStyleSheet->hasSourceData();
}
CSSStyleRule* InspectorStyleSheet::addRule(const String& selector)
{
String text;
bool success = styleSheetText(&text);
if (!success)
return 0;
ExceptionCode ec = 0;
m_pageStyleSheet->addRule(selector, "", ec);
if (ec)
return 0;
RefPtr<CSSRuleList> rules = m_pageStyleSheet->cssRules();
ASSERT(rules->length());
CSSStyleRule* rule = InspectorCSSAgent::asCSSStyleRule(rules->item(rules->length() - 1));
ASSERT(rule);
if (text.length())
text += "\n";
text += selector;
text += " {}";
m_parsedStyleSheet->setText(text);
return rule;
}
void FEDisplacementMap::applySoftware()
{
FilterEffect* in = inputEffect(0);
FilterEffect* in2 = inputEffect(1);
ASSERT(m_xChannelSelector != CHANNEL_UNKNOWN);
ASSERT(m_yChannelSelector != CHANNEL_UNKNOWN);
Uint8ClampedArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
IntRect effectADrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<Uint8ClampedArray> srcPixelArrayA = in->asPremultipliedImage(effectADrawingRect);
IntRect effectBDrawingRect = requestedRegionOfInputImageData(in2->absolutePaintRect());
RefPtr<Uint8ClampedArray> srcPixelArrayB = in2->asUnmultipliedImage(effectBDrawingRect);
ASSERT(srcPixelArrayA->length() == srcPixelArrayB->length());
Filter* filter = this->filter();
IntSize paintSize = absolutePaintRect().size();
float scaleX = filter->applyHorizontalScale(m_scale);
float scaleY = filter->applyVerticalScale(m_scale);
float scaleForColorX = scaleX / 255.0;
float scaleForColorY = scaleY / 255.0;
float scaledOffsetX = 0.5 - scaleX * 0.5;
float scaledOffsetY = 0.5 - scaleY * 0.5;
int stride = paintSize.width() * 4;
for (int y = 0; y < paintSize.height(); ++y) {
int line = y * stride;
for (int x = 0; x < paintSize.width(); ++x) {
int dstIndex = line + x * 4;
int srcX = x + static_cast<int>(scaleForColorX * srcPixelArrayB->item(dstIndex + m_xChannelSelector - 1) + scaledOffsetX);
int srcY = y + static_cast<int>(scaleForColorY * srcPixelArrayB->item(dstIndex + m_yChannelSelector - 1) + scaledOffsetY);
for (unsigned channel = 0; channel < 4; ++channel) {
if (srcX < 0 || srcX >= paintSize.width() || srcY < 0 || srcY >= paintSize.height()) {
dstPixelArray->set(dstIndex + channel, static_cast<unsigned char>(0));
} else {
unsigned char pixelValue = srcPixelArrayA->item(srcY * stride + srcX * 4 + channel);
dstPixelArray->set(dstIndex + channel, pixelValue);
}
}
}
}
}
String MockBox::peekType(ArrayBuffer* data)
{
StringBuilder builder;
RefPtr<Int8Array> array = JSC::Int8Array::create(data, 0, 4);
for (int i = 0; i < 4; ++i)
builder.append(array->item(i));
return builder.toString();
}
inline void ImageBuffer::genericConvertToLuminanceMask()
{
IntRect luminanceRect(IntPoint(), internalSize());
RefPtr<Uint8ClampedArray> srcPixelArray = getUnmultipliedImageData(luminanceRect);
unsigned pixelArrayLength = srcPixelArray->length();
for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
unsigned char a = srcPixelArray->item(pixelOffset + 3);
if (!a)
continue;
unsigned char r = srcPixelArray->item(pixelOffset);
unsigned char g = srcPixelArray->item(pixelOffset + 1);
unsigned char b = srcPixelArray->item(pixelOffset + 2);
double luma = (r * 0.2125 + g * 0.7154 + b * 0.0721) * ((double)a / 255.0);
srcPixelArray->set(pixelOffset + 3, luma);
}
putByteArray(Unmultiplied, srcPixelArray.get(), luminanceRect.size(), luminanceRect, IntPoint());
}
String StylePropertySerializer::backgroundRepeatPropertyValue() const
{
RefPtr<CSSValue> repeatX = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatX);
RefPtr<CSSValue> repeatY = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatY);
if (!repeatX || !repeatY)
return String();
if (repeatX->cssValueType() == repeatY->cssValueType()
&& (repeatX->cssValueType() == CSSValue::CSS_INITIAL || repeatX->cssValueType() == CSSValue::CSS_INHERIT)) {
return repeatX->cssText();
}
RefPtr<CSSValueList> repeatXList;
if (repeatX->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {
repeatXList = CSSValueList::createCommaSeparated();
repeatXList->append(repeatX);
} else if (repeatX->cssValueType() == CSSValue::CSS_VALUE_LIST) {
repeatXList = toCSSValueList(repeatX.get());
} else {
return String();
}
RefPtr<CSSValueList> repeatYList;
if (repeatY->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {
repeatYList = CSSValueList::createCommaSeparated();
repeatYList->append(repeatY);
} else if (repeatY->cssValueType() == CSSValue::CSS_VALUE_LIST) {
repeatYList = toCSSValueList(repeatY.get());
} else {
return String();
}
size_t shorthandLength = lowestCommonMultiple(repeatXList->length(), repeatYList->length());
StringBuilder builder;
for (size_t i = 0; i < shorthandLength; ++i) {
if (i)
builder.appendLiteral(", ");
appendBackgroundRepeatValue(builder,
*repeatXList->item(i % repeatXList->length()),
*repeatYList->item(i % repeatYList->length()));
}
return builder.toString();
}
void WMLTemplateElement::registerTemplatesInDocument(Document* doc)
{
ASSERT(doc);
// Build list of cards in document
RefPtr<NodeList> nodeList = doc->getElementsByTagName("card");
if (!nodeList)
return;
unsigned length = nodeList->length();
if (length < 1)
return;
HashSet<WMLCardElement*> cards;
for (unsigned i = 0; i < length; ++i)
cards.add(static_cast<WMLCardElement*>(nodeList->item(i)));
if (cards.isEmpty())
return;
// Register template element to all cards
nodeList = doc->getElementsByTagName("template");
if (!nodeList)
return;
length = nodeList->length();
if (length < 1)
return;
// Only one template element should be allowed in a document
// Calling setTemplateElement() twice on a WMLCardElement, will result in a tokenizer error.
for (unsigned i = 0; i < length; ++i) {
WMLTemplateElement* temp = static_cast<WMLTemplateElement*>(nodeList->item(i));
HashSet<WMLCardElement*>::iterator it = cards.begin();
HashSet<WMLCardElement*>::iterator end = cards.end();
for (; it != end; ++it)
(*it)->setTemplateElement(temp);
}
}
void HTMLTableSectionElement::deleteRow(int index, ExceptionCode& ec)
{
RefPtr<HTMLCollection> children = rows();
int numRows = children ? (int)children->length() : 0;
if (index == -1)
index = numRows - 1;
if (index >= 0 && index < numRows) {
RefPtr<Node> row = children->item(index);
HTMLElement::removeChild(row.get(), ec);
} else
ec = INDEX_SIZE_ERR;
}
void HTMLTableRowElement::deleteCell(int index, ExceptionCode& ec)
{
RefPtr<HTMLCollection> children = cells();
int numCells = children ? children->length() : 0;
if (index == -1)
index = numCells-1;
if (index >= 0 && index < numCells) {
RefPtr<Node> cell = children->item(index);
HTMLElement::removeChild(cell.get(), ec);
} else
ec = INDEX_SIZE_ERR;
}
String ISOBox::peekType(ArrayBuffer* data)
{
ASSERT_WITH_SECURITY_IMPLICATION(data->byteLength() >= 2 * sizeof(uint32_t));
if (data->byteLength() < 2 * sizeof(uint32_t))
return emptyString();
StringBuilder builder;
RefPtr<Int8Array> array = JSC::Int8Array::create(data, 4, sizeof(uint32_t));
for (int i = 0; i < 4; ++i)
builder.append(array->item(i));
return builder.toString();
}
void WebDocument::images(WebVector<WebElement>& results)
{
RefPtr<HTMLCollection> images = unwrap<Document>()->images();
size_t sourceLength = images->length();
Vector<WebElement> temp;
temp.reserveCapacity(sourceLength);
for (size_t i = 0; i < sourceLength; ++i) {
Node* node = images->item(i);
if (node && node->isHTMLElement())
temp.append(WebElement(static_cast<Element*>(node)));
}
results.assign(temp);
}
void WebDocument::images(WebVector<WebElement>& results)
{
RefPtr<HTMLCollection> images = unwrap<Document>()->images();
size_t sourceLength = images->length();
Vector<WebElement> temp;
temp.reserveCapacity(sourceLength);
for (size_t i = 0; i < sourceLength; ++i) {
Element* element = images->item(i);
if (element && element->isHTMLElement())
temp.append(WebElement(element));
}
results.assign(temp);
}
PassOwnPtr<Shape> Shape::createRasterShape(Image* image, float threshold, const LayoutRect& imageR, const LayoutRect& marginR, WritingMode writingMode, float margin)
{
IntRect imageRect = pixelSnappedIntRect(imageR);
IntRect marginRect = pixelSnappedIntRect(marginR);
OwnPtr<RasterShapeIntervals> intervals = adoptPtr(new RasterShapeIntervals(marginRect.height(), -marginRect.y()));
OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(imageRect.size());
if (image && imageBuffer) {
// FIXME: This is not totally correct but it is needed to prevent shapes
// that loads SVG Images during paint invalidations to mark layoutObjects for
// layout, which is not allowed. See https://crbug.com/429346
ImageObserverDisabler disabler(image);
SkPaint paint;
IntRect imageSourceRect(IntPoint(), image->size());
IntRect imageDestRect(IntPoint(), imageRect.size());
image->draw(imageBuffer->canvas(), paint, imageDestRect, imageSourceRect, DoNotRespectImageOrientation, Image::DoNotClampImageToSourceRect);
WTF::ArrayBufferContents contents;
imageBuffer->getImageData(Unmultiplied, IntRect(IntPoint(), imageRect.size()), contents);
RefPtr<DOMArrayBuffer> arrayBuffer = DOMArrayBuffer::create(contents);
RefPtr<DOMUint8ClampedArray> pixelArray = DOMUint8ClampedArray::create(arrayBuffer, 0, arrayBuffer->byteLength());
unsigned pixelArrayOffset = 3; // Each pixel is four bytes: RGBA.
uint8_t alphaPixelThreshold = threshold * 255;
ASSERT(static_cast<unsigned>(imageRect.width() * imageRect.height() * 4) == pixelArray->length());
int minBufferY = std::max(0, marginRect.y() - imageRect.y());
int maxBufferY = std::min(imageRect.height(), marginRect.maxY() - imageRect.y());
for (int y = minBufferY; y < maxBufferY; ++y) {
int startX = -1;
for (int x = 0; x < imageRect.width(); ++x, pixelArrayOffset += 4) {
uint8_t alpha = pixelArray->item(pixelArrayOffset);
bool alphaAboveThreshold = alpha > alphaPixelThreshold;
if (startX == -1 && alphaAboveThreshold) {
startX = x;
} else if (startX != -1 && (!alphaAboveThreshold || x == imageRect.width() - 1)) {
int endX = alphaAboveThreshold ? x + 1 : x;
intervals->intervalAt(y + imageRect.y()).unite(IntShapeInterval(startX + imageRect.x(), endX + imageRect.x()));
startX = -1;
}
}
}
}
OwnPtr<RasterShape> rasterShape = adoptPtr(new RasterShape(intervals.release(), marginRect.size()));
rasterShape->m_writingMode = writingMode;
rasterShape->m_margin = margin;
return rasterShape.release();
}
static JSValue namedItemGetter(ExecState* exec, JSValue slotBase, PropertyName propertyName)
{
JSDOMWindowBase* thisObj = jsCast<JSDOMWindow*>(asObject(slotBase));
Document* document = thisObj->impl()->frame()->document();
ASSERT(BindingSecurity::shouldAllowAccessToDOMWindow(exec, thisObj->impl()));
ASSERT(document);
ASSERT(document->isHTMLDocument());
RefPtr<HTMLCollection> collection = document->windowNamedItems(propertyNameToAtomicString(propertyName));
if (collection->hasExactlyOneItem())
return toJS(exec, thisObj, collection->item(0));
return toJS(exec, thisObj, WTF::getPtr(collection));
}
void InspectorNodeFinder::searchUsingCSSSelectors(Node* parentNode)
{
if (!parentNode->isContainerNode())
return;
ExceptionCode ec = 0;
RefPtr<NodeList> nodeList = toContainerNode(parentNode)->querySelectorAll(m_whitespaceTrimmedQuery, ec);
if (ec || !nodeList)
return;
unsigned size = nodeList->length();
for (unsigned i = 0; i < size; ++i)
m_results.add(nodeList->item(i));
}
void WebDocument::forms(WebVector<WebFormElement>& results) const
{
RefPtr<HTMLCollection> forms = const_cast<Document*>(constUnwrap<Document>())->forms();
size_t sourceLength = forms->length();
Vector<WebFormElement> temp;
temp.reserveCapacity(sourceLength);
for (size_t i = 0; i < sourceLength; ++i) {
Node* node = forms->item(i);
// Strange but true, sometimes node can be 0.
if (node && node->isHTMLElement())
temp.append(WebFormElement(static_cast<HTMLFormElement*>(node)));
}
results.assign(temp);
}
/*!
\since 4.5
\brief Returns the meta data in this frame as a QMultiMap
The meta data consists of the name and content attributes of the
of the \c{<meta>} tags in the HTML document.
For example:
\code
<html>
<head>
<meta name="description" content="This document is a tutorial about Qt development">
<meta name="keywords" content="Qt, WebKit, Programming">
</head>
...
</html>
\endcode
Given the above HTML code the metaData() function will return a map with two entries:
\table
\header \o Key
\o Value
\row \o "description"
\o "This document is a tutorial about Qt development"
\row \o "keywords"
\o "Qt, WebKit, Programming"
\endtable
This function returns a multi map to support multiple meta tags with the same attribute name.
*/
QMultiMap<QString, QString> QWebFrame::metaData() const
{
if (!d->frame->document())
return QMap<QString, QString>();
QMultiMap<QString, QString> map;
Document* doc = d->frame->document();
RefPtr<NodeList> list = doc->getElementsByTagName("meta");
unsigned len = list->length();
for (unsigned i = 0; i < len; i++) {
HTMLMetaElement* meta = static_cast<HTMLMetaElement*>(list->item(i));
map.insert(meta->name(), meta->content());
}
return map;
}
void WMLTableElement::transferAllChildrenOfElementToTargetElement(WMLElement* sourceElement, WMLElement* targetElement, unsigned startOffset) const
{
RefPtr<NodeList> children = sourceElement->childNodes();
if (!children)
return;
ExceptionCode ec = 0;
unsigned length = children->length();
for (unsigned i = startOffset; i < length; ++i) {
RefPtr<Node> clonedNode = children->item(i)->cloneNode(true);
targetElement->appendChild(clonedNode.release(), ec);
ASSERT(ec == 0);
}
}
