void SVGPointList::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> fromValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
{
RefPtrWillBeRawPtr<SVGPointList> fromList = toSVGPointList(fromValue);
RefPtrWillBeRawPtr<SVGPointList> toList = toSVGPointList(toValue);
RefPtrWillBeRawPtr<SVGPointList> toAtEndOfDurationList = toSVGPointList(toAtEndOfDurationValue);
size_t fromPointListSize = fromList->length();
size_t toPointListSize = toList->length();
size_t toAtEndOfDurationListSize = toAtEndOfDurationList->length();
if (!adjustFromToListValues(fromList, toList, percentage, animationElement->animationMode()))
return;
for (size_t i = 0; i < toPointListSize; ++i) {
float animatedX = at(i)->x();
float animatedY = at(i)->y();
FloatPoint effectiveFrom;
if (fromPointListSize)
effectiveFrom = fromList->at(i)->value();
FloatPoint effectiveTo = toList->at(i)->value();
FloatPoint effectiveToAtEnd;
if (i < toAtEndOfDurationListSize)
effectiveToAtEnd = toAtEndOfDurationList->at(i)->value();
animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.x(), effectiveTo.x(), effectiveToAtEnd.x(), animatedX);
animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom.y(), effectiveTo.y(), effectiveToAtEnd.y(), animatedY);
at(i)->setValue(FloatPoint(animatedX, animatedY));
}
}
void SVGRenderSupport::applyStrokeStyleToStrokeData(StrokeData* strokeData, const RenderStyle* style, const RenderObject* object)
{
ASSERT(strokeData);
ASSERT(style);
ASSERT(object);
ASSERT(object->node());
ASSERT(object->node()->isSVGElement());
const SVGRenderStyle& svgStyle = style->svgStyle();
SVGLengthContext lengthContext(toSVGElement(object->node()));
strokeData->setThickness(svgStyle.strokeWidth()->value(lengthContext));
strokeData->setLineCap(svgStyle.capStyle());
strokeData->setLineJoin(svgStyle.joinStyle());
strokeData->setMiterLimit(svgStyle.strokeMiterLimit());
RefPtrWillBeRawPtr<SVGLengthList> dashes = svgStyle.strokeDashArray();
if (dashes->isEmpty())
return;
DashArray dashArray;
size_t length = dashes->length();
for (size_t i = 0; i < length; ++i)
dashArray.append(dashes->at(i)->value(lengthContext));
strokeData->setLineDash(dashArray, svgStyle.strokeDashOffset()->value(lengthContext));
}
float SVGTransformList::calculateDistance(PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, SVGElement*)
{
// FIXME: This is not correct in all cases. The spec demands that each component (translate x and y for example)
// is paced separately. To implement this we need to treat each component as individual animation everywhere.
RefPtrWillBeRawPtr<SVGTransformList> toList = toSVGTransformList(toValue);
if (isEmpty() || length() != toList->length())
return -1;
ASSERT(length() == 1);
if (at(0)->transformType() == toList->at(0)->transformType())
return -1;
// Spec: http://www.w3.org/TR/SVG/animate.html#complexDistances
// Paced animations assume a notion of distance between the various animation values defined by the 'to', 'from', 'by' and 'values' attributes.
// Distance is defined only for scalar types (such as <length>), colors and the subset of transformation types that are supported by 'animateTransform'.
return SVGTransformDistance(at(0), toList->at(0)).distance();
}
void SVGPointList::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement* contextElement)
{
RefPtrWillBeRawPtr<SVGPointList> otherList = toSVGPointList(other);
if (length() != otherList->length())
return;
for (size_t i = 0; i < length(); ++i)
at(i)->setValue(at(i)->value() + otherList->at(i)->value());
}
void WorkerWebSocketChannel::fail(const String& reason, MessageLevel level, const String& sourceURL, unsigned lineNumber)
{
if (!m_bridge)
return;
RefPtrWillBeRawPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
if (callStack && callStack->size()) {
// In order to emulate the ConsoleMessage behavior,
// we should ignore the specified url and line number if
// we can get the JavaScript context.
m_bridge->fail(reason, level, callStack->at(0).sourceURL(), callStack->at(0).lineNumber());
} else if (sourceURL.isEmpty() && !lineNumber) {
// No information is specified by the caller - use the url
// and the line number at the connection.
m_bridge->fail(reason, level, m_sourceURLAtConnection, m_lineNumberAtConnection);
} else {
// Use the specified information.
m_bridge->fail(reason, level, sourceURL, lineNumber);
}
}
WebSocketChannel* WebSocketChannel::create(ExecutionContext* context, WebSocketChannelClient* client)
{
ASSERT(context);
ASSERT(client);
String sourceURL;
unsigned lineNumber = 0;
RefPtrWillBeRawPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
if (callStack && callStack->size()) {
sourceURL = callStack->at(0).sourceURL();
lineNumber = callStack->at(0).lineNumber();
}
if (context->isWorkerGlobalScope()) {
WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
return WorkerThreadableWebSocketChannel::create(*workerGlobalScope, client, sourceURL, lineNumber);
}
Document* document = toDocument(context);
return NewWebSocketChannelImpl::create(document, client, sourceURL, lineNumber);
}
void SVGTransformList::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> fromValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
{
ASSERT(animationElement);
bool isToAnimation = animationElement->animationMode() == ToAnimation;
// Spec: To animations provide specific functionality to get a smooth change from the underlying value to the
// 'to' attribute value, which conflicts mathematically with the requirement for additive transform animations
// to be post-multiplied. As a consequence, in SVG 1.1 the behavior of to animations for 'animateTransform' is undefined
// FIXME: This is not taken into account yet.
RefPtrWillBeRawPtr<SVGTransformList> fromList = isToAnimation ? PassRefPtrWillBeRawPtr<SVGTransformList>(this) : toSVGTransformList(fromValue);
RefPtrWillBeRawPtr<SVGTransformList> toList = toSVGTransformList(toValue);
RefPtrWillBeRawPtr<SVGTransformList> toAtEndOfDurationList = toSVGTransformList(toAtEndOfDurationValue);
size_t toListSize = toList->length();
if (!toListSize)
return;
// Get a reference to the from value before potentially cleaning it out (in the case of a To animation.)
RefPtrWillBeRawPtr<SVGTransform> toTransform = toList->at(0);
RefPtrWillBeRawPtr<SVGTransform> effectiveFrom = nullptr;
// If there's an existing 'from'/underlying value of the same type use that, else use a "zero transform".
if (fromList->length() && fromList->at(0)->transformType() == toTransform->transformType())
effectiveFrom = fromList->at(0);
else
effectiveFrom = SVGTransform::create(toTransform->transformType(), SVGTransform::ConstructZeroTransform);
// Never resize the animatedTransformList to the toList size, instead either clear the list or append to it.
if (!isEmpty() && (!animationElement->isAdditive() || isToAnimation))
clear();
RefPtrWillBeRawPtr<SVGTransform> currentTransform = SVGTransformDistance(effectiveFrom, toTransform).scaledDistance(percentage).addToSVGTransform(effectiveFrom);
if (animationElement->isAccumulated() && repeatCount) {
RefPtrWillBeRawPtr<SVGTransform> effectiveToAtEnd = !toAtEndOfDurationList->isEmpty() ? PassRefPtrWillBeRawPtr<SVGTransform>(toAtEndOfDurationList->at(0)) : SVGTransform::create(toTransform->transformType(), SVGTransform::ConstructZeroTransform);
append(SVGTransformDistance::addSVGTransforms(currentTransform, effectiveToAtEnd, repeatCount));
} else {
append(currentTransform);
}
}
void SVGNumberList::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtrWillBeRawPtr<SVGPropertyBase> fromValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toValue, PassRefPtrWillBeRawPtr<SVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement)
{
RefPtrWillBeRawPtr<SVGNumberList> fromList = toSVGNumberList(fromValue);
RefPtrWillBeRawPtr<SVGNumberList> toList = toSVGNumberList(toValue);
RefPtrWillBeRawPtr<SVGNumberList> toAtEndOfDurationList = toSVGNumberList(toAtEndOfDurationValue);
size_t fromListSize = fromList->length();
size_t toListSize = toList->length();
size_t toAtEndOfDurationListSize = toAtEndOfDurationList->length();
if (!adjustFromToListValues(fromList, toList, percentage, animationElement->animationMode()))
return;
for (size_t i = 0; i < toListSize; ++i) {
float effectiveFrom = fromListSize ? fromList->at(i)->value() : 0;
float effectiveTo = toListSize ? toList->at(i)->value() : 0;
float effectiveToAtEnd = i < toAtEndOfDurationListSize ? toAtEndOfDurationList->at(i)->value() : 0;
float animated = at(i)->value();
animationElement->animateAdditiveNumber(percentage, repeatCount, effectiveFrom, effectiveTo, effectiveToAtEnd, animated);
at(i)->setValue(animated);
}
}
static PassRefPtrWillBeRawPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Local<v8::Message> message, int* const scriptId)
{
v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
*scriptId = message->GetScriptOrigin().ScriptID()->Value();
// Currently stack trace is only collected when inspector is open.
if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
callStack = createScriptCallStack(isolate, stackTrace, ScriptCallStack::maxCallStackSizeToCapture);
bool success = false;
int topScriptId = callStack->at(0).scriptId().toInt(&success);
if (success && topScriptId == *scriptId)
*scriptId = 0;
}
return callStack.release();
}
void SVGTransformList::add(PassRefPtrWillBeRawPtr<SVGPropertyBase> other, SVGElement* contextElement)
{
if (isEmpty())
return;
RefPtrWillBeRawPtr<SVGTransformList> otherList = toSVGTransformList(other);
if (length() != otherList->length())
return;
ASSERT(length() == 1);
RefPtrWillBeRawPtr<SVGTransform> fromTransform = at(0);
RefPtrWillBeRawPtr<SVGTransform> toTransform = otherList->at(0);
ASSERT(fromTransform->transformType() == toTransform->transformType());
clear();
append(SVGTransformDistance::addSVGTransforms(fromTransform, toTransform));
}
static void gatherSecurityPolicyViolationEventData(SecurityPolicyViolationEventInit& init, Document* document, const String& directiveText, const String& effectiveDirective, const KURL& blockedURL, const String& header)
{
if (equalIgnoringCase(effectiveDirective, ContentSecurityPolicy::FrameAncestors)) {
// If this load was blocked via 'frame-ancestors', then the URL of |document| has not yet
// been initialized. In this case, we'll set both 'documentURI' and 'blockedURI' to the
// blocked document's URL.
init.setDocumentURI(blockedURL.string());
init.setBlockedURI(blockedURL.string());
} else {
init.setDocumentURI(document->url().string());
init.setBlockedURI(stripURLForUseInReport(document, blockedURL));
}
init.setReferrer(document->referrer());
init.setViolatedDirective(directiveText);
init.setEffectiveDirective(effectiveDirective);
init.setOriginalPolicy(header);
init.setSourceFile(String());
init.setLineNumber(0);
init.setColumnNumber(0);
init.setStatusCode(0);
if (!SecurityOrigin::isSecure(document->url()) && document->loader())
init.setStatusCode(document->loader()->response().httpStatusCode());
RefPtrWillBeRawPtr<ScriptCallStack> stack = currentScriptCallStack(1);
if (!stack || !stack->size())
return;
const ScriptCallFrame& callFrame = stack->at(0);
if (callFrame.lineNumber()) {
KURL source = KURL(ParsedURLString, callFrame.sourceURL());
init.setSourceFile(stripURLForUseInReport(document, source));
init.setLineNumber(callFrame.lineNumber());
init.setColumnNumber(callFrame.columnNumber());
}
}
