TEST(TimeRanges, OverlappingAdds)
{
RefPtr<TimeRanges> ranges = TimeRanges::create();
ranges->add(0, 2);
ranges->add(10, 11);
ASSERT_RANGE("{ [0,2) [10,11) }", ranges);
ranges->add(0, 2);
ASSERT_RANGE("{ [0,2) [10,11) }", ranges);
ranges->add(2, 3);
ASSERT_RANGE("{ [0,3) [10,11) }", ranges);
ranges->add(2, 6);
ASSERT_RANGE("{ [0,6) [10,11) }", ranges);
ranges->add(9, 10);
ASSERT_RANGE("{ [0,6) [9,11) }", ranges);
ranges->add(8, 10);
ASSERT_RANGE("{ [0,6) [8,11) }", ranges);
ranges->add(-1, 7);
ASSERT_RANGE("{ [-1,7) [8,11) }", ranges);
ranges->add(6, 9);
ASSERT_RANGE("{ [-1,11) }", ranges);
}
void AddSrlActions(RefPtr<Gtk::ActionGroup> prj_actions)
{
prj_actions->add( Gtk::Action::create("New", Gtk::Stock::NEW, _("_New Project")),
Gtk::AccelKey("<control>N"), MakeOnOtherPrjFunctor(bb::bind(&OnNewProject, _1, false)) );
prj_actions->add( Gtk::Action::create("Open", Gtk::Stock::OPEN, _("_Open...")),
Gtk::AccelKey("<control>O"), MakeOnOtherPrjFunctor(OnOpenProject) );
prj_actions->add( Gtk::Action::create("Save", Gtk::Stock::SAVE, _("_Save")),
Gtk::AccelKey("<control>S"), &OnSaveProject );
prj_actions->add( Gtk::Action::create("SaveAs", Gtk::Stock::SAVE_AS, _("Save _As...")),
&OnSaveAsProject );
}
PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(Filter* filter)
{
SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
bool primitiveBoundingBoxMode = filterElement->primitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
// Add effects to the builder
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(filter);
for (Node* node = filterElement->firstChild(); node; node = node->nextSibling()) {
if (!node->isSVGElement())
continue;
SVGElement* element = static_cast<SVGElement*>(node);
if (!element->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
RefPtr<FilterEffect> effect = effectElement->build(builder.get(), filter);
if (!effect) {
builder->clearEffects();
return 0;
}
builder->appendEffectToEffectReferences(effect);
effectElement->setStandardAttributes(primitiveBoundingBoxMode, effect.get());
builder->add(effectElement->result(), effect);
}
return builder.release();
}
PassRefPtr<TimeRanges> MediaPlayerPrivateAVFoundationCF::platformBufferedTimeRanges() const
{
RefPtr<TimeRanges> timeRanges = TimeRanges::create();
if (!avPlayerItem(m_avfWrapper))
return timeRanges.release();
RetainPtr<CFArrayRef> loadedRanges(AdoptCF, AVCFPlayerItemCopyLoadedTimeRanges(avPlayerItem(m_avfWrapper)));
if (!loadedRanges)
return timeRanges.release();
CFIndex rangeCount = CFArrayGetCount(loadedRanges.get());
for (CFIndex i = 0; i < rangeCount; i++) {
CFDictionaryRef range = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(loadedRanges.get(), i));
CMTime start = CMTimeMakeFromDictionary(static_cast<CFDictionaryRef>(CFDictionaryGetValue(range, CMTimeRangeStartKey())));
CMTime duration = CMTimeMakeFromDictionary(static_cast<CFDictionaryRef>(CFDictionaryGetValue(range, CMTimeRangeDurationKey())));
if (timeRangeIsValidAndNotEmpty(start, duration)) {
float rangeStart = narrowPrecisionToFloat(CMTimeGetSeconds(start));
float rangeEnd = narrowPrecisionToFloat(CMTimeGetSeconds(CMTimeAdd(start, duration)));
timeRanges->add(rangeStart, rangeEnd);
}
}
return timeRanges.release();
}
void SVGAnimatedTypeAnimator::calculateFromAndByValues(RefPtr<SVGPropertyBase>& from, RefPtr<SVGPropertyBase>& to, const String& fromString, const String& byString)
{
from = constructFromString(fromString);
to = constructFromString(byString);
// FIXME(oilpan): Below .get() should be removed after transition types are gone.
to->add(from.get(), m_contextElement);
}
PassRefPtr<TimeRanges> MediaPlayerPrivate::buffered() const
{
RefPtr<TimeRanges> timeRanges = TimeRanges::create();
if (float bufferLoaded = m_platformPlayer->bufferLoaded())
timeRanges->add(0, bufferLoaded);
return timeRanges.release();
}
PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(SVGFilter* filter)
{
SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
FloatRect targetBoundingBox = filter->targetBoundingBox();
// Add effects to the builder
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(filter);
for (Node* node = filterElement->firstChild(); node; node = node->nextSibling()) {
if (!node->isSVGElement())
continue;
SVGElement* element = static_cast<SVGElement*>(node);
if (!element->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
RefPtr<FilterEffect> effect = effectElement->build(builder.get(), filter);
if (!effect) {
builder->clearEffects();
return 0;
}
builder->appendEffectToEffectReferences(effect, effectElement->renderer());
effectElement->setStandardAttributes(effect.get());
effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(effectElement, filterElement->primitiveUnits(), targetBoundingBox));
builder->add(effectElement->result(), effect);
}
return builder.release();
}
PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(SVGFilter* filter)
{
SVGFilterElement* filterElement = toSVGFilterElement(node());
FloatRect targetBoundingBox = filter->targetBoundingBox();
// Add effects to the builder
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(SourceGraphic::create(filter), SourceAlpha::create(filter));
for (Node* node = filterElement->firstChild(); node; node = node->nextSibling()) {
if (!node->isSVGElement())
continue;
SVGElement* element = toSVGElement(node);
if (!element->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
RefPtr<FilterEffect> effect = effectElement->build(builder.get(), filter);
if (!effect) {
builder->clearEffects();
return 0;
}
builder->appendEffectToEffectReferences(effect, effectElement->renderer());
effectElement->setStandardAttributes(effect.get());
effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(effectElement, filterElement->primitiveUnits(), targetBoundingBox));
effect->setOperatingColorSpace(
effectElement->renderer()->style()->svgStyle()->colorInterpolationFilters() == CI_LINEARRGB ? ColorSpaceLinearRGB : ColorSpaceDeviceRGB);
builder->add(effectElement->result(), effect);
}
return builder.release();
}
/*
* Evaluates a key() xslt-function call. First argument is name of key
* to use, second argument is value to look up.
* @param aContext the context node for evaluation of this Expr
* @param aCs the ContextState containing the stack information needed
* for evaluation
* @return the result of the evaluation
*/
nsresult
txKeyFunctionCall::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
{
if (!aContext || !requireParams(2, 2, aContext))
return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
txExecutionState* es =
static_cast<txExecutionState*>(aContext->getPrivateContext());
nsAutoString keyQName;
nsresult rv = mParams[0]->evaluateToString(aContext, keyQName);
NS_ENSURE_SUCCESS(rv, rv);
txExpandedName keyName;
rv = keyName.init(keyQName, mMappings, false);
NS_ENSURE_SUCCESS(rv, rv);
RefPtr<txAExprResult> exprResult;
rv = mParams[1]->evaluate(aContext, getter_AddRefs(exprResult));
NS_ENSURE_SUCCESS(rv, rv);
txXPathTreeWalker walker(aContext->getContextNode());
walker.moveToRoot();
RefPtr<txNodeSet> res;
txNodeSet* nodeSet;
if (exprResult->getResultType() == txAExprResult::NODESET &&
(nodeSet = static_cast<txNodeSet*>
(static_cast<txAExprResult*>
(exprResult)))->size() > 1) {
rv = aContext->recycler()->getNodeSet(getter_AddRefs(res));
NS_ENSURE_SUCCESS(rv, rv);
int32_t i;
for (i = 0; i < nodeSet->size(); ++i) {
nsAutoString val;
txXPathNodeUtils::appendNodeValue(nodeSet->get(i), val);
RefPtr<txNodeSet> nodes;
rv = es->getKeyNodes(keyName, walker.getCurrentPosition(), val,
i == 0, getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
res->add(*nodes);
}
}
else {
nsAutoString val;
exprResult->stringValue(val);
rv = es->getKeyNodes(keyName, walker.getCurrentPosition(), val,
true, getter_AddRefs(res));
NS_ENSURE_SUCCESS(rv, rv);
}
*aResult = res;
NS_ADDREF(*aResult);
return NS_OK;
}
PassRefPtr<WebCore::TimeRanges> SourceBufferPrivateImpl::buffered()
{
WebTimeRanges webRanges = m_sourceBuffer->buffered();
RefPtr<WebCore::TimeRanges> ranges = WebCore::TimeRanges::create();
for (size_t i = 0; i < webRanges.size(); ++i)
ranges->add(webRanges[i].start, webRanges[i].end);
return ranges.release();
}
PassRefPtr<TimeRanges> MediaPlayerPrivate::buffered() const
{
RefPtr<TimeRanges> timeRanges = TimeRanges::create();
float loaded = maxTimeLoaded();
if (!m_errorOccured && !m_isStreaming && loaded > 0)
timeRanges->add(0, loaded);
return timeRanges.release();
}
TEST(TimeRanges, AddOrder)
{
RefPtr<TimeRanges> rangeA = TimeRanges::create();
RefPtr<TimeRanges> rangeB = TimeRanges::create();
rangeA->add(0, 2);
rangeA->add(3, 4);
rangeA->add(5, 100);
std::string expected = "{ [0,2) [3,4) [5,100) }";
ASSERT_RANGE(expected, rangeA);
// Add the values in rangeA to rangeB in reverse order.
for (int i = rangeA->length() - 1; i >= 0; --i)
rangeB->add(rangeA->start(i, IGNORE_EXCEPTION), rangeA->end(i, IGNORE_EXCEPTION));
ASSERT_RANGE(expected, rangeB);
}
TEST(TimeRanges, IntersectWith_Gaps1)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 2);
rangesA->add(4, 6);
rangesB->add(1, 5);
ASSERT_RANGE("{ [0,2) [4,6) }", rangesA);
ASSERT_RANGE("{ [1,5) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,2) [4,5) }", rangesA);
ASSERT_RANGE("{ [1,5) }", rangesB);
}
PassRefPtr<TimeRanges> MediaPlayerPrivateQuickTimeVisualContext::buffered() const
{
RefPtr<TimeRanges> timeRanges = TimeRanges::create();
float loaded = maxTimeLoaded();
// rtsp streams are not buffered
if (!m_isStreaming && loaded > 0)
timeRanges->add(0, loaded);
return timeRanges.release();
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(RenderObject* renderer, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
#if ENABLE(SVG)
if (!renderer)
return 0;
Document* document = &renderer->document();
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter) {
// Although we did not find the referenced filter, it might exist later
// in the document
document->accessSVGExtensions()->addPendingResource(filterOperation->fragment(), toElement(renderer->node()));
return 0;
}
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this));
for (SVGElement* svgElement = Traversal<SVGElement>::firstChild(filter); svgElement; svgElement = Traversal<SVGElement>::nextSibling(svgElement)) {
if (!svgElement->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(svgElement);
effect = effectElement->build(builder.get(), this);
if (!effect)
continue;
effectElement->setStandardAttributes(effect.get());
builder->add(effectElement->result(), effect);
m_effects.append(effect);
}
return effect;
#else
UNUSED_PARAM(renderer);
UNUSED_PARAM(previousEffect);
UNUSED_PARAM(filterOperation);
return 0;
#endif
}
PassRefPtr<TimeRanges> TimeRanges::create(const blink::WebTimeRanges& webRanges)
{
RefPtr<TimeRanges> ranges = TimeRanges::create();
unsigned size = webRanges.size();
for (unsigned i = 0; i < size; ++i)
ranges->add(webRanges[i].start, webRanges[i].end);
return ranges.release();
}
TEST(TimeRanges, IntersectWith_CompleteOverlap2)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(1, 3);
rangesA->add(4, 5);
rangesA->add(6, 9);
rangesB->add(1, 9);
ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA);
ASSERT_RANGE("{ [1,9) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,3) [4,5) [6,9) }", rangesA);
ASSERT_RANGE("{ [1,9) }", rangesB);
}
TEST(TimeRanges, IntersectWith_DisjointRanges2)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 1);
rangesA->add(4, 5);
rangesB->add(1, 4);
rangesB->add(5, 7);
ASSERT_RANGE("{ [0,1) [4,5) }", rangesA);
ASSERT_RANGE("{ [1,4) [5,7) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ }", rangesA);
ASSERT_RANGE("{ [1,4) [5,7) }", rangesB);
}
PassRefPtr<TimeRanges> TimeRanges::copy() const
{
RefPtr<TimeRanges> newSession = TimeRanges::create();
unsigned size = m_ranges.size();
for (unsigned i = 0; i < size; i++)
newSession->add(m_ranges[i].m_start, m_ranges[i].m_end);
return newSession.release();
}
TEST(TimeRanges, IntersectWith_DisjointRanges1)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 1);
rangesA->add(4, 5);
rangesB->add(2, 3);
rangesB->add(6, 7);
ASSERT_RANGE("{ [0,1) [4,5) }", rangesA);
ASSERT_RANGE("{ [2,3) [6,7) }", rangesB);
rangesA->intersectWith(*rangesB.get());
ASSERT_RANGE("{ }", rangesA);
ASSERT_RANGE("{ [2,3) [6,7) }", rangesB);
}
TEST(TimeRanges, IntersectWith_Gaps3)
{
RefPtr<TimeRanges> rangesA = TimeRanges::create();
RefPtr<TimeRanges> rangesB = TimeRanges::create();
rangesA->add(0, 2);
rangesA->add(4, 7);
rangesA->add(8, 10);
rangesB->add(1, 5);
rangesB->add(6, 9);
ASSERT_RANGE("{ [0,2) [4,7) [8,10) }", rangesA);
ASSERT_RANGE("{ [1,5) [6,9) }", rangesB);
rangesA->intersectWith(rangesB.get());
ASSERT_RANGE("{ [1,2) [4,5) [6,7) [8,9) }", rangesA);
ASSERT_RANGE("{ [1,5) [6,9) }", rangesB);
}
PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::sourceBuffered(const String& id)
{
if (!m_webMediaPlayer)
return TimeRanges::create();
WebTimeRanges webRanges = m_webMediaPlayer->sourceBuffered(id);
RefPtr<TimeRanges> ranges = TimeRanges::create();
for (size_t i = 0; i < webRanges.size(); ++i)
ranges->add(webRanges[i].start, webRanges[i].end);
return ranges.release();
}
void TimeRanges::unionWith(const TimeRanges* other)
{
ASSERT(other);
RefPtr<TimeRanges> unioned = copy();
for (size_t index = 0; index < other->m_ranges.size(); ++index) {
const Range& range = other->m_ranges[index];
unioned->add(range.m_start, range.m_end);
}
m_ranges.swap(unioned->m_ranges);
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(Document* document, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
#if ENABLE(SVG)
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter)
return 0;
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this));
for (Node* node = filter->firstChild(); node; node = node->nextSibling()) {
if (!node->isSVGElement())
continue;
SVGElement* element = static_cast<SVGElement*>(node);
if (!element->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
effect = effectElement->build(builder.get(), this);
if (!effect)
continue;
effectElement->setStandardAttributes(effect.get());
builder->add(effectElement->result(), effect);
m_effects.append(effect);
}
return effect;
#else
UNUSED_PARAM(document);
UNUSED_PARAM(previousEffect);
UNUSED_PARAM(filterOperation);
return 0;
#endif
}
void TimeRanges::invert()
{
RefPtr<TimeRanges> inverted = TimeRanges::create();
double posInf = std::numeric_limits<double>::infinity();
double negInf = -std::numeric_limits<double>::infinity();
if (!m_ranges.size())
inverted->add(negInf, posInf);
else {
if (double start = m_ranges.first().m_start != negInf)
inverted->add(negInf, start);
for (size_t index = 0; index + 1 < m_ranges.size(); ++index)
inverted->add(m_ranges[index].m_end, m_ranges[index + 1].m_start);
if (double end = m_ranges.last().m_end != posInf)
inverted->add(end, posInf);
}
m_ranges.swap(inverted->m_ranges);
}
PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const
{
if (m_webMediaPlayer) {
const WebTimeRanges& webRanges = m_webMediaPlayer->buffered();
// FIXME: Save the time ranges in a member variable and update it when needed.
RefPtr<TimeRanges> ranges = TimeRanges::create();
for (size_t i = 0; i < webRanges.size(); ++i)
ranges->add(webRanges[i].start, webRanges[i].end);
return ranges.release();
}
return TimeRanges::create();
}
PassRefPtr<TimeRanges> MediaPlayerPrivateGStreamer::buffered() const
{
RefPtr<TimeRanges> timeRanges = TimeRanges::create();
if (m_errorOccured || isLiveStream())
return timeRanges.release();
#if GST_CHECK_VERSION(0, 10, 31)
float mediaDuration(duration());
if (!mediaDuration || isinf(mediaDuration))
return timeRanges.release();
GstQuery* query = gst_query_new_buffering(GST_FORMAT_PERCENT);
if (!gst_element_query(m_playBin.get(), query)) {
gst_query_unref(query);
return timeRanges.release();
}
for (guint index = 0; index < gst_query_get_n_buffering_ranges(query); index++) {
gint64 rangeStart = 0, rangeStop = 0;
if (gst_query_parse_nth_buffering_range(query, index, &rangeStart, &rangeStop))
timeRanges->add(static_cast<float>((rangeStart * mediaDuration) / gPercentMax),
static_cast<float>((rangeStop * mediaDuration) / gPercentMax));
}
// Fallback to the more general maxTimeLoaded() if no range has
// been found.
if (!timeRanges->length())
if (float loaded = maxTimeLoaded())
timeRanges->add(0, loaded);
gst_query_unref(query);
#else
float loaded = maxTimeLoaded();
if (!m_errorOccured && !isLiveStream() && loaded > 0)
timeRanges->add(0, loaded);
#endif
return timeRanges.release();
}
PassRefPtr<TimeRanges> MediaPlayerPrivate::buffered() const
{
RefPtr<TimeRanges> buffered = TimeRanges::create();
if (!m_mediaPlayerControl)
return buffered;
QMediaTimeRange playbackRanges = m_mediaPlayerControl->availablePlaybackRanges();
foreach (const QMediaTimeInterval interval, playbackRanges.intervals()) {
float rangeMin = static_cast<float>(interval.start()) / 1000.0f;
float rangeMax = static_cast<float>(interval.end()) / 1000.0f;
buffered->add(rangeMin, rangeMax);
}
return buffered.release();
}
PassRefPtr<PrerenderHandle> Prerenderer::render(PrerenderClient* prerenderClient, const KURL& url)
{
// Prerenders are unlike requests in most ways (for instance, they pass down fragments, and they don't return data),
// but they do have referrers.
const ReferrerPolicy referrerPolicy = document()->referrerPolicy();
if (!document()->frame())
return 0;
const String referrer = SecurityPolicy::generateReferrerHeader(referrerPolicy, url, document()->frame()->loader()->outgoingReferrer());
RefPtr<PrerenderHandle> prerenderHandle = PrerenderHandle::create(prerenderClient, url, referrer, referrerPolicy);
if (client())
client()->willAddPrerender(prerenderHandle.get());
prerenderHandle->add();
m_activeHandles.append(prerenderHandle);
return prerenderHandle;
}
// static
PassOwnPtr<PrerenderHandle> PrerenderHandle::create(Document& document, PrerenderClient* client, const KURL& url)
{
// Prerenders are unlike requests in most ways (for instance, they pass down fragments, and they don't return data),
// but they do have referrers.
const ReferrerPolicy referrerPolicy = document.referrerPolicy();
if (!document.frame())
return PassOwnPtr<PrerenderHandle>();
const String referrer = SecurityPolicy::generateReferrerHeader(referrerPolicy, url, document.frame()->loader().outgoingReferrer());
RefPtr<Prerender> prerender = Prerender::create(client, url, referrer, referrerPolicy);
PrerendererClient* prerendererClient = PrerendererClient::from(document.page());
if (prerendererClient)
prerendererClient->willAddPrerender(prerender.get());
prerender->add();
return adoptPtr(new PrerenderHandle(document, prerender.release()));
}
