Vector<Ref<Element>> HTMLCollection::namedItems(const AtomicString& name) const
{
// FIXME: This non-virtual function can't possibly be doing the correct thing for
// any derived class that overrides the virtual namedItem function.
Vector<Ref<Element>> elements;
if (name.isEmpty())
return elements;
updateNamedElementCache();
ASSERT(m_namedElementCache);
auto* elementsWithId = m_namedElementCache->findElementsWithId(name);
auto* elementsWithName = m_namedElementCache->findElementsWithName(name);
elements.reserveInitialCapacity((elementsWithId ? elementsWithId->size() : 0) + (elementsWithName ? elementsWithName->size() : 0));
if (elementsWithId) {
for (auto& element : *elementsWithId)
elements.uncheckedAppend(*element);
}
if (elementsWithName) {
for (auto& element : *elementsWithName)
elements.uncheckedAppend(*element);
}
return elements;
}
CGGradientRef Gradient::platformGradient()
{
if (m_gradient)
return m_gradient;
sortStopsIfNecessary();
// FIXME: ExtendedColor - we should generate CGColorRefs here, so that
// we can handle color spaces.
const int cReservedStops = 3;
Vector<CGFloat, 4 * cReservedStops> colorComponents;
colorComponents.reserveInitialCapacity(m_stops.size() * 4); // RGBA components per stop
Vector<CGFloat, cReservedStops> locations;
locations.reserveInitialCapacity(m_stops.size());
for (size_t i = 0; i < m_stops.size(); ++i) {
colorComponents.uncheckedAppend(m_stops[i].red);
colorComponents.uncheckedAppend(m_stops[i].green);
colorComponents.uncheckedAppend(m_stops[i].blue);
colorComponents.uncheckedAppend(m_stops[i].alpha);
locations.uncheckedAppend(m_stops[i].stop);
}
// FIXME: ExtendedColor - use CGGradientCreateWithColors so that we can have stops in different color spaces.
m_gradient = CGGradientCreateWithColorComponents(sRGBColorSpaceRef(), colorComponents.data(), locations.data(), m_stops.size());
return m_gradient;
}
void WebContext::pluginInfoStoreDidLoadPlugins(PluginInfoStore* store)
{
#ifdef NDEBUG
UNUSED_PARAM(store);
#endif
ASSERT(store == &m_pluginInfoStore);
Vector<PluginModuleInfo> pluginModules = m_pluginInfoStore.plugins();
Vector<RefPtr<API::Object>> plugins;
plugins.reserveInitialCapacity(pluginModules.size());
for (const auto& pluginModule : pluginModules) {
ImmutableDictionary::MapType map;
map.set(ASCIILiteral("path"), API::String::create(pluginModule.path));
map.set(ASCIILiteral("name"), API::String::create(pluginModule.info.name));
map.set(ASCIILiteral("file"), API::String::create(pluginModule.info.file));
map.set(ASCIILiteral("desc"), API::String::create(pluginModule.info.desc));
Vector<RefPtr<API::Object>> mimeTypes;
mimeTypes.reserveInitialCapacity(pluginModule.info.mimes.size());
for (const auto& mimeClassInfo : pluginModule.info.mimes)
mimeTypes.uncheckedAppend(API::String::create(mimeClassInfo.type));
map.set(ASCIILiteral("mimes"), API::Array::create(std::move(mimeTypes)));
#if PLATFORM(COCOA)
map.set(ASCIILiteral("bundleId"), API::String::create(pluginModule.bundleIdentifier));
map.set(ASCIILiteral("version"), API::String::create(pluginModule.versionString));
#endif
plugins.uncheckedAppend(ImmutableDictionary::create(std::move(map)));
}
m_client.plugInInformationBecameAvailable(this, API::Array::create(std::move(plugins)).get());
}
CGGradientRef Gradient::platformGradient()
{
if (m_gradient)
return m_gradient;
sortStopsIfNecessary();
const int cReservedStops = 3;
Vector<CGFloat, 4 * cReservedStops> colorComponents;
colorComponents.reserveInitialCapacity(m_stops.size() * 4); // RGBA components per stop
Vector<CGFloat, cReservedStops> locations;
locations.reserveInitialCapacity(m_stops.size());
for (size_t i = 0; i < m_stops.size(); ++i) {
colorComponents.uncheckedAppend(m_stops[i].red);
colorComponents.uncheckedAppend(m_stops[i].green);
colorComponents.uncheckedAppend(m_stops[i].blue);
colorComponents.uncheckedAppend(m_stops[i].alpha);
locations.uncheckedAppend(m_stops[i].stop);
}
m_gradient = CGGradientCreateWithColorComponents(deviceRGBColorSpaceRef(), colorComponents.data(), locations.data(), m_stops.size());
return m_gradient;
}
Vector<GamepadData> UIGamepadProvider::snapshotGamepads()
{
Vector<GamepadData> gamepadDatas;
gamepadDatas.reserveInitialCapacity(m_gamepads.size());
for (auto& gamepad : m_gamepads) {
if (gamepad)
gamepadDatas.uncheckedAppend(gamepad->condensedGamepadData());
else
gamepadDatas.uncheckedAppend({ });
}
return gamepadDatas;
}
static RetainPtr<CFDictionaryRef> createDictionary(std::initializer_list<std::pair<CFStringRef, CFTypeRef>> keyValuePairs)
{
Vector<CFTypeRef> keys;
Vector<CFTypeRef> values;
keys.reserveInitialCapacity(keyValuePairs.size());
values.reserveInitialCapacity(keyValuePairs.size());
for (const auto& keyValuePair : keyValuePairs) {
keys.uncheckedAppend(keyValuePair.first);
values.uncheckedAppend(keyValuePair.second);
}
return adoptCF(CFDictionaryCreate(kCFAllocatorDefault, keys.data(), values.data(), keyValuePairs.size(), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
}
void WeakMapData::DeadKeyCleaner::finalizeUnconditionally()
{
if (m_liveKeyCount > m_target->m_map.size() / 2) {
RELEASE_ASSERT(m_liveKeyCount <= m_target->m_map.size());
int deadCount = m_target->m_map.size() - m_liveKeyCount;
if (!deadCount)
return;
Vector<JSObject*> deadEntries;
deadEntries.reserveCapacity(deadCount);
for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
if (Heap::isMarked(it->key))
continue;
deadEntries.uncheckedAppend(it->key);
}
for (size_t i = 0; i < deadEntries.size(); i++)
m_target->m_map.remove(deadEntries[i]);
} else {
MapType newMap;
for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
if (!Heap::isMarked(it->key))
continue;
newMap.add(it->key, it->value);
}
m_target->m_map.swap(newMap);
}
}
void FontCache::invalidate()
{
if (!gClients) {
ASSERT(fontPlatformDataCache().isEmpty());
return;
}
fontPlatformDataCache().clear();
#if ENABLE(OPENTYPE_VERTICAL)
fontVerticalDataCache().clear();
#endif
invalidateFontCascadeCache();
gGeneration++;
Vector<Ref<FontSelector>> clients;
clients.reserveInitialCapacity(gClients->size());
for (auto it = gClients->begin(), end = gClients->end(); it != end; ++it)
clients.uncheckedAppend(**it);
for (unsigned i = 0; i < clients.size(); ++i)
clients[i]->fontCacheInvalidated();
purgeInactiveFontData();
}
bool InjectedBundlePageContextMenuClient::getCustomMenuFromDefaultItems(WebPage& page, const HitTestResult& hitTestResult, const Vector<ContextMenuItem>& proposedMenu, Vector<WebContextMenuItemData>& newMenu, RefPtr<API::Object>& userData)
{
if (!m_client.getContextMenuFromDefaultMenu)
return false;
Vector<WebContextMenuItemData> defaultMenu = kitItems(proposedMenu);
Vector<RefPtr<API::Object>> defaultMenuItems;
defaultMenuItems.reserveInitialCapacity(defaultMenu.size());
for (const auto& item : defaultMenu)
defaultMenuItems.uncheckedAppend(WebContextMenuItem::create(item));
WKArrayRef newMenuWK = nullptr;
WKTypeRef userDataToPass = nullptr;
m_client.getContextMenuFromDefaultMenu(toAPI(&page), toAPI(InjectedBundleHitTestResult::create(hitTestResult).get()), toAPI(API::Array::create(WTF::move(defaultMenuItems)).ptr()), &newMenuWK, &userDataToPass, m_client.base.clientInfo);
RefPtr<API::Array> array = adoptRef(toImpl(newMenuWK));
userData = adoptRef(toImpl(userDataToPass));
newMenu.clear();
if (!array || !array->size())
return true;
size_t size = array->size();
for (size_t i = 0; i < size; ++i) {
WebContextMenuItem* item = array->at<WebContextMenuItem>(i);
if (!item) {
LOG(ContextMenu, "New menu entry at index %i is not a WebContextMenuItem", (int)i);
continue;
}
newMenu.append(*item->data());
}
return true;
}
void WebApplicationCacheManager::getApplicationCacheOrigins(uint64_t callbackID)
{
WebProcess::LocalTerminationDisabler terminationDisabler(WebProcess::shared());
HashSet<RefPtr<SecurityOrigin>, SecurityOriginHash> origins;
cacheStorage().getOriginsWithCache(origins);
Vector<SecurityOriginData> identifiers;
identifiers.reserveCapacity(origins.size());
HashSet<RefPtr<SecurityOrigin>, SecurityOriginHash>::iterator end = origins.end();
HashSet<RefPtr<SecurityOrigin>, SecurityOriginHash>::iterator i = origins.begin();
for (; i != end; ++i) {
RefPtr<SecurityOrigin> origin = *i;
SecurityOriginData originData;
originData.protocol = origin->protocol();
originData.host = origin->host();
originData.port = origin->port();
identifiers.uncheckedAppend(originData);
}
WebProcess::shared().connection()->send(Messages::WebApplicationCacheManagerProxy::DidGetApplicationCacheOrigins(identifiers, callbackID), 0);
}
bool getRawCookies(const Document*, const KURL& url, Vector<Cookie>& rawCookies)
{
rawCookies.clear();
CFHTTPCookieStorageRef cookieStorage = currentCookieStorage();
if (!cookieStorage)
return false;
RetainPtr<CFURLRef> urlCF(AdoptCF, url.createCFURL());
bool sendSecureCookies = url.protocolIs("https");
RetainPtr<CFArrayRef> cookiesCF(AdoptCF, CFHTTPCookieStorageCopyCookiesForURL(cookieStorage, urlCF.get(), sendSecureCookies));
CFIndex count = CFArrayGetCount(cookiesCF.get());
rawCookies.reserveCapacity(count);
for (CFIndex i = 0; i < count; i++) {
CFHTTPCookieRef cookie = (CFHTTPCookieRef)CFArrayGetValueAtIndex(cookiesCF.get(), i);
String name = CFHTTPCookieGetName(cookie);
String value = CFHTTPCookieGetValue(cookie);
String domain = CFHTTPCookieGetDomain(cookie);
String path = CFHTTPCookieGetPath(cookie);
double expires = (CFDateGetAbsoluteTime(CFHTTPCookieGetExpiratonDate(cookie)) + kCFAbsoluteTimeIntervalSince1970) * 1000;
bool httpOnly = CFHTTPCookieIsHTTPOnly(cookie);
bool secure = CFHTTPCookieIsSecure(cookie);
bool session = false; // FIXME: Need API for if a cookie is a session cookie.
rawCookies.uncheckedAppend(Cookie(name, value, domain, path, expires, httpOnly, secure, session));
}
return true;
}
static EncodedJSValue JSC_HOST_CALL constructJSCallback(ExecState* exec)
{
JSObject* constructor = exec->callee();
JSContextRef ctx = toRef(exec);
JSObjectRef constructorRef = toRef(constructor);
JSObjectCallAsConstructorCallback callback = jsCast<JSCallbackConstructor*>(constructor)->callback();
if (callback) {
size_t argumentCount = exec->argumentCount();
Vector<JSValueRef, 16> arguments;
arguments.reserveInitialCapacity(argumentCount);
for (size_t i = 0; i < argumentCount; ++i)
arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
JSValueRef exception = 0;
JSObjectRef result;
{
APICallbackShim callbackShim(exec);
result = callback(ctx, constructorRef, argumentCount, arguments.data(), &exception);
}
if (exception)
exec->vm().throwException(exec, toJS(exec, exception));
// result must be a valid JSValue.
if (!result)
return throwVMTypeError(exec);
return JSValue::encode(toJS(result));
}
return JSValue::encode(toJS(JSObjectMake(ctx, jsCast<JSCallbackConstructor*>(constructor)->classRef(), 0)));
}
RefPtr<API::Object> UserData::transform(API::Object* object, const std::function<RefPtr<API::Object> (const API::Object&)> transformer)
{
if (!object)
return nullptr;
if (object->type() == API::Object::Type::Array) {
auto& array = static_cast<API::Array&>(*object);
Vector<RefPtr<API::Object>> elements;
elements.reserveInitialCapacity(array.elements().size());
for (const auto& element : array.elements())
elements.uncheckedAppend(transform(element.get(), transformer));
return API::Array::create(std::move(elements));
}
if (object->type() == API::Object::Type::Dictionary) {
auto& dictionary = static_cast<ImmutableDictionary&>(*object);
ImmutableDictionary::MapType map;
for (const auto& keyValuePair : dictionary.map())
map.add(keyValuePair.key, transform(keyValuePair.value.get(), transformer));
return ImmutableDictionary::create(std::move(map));
}
if (auto transformedObject = transformer(*object))
return transformedObject;
return object;
}
WebTouchEvent WebEventFactory::createWebTouchEvent(WPE::Input::TouchEvent&& event)
{
WebEvent::Type type = WebEvent::NoType;
switch (event.type) {
case WPE::Input::TouchEvent::Down:
type = WebEvent::TouchStart;
break;
case WPE::Input::TouchEvent::Motion:
type = WebEvent::TouchMove;
break;
case WPE::Input::TouchEvent::Up:
type = WebEvent::TouchEnd;
break;
case WPE::Input::TouchEvent::Null:
ASSERT_NOT_REACHED();
}
Vector<WebKit::WebPlatformTouchPoint> touchPoints;
touchPoints.reserveCapacity(event.touchPoints.size());
for (auto& point : event.touchPoints) {
if (point.type == WPE::Input::TouchEvent::Null)
continue;
touchPoints.uncheckedAppend(WebKit::WebPlatformTouchPoint(point.id, stateForTouchPoint(event.id, point),
WebCore::IntPoint(point.x, point.y), WebCore::IntPoint(point.x, point.y)));
}
return WebTouchEvent(type, WTFMove(touchPoints), WebEvent::Modifiers(0), event.time);
}
WebTouchEvent WebEventFactory::createWebTouchEvent(Ewk_Touch_Event_Type type, const Eina_List* points, const Evas_Modifier* modifiers, const AffineTransform& toWebContent, const AffineTransform& toDeviceScreen, double timestamp)
{
Vector<WebPlatformTouchPoint> touchPoints;
touchPoints.reserveInitialCapacity(eina_list_count(points));
const Eina_List* list;
void* item;
EINA_LIST_FOREACH(points, list, item) {
Ewk_Touch_Point* point = static_cast<Ewk_Touch_Point*>(item);
WebPlatformTouchPoint::TouchPointState state;
switch (point->state) {
case EVAS_TOUCH_POINT_UP:
state = WebPlatformTouchPoint::TouchReleased;
break;
case EVAS_TOUCH_POINT_MOVE:
state = WebPlatformTouchPoint::TouchMoved;
break;
case EVAS_TOUCH_POINT_DOWN:
state = WebPlatformTouchPoint::TouchPressed;
break;
case EVAS_TOUCH_POINT_STILL:
state = WebPlatformTouchPoint::TouchStationary;
break;
case EVAS_TOUCH_POINT_CANCEL:
state = WebPlatformTouchPoint::TouchCancelled;
break;
default:
ASSERT_NOT_REACHED();
continue;
}
IntPoint pos(point->x, point->y);
touchPoints.uncheckedAppend(WebPlatformTouchPoint(point->id, state, toDeviceScreen.mapPoint(pos), toWebContent.mapPoint(pos)));
}
EncodedJSValue JSCallbackFunction::call(ExecState* exec)
{
JSContextRef execRef = toRef(exec);
JSObjectRef functionRef = toRef(exec->callee());
JSObjectRef thisObjRef = toRef(exec->hostThisValue().toThisObject(exec));
size_t argumentCount = exec->argumentCount();
Vector<JSValueRef, 16> arguments;
arguments.reserveInitialCapacity(argumentCount);
for (size_t i = 0; i < argumentCount; ++i)
arguments.uncheckedAppend(toRef(exec, exec->argument(i)));
JSValueRef exception = 0;
JSValueRef result;
{
APICallbackShim callbackShim(exec);
result = jsCast<JSCallbackFunction*>(toJS(functionRef))->m_callback(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
}
if (exception)
throwError(exec, toJS(exec, exception));
// result must be a valid JSValue.
if (!result)
return JSValue::encode(jsUndefined());
return JSValue::encode(toJS(exec, result));
}
EncodedJSValue JSC_HOST_CALL mathProtoFuncHypot(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
unsigned argsCount = exec->argumentCount();
double max = 0;
Vector<double, 8> args;
args.reserveInitialCapacity(argsCount);
for (unsigned i = 0; i < argsCount; ++i) {
args.uncheckedAppend(exec->uncheckedArgument(i).toNumber(exec));
RETURN_IF_EXCEPTION(scope, encodedJSValue());
if (std::isinf(args[i]))
return JSValue::encode(jsDoubleNumber(+std::numeric_limits<double>::infinity()));
max = std::max(fabs(args[i]), max);
}
if (!max)
max = 1;
// Kahan summation algorithm significantly reduces the numerical error in the total obtained.
double sum = 0;
double compensation = 0;
for (double argument : args) {
double scaledArgument = argument / max;
double summand = scaledArgument * scaledArgument - compensation;
double preliminary = sum + summand;
compensation = (preliminary - sum) - summand;
sum = preliminary;
}
return JSValue::encode(jsDoubleNumber(sqrt(sum) * max));
}
void NetscapePluginModule::parseMIMEDescription(const String& mimeDescription, Vector<MimeClassInfo>& result)
{
ASSERT_ARG(result, result.isEmpty());
Vector<String> types;
mimeDescription.lower().split(UChar(';'), false, types);
result.reserveInitialCapacity(types.size());
size_t mimeInfoCount = 0;
for (size_t i = 0; i < types.size(); ++i) {
Vector<String> mimeTypeParts;
types[i].split(UChar(':'), true, mimeTypeParts);
if (mimeTypeParts.size() <= 0)
continue;
result.uncheckedAppend(MimeClassInfo());
MimeClassInfo& mimeInfo = result[mimeInfoCount++];
mimeInfo.type = mimeTypeParts[0];
if (mimeTypeParts.size() > 1)
mimeTypeParts[1].split(UChar(','), false, mimeInfo.extensions);
if (mimeTypeParts.size() > 2)
mimeInfo.desc = mimeTypeParts[2];
}
}
bool getRawCookies(const NetworkStorageSession& session, const KURL& /*firstParty*/, const KURL& url, Vector<Cookie>& rawCookies)
{
rawCookies.clear();
RetainPtr<CFURLRef> urlCF = adoptCF(url.createCFURL());
bool sendSecureCookies = url.protocolIs("https");
RetainPtr<CFArrayRef> cookiesCF = adoptCF(CFHTTPCookieStorageCopyCookiesForURL(session.cookieStorage().get(), urlCF.get(), sendSecureCookies));
CFIndex count = CFArrayGetCount(cookiesCF.get());
rawCookies.reserveCapacity(count);
for (CFIndex i = 0; i < count; i++) {
CFHTTPCookieRef cookie = (CFHTTPCookieRef)CFArrayGetValueAtIndex(cookiesCF.get(), i);
String name = cookieName(cookie).get();
String value = cookieValue(cookie).get();
String domain = cookieDomain(cookie).get();
String path = cookiePath(cookie).get();
double expires = (cookieExpirationTime(cookie) + kCFAbsoluteTimeIntervalSince1970) * 1000;
bool httpOnly = CFHTTPCookieIsHTTPOnly(cookie);
bool secure = CFHTTPCookieIsSecure(cookie);
bool session = false; // FIXME: Need API for if a cookie is a session cookie.
rawCookies.uncheckedAppend(Cookie(name, value, domain, path, expires, httpOnly, secure, session));
}
return true;
}
void StatisticsRequest::completedRequest(uint64_t requestID, const StatisticsData& data)
{
ASSERT(m_outstandingRequests.contains(requestID));
m_outstandingRequests.remove(requestID);
if (!m_responseDictionary)
m_responseDictionary = MutableDictionary::create();
// FIXME (Multi-WebProcess) <rdar://problem/13200059>: This code overwrites any previous response data received.
// When getting responses from multiple WebProcesses we need to combine items instead of clobbering them.
addToDictionaryFromHashMap(m_responseDictionary.get(), data.statisticsNumbers);
if (!data.javaScriptProtectedObjectTypeCounts.isEmpty())
m_responseDictionary->set("JavaScriptProtectedObjectTypeCounts", createDictionaryFromHashMap(data.javaScriptProtectedObjectTypeCounts).get());
if (!data.javaScriptObjectTypeCounts.isEmpty())
m_responseDictionary->set("JavaScriptObjectTypeCounts", createDictionaryFromHashMap(data.javaScriptObjectTypeCounts).get());
if (!data.webCoreCacheStatistics.isEmpty()) {
Vector<RefPtr<API::Object>> cacheStatistics;
cacheStatistics.reserveInitialCapacity(data.webCoreCacheStatistics.size());
for (const auto& statistic : data.webCoreCacheStatistics)
cacheStatistics.uncheckedAppend(createDictionaryFromHashMap(statistic));
m_responseDictionary->set("WebCoreCacheStatistics", API::Array::create(WTF::move(cacheStatistics)).get());
}
if (m_outstandingRequests.isEmpty()) {
m_callback->performCallbackWithReturnValue(m_responseDictionary.get());
m_callback = 0;
}
}
void RenderView::updateWidgetPositions()
{
// updateWidgetPosition() can possibly cause layout to be re-entered (via plug-ins running
// scripts in response to NPP_SetWindow, for example), so we need to keep the Widgets
// alive during enumeration.
size_t size = m_widgets.size();
Vector<RenderWidget*> renderWidgets;
renderWidgets.reserveCapacity(size);
RenderWidgetSet::const_iterator end = m_widgets.end();
for (RenderWidgetSet::const_iterator it = m_widgets.begin(); it != end; ++it) {
renderWidgets.uncheckedAppend(*it);
(*it)->ref();
}
for (size_t i = 0; i < size; ++i)
renderWidgets[i]->updateWidgetPosition();
for (size_t i = 0; i < size; ++i)
renderWidgets[i]->widgetPositionsUpdated();
for (size_t i = 0; i < size; ++i)
renderWidgets[i]->deref(renderArena());
}
Vector<SecurityOriginData> LocalStorageDatabaseTracker::deleteDatabasesModifiedSince(std::chrono::system_clock::time_point time)
{
Vector<String> originIdentifiersToDelete;
for (const String& origin : m_origins) {
String filePath = pathForDatabaseWithOriginIdentifier(origin);
auto modificationTime = fileModificationTime(filePath);
if (!modificationTime)
continue;
if (modificationTime.value() >= std::chrono::system_clock::to_time_t(time))
originIdentifiersToDelete.append(origin);
}
Vector<SecurityOriginData> deletedDatabaseOrigins;
deletedDatabaseOrigins.reserveInitialCapacity(originIdentifiersToDelete.size());
for (const auto& originIdentifier : originIdentifiersToDelete) {
removeDatabaseWithOriginIdentifier(originIdentifier);
if (auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier))
deletedDatabaseOrigins.uncheckedAppend(*origin);
else
ASSERT_NOT_REACHED();
}
return deletedDatabaseOrigins;
}
Ref<FileList> FileInputType::createFileList(const Vector<FileChooserFileInfo>& files)
{
Vector<RefPtr<File>> fileObjects;
fileObjects.reserveInitialCapacity(files.size());
for (auto& info : files)
fileObjects.uncheckedAppend(File::createWithName(info.path, info.displayName));
return FileList::create(WTFMove(fileObjects));
}
Vector<float> SVGNumberList::toFloatVector() const
{
Vector<float> vec;
vec.reserveInitialCapacity(length());
for (size_t i = 0; i < length(); ++i)
vec.uncheckedAppend(at(i)->value());
return vec;
}
Vector<String> IDBDatabaseInfo::objectStoreNames() const
{
Vector<String> names;
names.reserveCapacity(m_objectStoreMap.size());
for (auto& objectStore : m_objectStoreMap.values())
names.uncheckedAppend(objectStore.name());
return names;
}
Vector<uint64_t> DFANode::actions(const DFA& dfa) const
{
// FIXME: Use iterators instead of copying the Vector elements.
Vector<uint64_t> vector;
vector.reserveInitialCapacity(m_actionsLength);
for (uint32_t i = m_actionsStart; i < m_actionsStart + m_actionsLength; ++i)
vector.uncheckedAppend(dfa.actions[i]);
return vector;
}
Vector<String> IDBObjectStoreInfo::indexNames() const
{
Vector<String> names;
names.reserveCapacity(m_indexMap.size());
for (auto& index : m_indexMap.values())
names.uncheckedAppend(index.name());
return names;
}
Vector<AtomicString> EventListenerMap::eventTypes() const {
Vector<AtomicString> types;
types.reserveInitialCapacity(m_entries.size());
for (const auto& entry : m_entries)
types.uncheckedAppend(entry.first);
return types;
}
static inline Vector<IntPoint> createVectorWithWKArray(WKArrayRef array, size_t size)
{
Vector<IntPoint> points;
points.reserveCapacity(size);
for (size_t i = 0; i < size; ++i)
points.uncheckedAppend(toIntPoint(getPointAtIndex(array, i)));
return points;
}
static Vector<String> sortLocaleData(const String& locale, size_t keyIndex)
{
// 9.1 Internal slots of Service Constructors & 10.2.3 Internal slots (ECMA-402 2.0)
Vector<String> keyLocaleData;
switch (keyIndex) {
case indexOfExtensionKeyCo: {
// 10.2.3 "The first element of [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co must be null for all locale values."
keyLocaleData.append({ });
UErrorCode status = U_ZERO_ERROR;
UEnumeration* enumeration = ucol_getKeywordValuesForLocale("collation", locale.utf8().data(), false, &status);
if (U_SUCCESS(status)) {
const char* collation;
while ((collation = uenum_next(enumeration, nullptr, &status)) && U_SUCCESS(status)) {
// 10.2.3 "The values "standard" and "search" must not be used as elements in any [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co array."
if (!strcmp(collation, "standard") || !strcmp(collation, "search"))
continue;
// Map keyword values to BCP 47 equivalents.
if (!strcmp(collation, "dictionary"))
collation = "dict";
else if (!strcmp(collation, "gb2312han"))
collation = "gb2312";
else if (!strcmp(collation, "phonebook"))
collation = "phonebk";
else if (!strcmp(collation, "traditional"))
collation = "trad";
keyLocaleData.append(collation);
}
uenum_close(enumeration);
}
break;
}
case indexOfExtensionKeyKn:
keyLocaleData.reserveInitialCapacity(2);
keyLocaleData.uncheckedAppend(ASCIILiteral("false"));
keyLocaleData.uncheckedAppend(ASCIILiteral("true"));
break;
default:
ASSERT_NOT_REACHED();
}
return keyLocaleData;
}
