PassRefPtr<DOMStringList> IDBDatabase::objectStoreNames() const
{
RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
for (IDBDatabaseMetadata::ObjectStoreMap::const_iterator it = m_metadata.objectStores.begin(); it != m_metadata.objectStores.end(); ++it)
objectStoreNames->append(it->value.name);
objectStoreNames->sort();
return objectStoreNames.release();
}
PassRefPtr<SVGDashArray> AnimatableStrokeDasharrayList::toSVGDashArray(
float zoom) const {
RefPtr<SVGDashArray> lengths = SVGDashArray::create();
for (const auto& dashLength : m_values)
lengths->append(toAnimatableLength(dashLength.get())
->getLength(zoom, ValueRangeNonNegative));
return lengths.release();
}
RefPtr<DOMStringList> LegacyDatabase::objectStoreNames() const
{
RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
for (auto& objectStore : m_metadata.objectStores.values())
objectStoreNames->append(objectStore.name);
objectStoreNames->sort();
return objectStoreNames.release();
}
RefPtr<DOMStringList> IDBDatabase::objectStoreNames() const
{
RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
for (auto& name : m_info.objectStoreNames())
objectStoreNames->append(name);
objectStoreNames->sort();
return WTF::move(objectStoreNames);
}
PassRefPtr<CSSValueList> createBorderImageValue(PassRefPtr<CSSValue> image, PassRefPtr<CSSValue> imageSlice,
PassRefPtr<CSSValue> borderSlice, PassRefPtr<CSSValue> outset, PassRefPtr<CSSValue> repeat)
{
RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
if (image)
list->append(image);
if (borderSlice || outset) {
RefPtr<CSSValueList> listSlash = CSSValueList::createSlashSeparated();
if (imageSlice)
listSlash->append(imageSlice);
if (borderSlice)
listSlash->append(borderSlice);
if (outset)
listSlash->append(outset);
list->append(listSlash);
} else if (imageSlice)
list->append(imageSlice);
if (repeat)
list->append(repeat);
return list.release();
}
PassRefPtr<DOMStringList> IDBObjectStore::indexNames() const
{
LOG(StorageAPI, "IDBObjectStore::indexNames");
RefPtr<DOMStringList> indexNames = DOMStringList::create();
for (auto& index : m_metadata.indexes.values())
indexNames->append(index.name);
indexNames->sort();
return indexNames.release();
}
RefPtr<DOMStringList> IDBObjectStore::indexNames() const
{
RefPtr<DOMStringList> indexNames = DOMStringList::create();
for (auto& name : m_info.indexNames())
indexNames->append(name);
indexNames->sort();
return indexNames;
}
PassRefPtr<EntryArraySync> EntryArraySync::create(EntryArray* entries)
{
RefPtr<EntryArraySync> entriesSync = adoptRef(new EntryArraySync());
if (entries) {
for (unsigned i = 0; i < entries->length(); ++i)
entriesSync->append(EntrySync::create(entries->item(i)));
}
return entriesSync.release();
}
PassRefPtr<DOMStringList> Internals::getReferencedFilePaths() const
{
RefPtr<DOMStringList> stringList = DOMStringList::create();
frame()->loader()->history()->saveDocumentAndScrollState();
const Vector<String>& filePaths = FormController::getReferencedFilePaths(frame()->loader()->history()->currentItem()->documentState());
for (size_t i = 0; i < filePaths.size(); ++i)
stringList->append(filePaths[i]);
return stringList.release();
}
PassRefPtr<DOMStringList> Location::ancestorOrigins() const
{
RefPtr<DOMStringList> origins = DOMStringList::create();
if (!m_frame)
return origins.release();
for (Frame* frame = m_frame->tree()->parent(); frame; frame = frame->tree()->parent())
origins->append(frame->document()->securityOrigin()->toString());
return origins.release();
}
void SVGFontFaceElement::rebuildFontFace()
{
ASSERT(inDocument());
// we currently ignore all but the first src element, alternatively we could concat them
SVGFontFaceSrcElement* srcElement = 0;
SVGDefinitionSrcElement* definitionSrc = 0;
for (Node* child = firstChild(); child; child = child->nextSibling()) {
if (child->hasTagName(font_face_srcTag) && !srcElement)
srcElement = static_cast<SVGFontFaceSrcElement*>(child);
else if (child->hasTagName(definition_srcTag) && !definitionSrc)
definitionSrc = static_cast<SVGDefinitionSrcElement*>(child);
}
#if 0
// @font-face (CSSFontFace) does not yet support definition-src, as soon as it does this code should do the trick!
if (definitionSrc)
m_styleDeclaration->setProperty(CSSPropertyDefinitionSrc, definitionSrc->getAttribute(XLinkNames::hrefAttr), false);
#endif
bool describesParentFont = parentNode()->hasTagName(fontTag);
RefPtr<CSSValueList> list;
if (describesParentFont) {
m_fontElement = static_cast<SVGFontElement*>(parentNode());
list = CSSValueList::createCommaSeparated();
list->append(CSSFontFaceSrcValue::createLocal(fontFamily()));
} else {
m_fontElement = 0;
if (srcElement)
list = srcElement->srcValue();
}
if (!list)
return;
// Parse in-memory CSS rules
CSSProperty srcProperty(CSSPropertySrc, list);
const CSSProperty* srcPropertyRef = &srcProperty;
m_styleDeclaration->addParsedProperties(&srcPropertyRef, 1);
if (describesParentFont) {
// Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
RefPtr<CSSValue> src = m_styleDeclaration->getPropertyCSSValue(CSSPropertySrc);
CSSValueList* srcList = static_cast<CSSValueList*>(src.get());
unsigned srcLength = srcList ? srcList->length() : 0;
for (unsigned i = 0; i < srcLength; i++) {
if (CSSFontFaceSrcValue* item = static_cast<CSSFontFaceSrcValue*>(srcList->itemWithoutBoundsCheck(i)))
item->setSVGFontFaceElement(this);
}
}
document()->updateStyleSelector();
}
JSValue JSDocument::createTouchList(ExecState* exec)
{
RefPtr<TouchList> touchList = TouchList::create();
for (int i = 0; i < exec->argumentCount(); i++)
touchList->append(toTouch(exec->argument(i)));
return toJS(exec, globalObject(), touchList.release());
}
PassRefPtr<DOMStringList> IDBObjectStore::indexNames() const
{
IDB_TRACE("IDBObjectStore::indexNames");
RefPtr<DOMStringList> indexNames = DOMStringList::create();
for (IDBObjectStoreMetadata::IndexMap::const_iterator it = m_metadata.indexes.begin(); it != m_metadata.indexes.end(); ++it)
indexNames->append(it->value.name);
indexNames->sort();
return indexNames.release();
}
static PassRefPtr<IDBTransactionBackendInterface> transactionForDatabase(IDBDatabaseBackendInterface* idbDatabase, const String& objectStoreName)
{
ExceptionCode ec = 0;
RefPtr<DOMStringList> transactionObjectStoreNamesList = DOMStringList::create();
transactionObjectStoreNamesList->append(objectStoreName);
RefPtr<IDBTransactionBackendInterface> idbTransaction = idbDatabase->transaction(transactionObjectStoreNamesList.get(), IDBTransaction::READ_ONLY, ec);
if (ec)
return 0;
return idbTransaction;
}
inline MediaQueryExp::MediaQueryExp(const AtomicString& mediaFeature, CSSParserValueList* valueList)
: m_mediaFeature(mediaFeature)
, m_value(0)
, m_isValid(true)
{
if (valueList) {
if (valueList->size() == 1) {
CSSParserValue* value = valueList->current();
if (value->id != 0)
m_value = CSSPrimitiveValue::createIdentifier(value->id);
else if (value->unit == CSSPrimitiveValue::CSS_STRING)
m_value = CSSPrimitiveValue::create(value->string, (CSSPrimitiveValue::UnitTypes) value->unit);
else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER &&
value->unit <= CSSPrimitiveValue::CSS_KHZ)
m_value = CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
valueList->next();
} else if (valueList->size() > 1) {
// create list of values
// currently accepts only <integer>/<integer>
RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
CSSParserValue* value = valueList->current();
bool isValid = true;
while (value && isValid) {
if (value->unit == CSSParserValue::Operator && value->iValue == '/')
list->append(CSSPrimitiveValue::create("/", CSSPrimitiveValue::CSS_STRING));
else if (value->unit == CSSPrimitiveValue::CSS_NUMBER)
list->append(CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_NUMBER));
else
isValid = false;
value = valueList->next();
}
if (isValid)
m_value = list.release();
}
m_isValid = m_value;
}
}
RefPtr<DOMStringList> IDBDatabase::objectStoreNames() const
{
ASSERT(currentThread() == originThreadID());
RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
for (auto& name : m_info.objectStoreNames())
objectStoreNames->append(name);
objectStoreNames->sort();
return objectStoreNames;
}
String FontFace::unicodeRange() const
{
const_cast<CSSFontFace&>(m_backing.get()).updateStyleIfNeeded();
if (!m_backing->ranges().size())
return ASCIILiteral("U+0-10FFFF");
RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
for (auto& range : m_backing->ranges())
values->append(CSSUnicodeRangeValue::create(range.from, range.to));
return values->cssText();
}
String FontFace::featureSettings() const
{
const_cast<CSSFontFace&>(m_backing.get()).updateStyleIfNeeded();
if (!m_backing->featureSettings().size())
return ASCIILiteral("normal");
RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
for (auto& feature : m_backing->featureSettings())
list->append(CSSFontFeatureValue::create(FontTag(feature.tag()), feature.value()));
return list->cssText();
}
PassRefPtr<FileList> ClipboardWin::files() const
{
#if OS(WINCE)
notImplemented();
return 0;
#else
RefPtr<FileList> files = FileList::create();
if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
return files.release();
if (!m_dataObject && m_dragDataMap.isEmpty())
return files.release();
if (m_dataObject) {
STGMEDIUM medium;
if (FAILED(m_dataObject->GetData(cfHDropFormat(), &medium)))
return files.release();
HDROP hdrop = reinterpret_cast<HDROP>(GlobalLock(medium.hGlobal));
if (!hdrop)
return files.release();
WCHAR filename[MAX_PATH];
UINT fileCount = DragQueryFileW(hdrop, 0xFFFFFFFF, 0, 0);
for (UINT i = 0; i < fileCount; i++) {
if (!DragQueryFileW(hdrop, i, filename, WTF_ARRAY_LENGTH(filename)))
continue;
files->append(File::create(reinterpret_cast<UChar*>(filename), File::AllContentTypes));
}
GlobalUnlock(medium.hGlobal);
ReleaseStgMedium(&medium);
return files.release();
}
if (!m_dragDataMap.contains(cfHDropFormat()->cfFormat))
return files.release();
Vector<String> filesVector = m_dragDataMap.get(cfHDropFormat()->cfFormat);
for (Vector<String>::iterator it = filesVector.begin(); it != filesVector.end(); ++it)
files->append(File::create(*it));
return files.release();
#endif
}
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 IDBRequest::onSuccess(const Vector<String>& stringList)
{
IDB_TRACE("IDBRequest::onSuccess(StringList)");
if (!shouldEnqueueEvent())
return;
RefPtr<DOMStringList> domStringList = DOMStringList::create();
for (size_t i = 0; i < stringList.size(); ++i)
domStringList->append(stringList[i]);
onSuccessInternal(IDBAny::create(domStringList.release()));
}
RefPtr<CSSValue> ComputedStyleExtractor::adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor) const
{
if (paintType >= SVG_PAINTTYPE_URI_NONE) {
RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
values->append(CSSPrimitiveValue::create(url, CSSPrimitiveValue::UnitType::CSS_URI));
if (paintType == SVG_PAINTTYPE_URI_NONE)
values->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
else if (paintType == SVG_PAINTTYPE_URI_CURRENTCOLOR)
values->append(CSSPrimitiveValue::create(currentColor));
else if (paintType == SVG_PAINTTYPE_URI_RGBCOLOR)
values->append(CSSPrimitiveValue::create(color));
return values;
}
if (paintType == SVG_PAINTTYPE_NONE)
return CSSPrimitiveValue::createIdentifier(CSSValueNone);
if (paintType == SVG_PAINTTYPE_CURRENTCOLOR)
return CSSPrimitiveValue::create(currentColor);
return CSSPrimitiveValue::create(color);
}
RefPtr<DOMStringList> IDBObjectStore::indexNames() const
{
ASSERT(currentThread() == m_transaction->database().originThreadID());
RefPtr<DOMStringList> indexNames = DOMStringList::create();
for (auto& name : m_info.indexNames())
indexNames->append(name);
indexNames->sort();
return indexNames;
}
PassRefPtr<DOMStringList> Internals::iconURLs(Document* document) const
{
Vector<IconURL> iconURLs = document->iconURLs();
RefPtr<DOMStringList> stringList = DOMStringList::create();
Vector<IconURL>::const_iterator iter(iconURLs.begin());
for (; iter != iconURLs.end(); ++iter)
stringList->append(iter->m_iconURL.string());
return stringList.release();
}
PassRefPtr<SharedBuffer> DeferredImageDecoder::data() {
if (!m_rwBuffer)
return nullptr;
sk_sp<SkROBuffer> roBuffer(m_rwBuffer->newRBufferSnapshot());
RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create();
SkROBuffer::Iter it(roBuffer.get());
do {
sharedBuffer->append(static_cast<const char*>(it.data()), it.size());
} while (it.next());
return sharedBuffer.release();
}
v8::Handle<v8::Value> V8Document::createTouchListMethodCustom(const v8::Arguments& args)
{
RefPtr<TouchList> touchList = TouchList::create();
for (int i = 0; i < args.Length(); i++) {
Touch* touch = V8DOMWrapper::isWrapperOfType(args[i], &V8Touch::info) ? V8Touch::toNative(args[i]->ToObject()) : 0;
touchList->append(touch);
}
return toV8(touchList.release(), args.Holder(), args.GetIsolate());
}
PassRefPtr<SVGLengthList> AnimatableStrokeDasharrayList::toSVGLengthList() const
{
RefPtr<SVGLengthList> lengths = SVGLengthList::create();
for (size_t i = 0; i < m_values.size(); ++i) {
RefPtr<SVGLength> length = toAnimatableSVGLength(m_values[i].get())->toSVGLength()->clone();
if (length->valueInSpecifiedUnits() < 0)
length->setValueInSpecifiedUnits(0);
lengths->append(length);
}
return lengths.release();
}
PassRefPtr<CSSValue> CSSParser::parseSVGStrokeDasharray()
{
RefPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
CSSParserValue* value = m_valueList->current();
bool valid_primitive = true;
while (value) {
valid_primitive = validUnit(value, FLength | FPercent |FNonNeg, false);
if (!valid_primitive)
break;
if (value->id != 0)
ret->append(CSSPrimitiveValue::createIdentifier(value->id));
else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
ret->append(CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit));
value = m_valueList->next();
if (value && value->unit == CSSParserValue::Operator && value->iValue == ',')
value = m_valueList->next();
}
if (!valid_primitive)
return 0;
return ret.release();
}
static PassRefPtr<CSSValue> strokeDashArrayToCSSValueList(const Vector<SVGLength>& dashes)
{
if (dashes.isEmpty())
return CSSPrimitiveValue::createIdentifier(CSSValueNone);
RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
const Vector<SVGLength>::const_iterator end = dashes.end();
for (Vector<SVGLength>::const_iterator it = dashes.begin(); it != end; ++it)
list->append(SVGLength::toCSSPrimitiveValue(*it));
return list.release();
}
TEST(FastSharedBufferReaderTest, byteByByte)
{
char referenceData[kDefaultTestSize];
prepareReferenceData(referenceData, sizeof(referenceData));
RefPtr<SharedBuffer> data = SharedBuffer::create();
data->append(referenceData, sizeof(referenceData));
FastSharedBufferReader reader(data);
for (size_t i = 0; i < sizeof(referenceData); ++i) {
ASSERT_EQ(referenceData[i], reader.getOneByte(i));
}
}
