void logError(const char *errorMessage) override
{
if (!mFailureId) {
return;
}
nsCString str(errorMessage);
Tokenizer tokenizer(str);
// Parse "ANGLE Display::initialize error " << error.getID() << ": "
// << error.getMessage()
nsCString currWord;
Tokenizer::Token intToken;
if (tokenizer.CheckWord("ANGLE") &&
tokenizer.CheckWhite() &&
tokenizer.CheckWord("Display") &&
tokenizer.CheckChar(':') &&
tokenizer.CheckChar(':') &&
tokenizer.CheckWord("initialize") &&
tokenizer.CheckWhite() &&
tokenizer.CheckWord("error") &&
tokenizer.CheckWhite() &&
tokenizer.Check(Tokenizer::TOKEN_INTEGER, intToken)) {
*mFailureId = "FAILURE_ID_ANGLE_ID_";
mFailureId->AppendPrintf("%i", intToken.AsInteger());
} else {
*mFailureId = "FAILURE_ID_ANGLE_UNKNOWN";
}
}
TEST(Tokenizer, HasFailed)
{
Tokenizer::Token t;
// HasFailed test
Tokenizer p1(NS_LITERAL_CSTRING("a b"));
while (p1.Next(t) && t.Type() != Tokenizer::TOKEN_CHAR);
EXPECT_TRUE(p1.HasFailed());
Tokenizer p2(NS_LITERAL_CSTRING("a b"));
EXPECT_FALSE(p2.CheckChar('c'));
EXPECT_TRUE(p2.HasFailed());
EXPECT_TRUE(p2.CheckChar(HttpHeaderCharacter));
EXPECT_FALSE(p2.HasFailed());
p2.SkipWhites();
EXPECT_FALSE(p2.HasFailed());
EXPECT_TRUE(p2.Next(t));
EXPECT_FALSE(p2.HasFailed());
EXPECT_TRUE(p2.Next(t));
EXPECT_FALSE(p2.HasFailed());
EXPECT_FALSE(p2.CheckChar('c'));
EXPECT_TRUE(p2.HasFailed());
while (p2.Next(t) && t.Type() != Tokenizer::TOKEN_CHAR);
EXPECT_TRUE(p2.HasFailed());
}
TEST(Tokenizer, BadInteger)
{
Tokenizer::Token t;
// A bad integer test
Tokenizer p(NS_LITERAL_CSTRING("189234891274981758617846178651647620587135"));
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_ERROR);
EXPECT_TRUE(p.CheckEOF());
}
int main(int argc, char **argv)
{
// Buffer to analyze, if content is into a file it must be read and
// allocated in memory before tokenization
std::string buffer("an example to tokenize");
// Allocate a tokenizer without wiki synthax support (second
// argument) which generate single word (with a minimal size of 3)
Tokenizer::Tokenizer tokenizer(1, 3);
tokenizer.setBufferToAnalyze(buffer.c_str(), buffer.size());
while (!tokenizer.eof()){
Tokenizer::Token tok = tokenizer.getNextToken();
std::cout << std::string(tok.getContent(), tok.getSize()) << std::endl;
}
}
TEST(Tokenizer, CheckExpectedTokenValue)
{
Tokenizer::Token t;
// Check expected token value test
Tokenizer p(NS_LITERAL_CSTRING("blue velvet"));
EXPECT_FALSE(p.Check(Tokenizer::TOKEN_INTEGER, t));
EXPECT_TRUE(p.Check(Tokenizer::TOKEN_WORD, t));
EXPECT_TRUE(t.AsString() == "blue");
EXPECT_FALSE(p.Check(Tokenizer::TOKEN_WORD, t));
EXPECT_TRUE(p.CheckWhite());
EXPECT_TRUE(p.Check(Tokenizer::TOKEN_WORD, t));
EXPECT_TRUE(t.AsString() == "velvet");
EXPECT_TRUE(p.CheckEOF());
EXPECT_FALSE(p.Next(t));
}
TEST(Tokenizer, Main)
{
Tokenizer::Token t;
// Synthetic code-specific test
Tokenizer p(NS_LITERAL_CSTRING("test123 ,15 \t*\r\n%xx,-15\r\r"));
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_WORD);
EXPECT_TRUE(t.AsString() == "test123");
Tokenizer::Token u;
EXPECT_FALSE(p.Check(u));
EXPECT_FALSE(p.CheckChar('!'));
EXPECT_FALSE(p.Check(Tokenizer::Token::Number(123)));
EXPECT_TRUE(p.CheckWhite());
EXPECT_TRUE(p.CheckChar(','));
EXPECT_TRUE(p.Check(Tokenizer::Token::Number(15)));
p.Rollback();
EXPECT_TRUE(p.Check(Tokenizer::Token::Number(15)));
p.Rollback();
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_INTEGER);
EXPECT_TRUE(t.AsInteger() == 15);
EXPECT_FALSE(p.CheckChar(IsOperator));
EXPECT_TRUE(p.CheckWhite());
p.SkipWhites();
EXPECT_FALSE(p.CheckWhite());
p.Rollback();
EXPECT_TRUE(p.CheckWhite());
EXPECT_TRUE(p.CheckWhite());
p.Record(Tokenizer::EXCLUDE_LAST);
EXPECT_TRUE(p.CheckChar(IsOperator));
p.Rollback();
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_CHAR);
EXPECT_TRUE(t.AsChar() == '*');
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_EOL);
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_CHAR);
EXPECT_TRUE(t.AsChar() == '%');
nsAutoCString claim;
p.Claim(claim, Tokenizer::EXCLUDE_LAST);
EXPECT_TRUE(claim == "*\r\n");
p.Claim(claim, Tokenizer::INCLUDE_LAST);
EXPECT_TRUE(claim == "*\r\n%");
p.Rollback();
EXPECT_TRUE(p.CheckChar('%'));
p.Record(Tokenizer::INCLUDE_LAST);
EXPECT_FALSE(p.CheckWord("xy"));
EXPECT_TRUE(p.CheckWord("xx"));
p.Claim(claim, Tokenizer::INCLUDE_LAST);
EXPECT_TRUE(claim == "%xx");
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_CHAR);
EXPECT_TRUE(t.AsChar() == ',');
EXPECT_TRUE(p.CheckChar('-'));
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_INTEGER);
EXPECT_TRUE(t.AsInteger() == 15);
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_EOL);
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_EOL);
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_EOF);
EXPECT_FALSE(p.Next(t));
p.Rollback();
EXPECT_TRUE(p.Next(t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_EOF);
EXPECT_FALSE(p.Next(t));
p.Rollback();
EXPECT_TRUE(p.CheckEOF());
EXPECT_FALSE(p.CheckEOF());
}
TEST(Tokenizer, HTTPResponse)
{
Tokenizer::Token t;
// Real life test, HTTP response
Tokenizer p(NS_LITERAL_CSTRING(
"HTTP/1.0 304 Not modified\r\n"
"ETag: hallo\r\n"
"Content-Length: 16\r\n"
"\r\n"
"This is the body"));
EXPECT_TRUE(p.CheckWord("HTTP"));
EXPECT_TRUE(p.CheckChar('/'));
EXPECT_TRUE(p.Check(Tokenizer::TOKEN_INTEGER, t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_INTEGER);
EXPECT_TRUE(t.AsInteger() == 1);
EXPECT_TRUE(p.CheckChar('.'));
EXPECT_TRUE(p.Check(Tokenizer::TOKEN_INTEGER, t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_INTEGER);
EXPECT_TRUE(t.AsInteger() == 0);
p.SkipWhites();
EXPECT_TRUE(p.Check(Tokenizer::TOKEN_INTEGER, t));
EXPECT_TRUE(t.Type() == Tokenizer::TOKEN_INTEGER);
EXPECT_TRUE(t.AsInteger() == 304);
p.SkipWhites();
p.Record();
while (p.Next(t) && t.Type() != Tokenizer::TOKEN_EOL);
EXPECT_FALSE(p.HasFailed());
nsAutoCString h;
p.Claim(h);
EXPECT_TRUE(h == "Not modified");
p.Record();
while (p.CheckChar(HttpHeaderCharacter));
p.Claim(h, Tokenizer::INCLUDE_LAST);
EXPECT_TRUE(h == "ETag");
p.SkipWhites();
EXPECT_TRUE(p.CheckChar(':'));
p.SkipWhites();
p.Record();
while (p.Next(t) && t.Type() != Tokenizer::TOKEN_EOL);
EXPECT_FALSE(p.HasFailed());
p.Claim(h);
EXPECT_TRUE(h == "hallo");
p.Record();
while (p.CheckChar(HttpHeaderCharacter));
p.Claim(h, Tokenizer::INCLUDE_LAST);
EXPECT_TRUE(h == "Content-Length");
p.SkipWhites();
EXPECT_TRUE(p.CheckChar(':'));
p.SkipWhites();
EXPECT_TRUE(p.Check(Tokenizer::TOKEN_INTEGER, t));
EXPECT_TRUE(t.AsInteger() == 16);
EXPECT_TRUE(p.CheckEOL());
EXPECT_TRUE(p.CheckEOL());
p.Record();
while (p.Next(t) && t.Type() != Tokenizer::TOKEN_EOF);
nsAutoCString b;
p.Claim(b);
EXPECT_TRUE(b == "This is the body");
}
nsresult
nsSystemInfo::Init()
{
nsresult rv;
static const struct
{
PRSysInfo cmd;
const char* name;
} items[] = {
{ PR_SI_SYSNAME, "name" },
{ PR_SI_HOSTNAME, "host" },
{ PR_SI_ARCHITECTURE, "arch" },
{ PR_SI_RELEASE, "version" }
};
for (uint32_t i = 0; i < (sizeof(items) / sizeof(items[0])); i++) {
char buf[SYS_INFO_BUFFER_LENGTH];
if (PR_GetSystemInfo(items[i].cmd, buf, sizeof(buf)) == PR_SUCCESS) {
rv = SetPropertyAsACString(NS_ConvertASCIItoUTF16(items[i].name),
nsDependentCString(buf));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
} else {
NS_WARNING("PR_GetSystemInfo failed");
}
}
rv = SetPropertyAsBool(NS_ConvertASCIItoUTF16("hasWindowsTouchInterface"),
false);
NS_ENSURE_SUCCESS(rv, rv);
// Additional informations not available through PR_GetSystemInfo.
SetInt32Property(NS_LITERAL_STRING("pagesize"), PR_GetPageSize());
SetInt32Property(NS_LITERAL_STRING("pageshift"), PR_GetPageShift());
SetInt32Property(NS_LITERAL_STRING("memmapalign"), PR_GetMemMapAlignment());
SetUint64Property(NS_LITERAL_STRING("memsize"), PR_GetPhysicalMemorySize());
SetUint32Property(NS_LITERAL_STRING("umask"), nsSystemInfo::gUserUmask);
uint64_t virtualMem = 0;
nsAutoCString cpuVendor;
int cpuSpeed = -1;
int cpuFamily = -1;
int cpuModel = -1;
int cpuStepping = -1;
int logicalCPUs = -1;
int physicalCPUs = -1;
int cacheSizeL2 = -1;
int cacheSizeL3 = -1;
#if defined (XP_WIN)
// Virtual memory:
MEMORYSTATUSEX memStat;
memStat.dwLength = sizeof(memStat);
if (GlobalMemoryStatusEx(&memStat)) {
virtualMem = memStat.ullTotalVirtual;
}
// CPU speed
HKEY key;
static const WCHAR keyName[] =
L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0";
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key)
== ERROR_SUCCESS) {
DWORD data, len, vtype;
len = sizeof(data);
if (RegQueryValueEx(key, L"~Mhz", 0, 0, reinterpret_cast<LPBYTE>(&data),
&len) == ERROR_SUCCESS) {
cpuSpeed = static_cast<int>(data);
}
// Limit to 64 double byte characters, should be plenty, but create
// a buffer one larger as the result may not be null terminated. If
// it is more than 64, we will not get the value.
wchar_t cpuVendorStr[64+1];
len = sizeof(cpuVendorStr)-2;
if (RegQueryValueExW(key, L"VendorIdentifier",
0, &vtype,
reinterpret_cast<LPBYTE>(cpuVendorStr),
&len) == ERROR_SUCCESS &&
vtype == REG_SZ && len % 2 == 0 && len > 1) {
cpuVendorStr[len/2] = 0; // In case it isn't null terminated
CopyUTF16toUTF8(nsDependentString(cpuVendorStr), cpuVendor);
}
RegCloseKey(key);
}
// Other CPU attributes:
SYSTEM_INFO si;
GetNativeSystemInfo(&si);
logicalCPUs = si.dwNumberOfProcessors;
GetProcessorInformation(&physicalCPUs, &cacheSizeL2, &cacheSizeL3);
if (physicalCPUs <= 0) {
physicalCPUs = logicalCPUs;
}
cpuFamily = si.wProcessorLevel;
cpuModel = si.wProcessorRevision >> 8;
cpuStepping = si.wProcessorRevision & 0xFF;
#elif defined (XP_MACOSX)
// CPU speed
uint64_t sysctlValue64 = 0;
uint32_t sysctlValue32 = 0;
size_t len = 0;
len = sizeof(sysctlValue64);
if (!sysctlbyname("hw.cpufrequency_max", &sysctlValue64, &len, NULL, 0)) {
cpuSpeed = static_cast<int>(sysctlValue64/1000000);
}
MOZ_ASSERT(sizeof(sysctlValue64) == len);
len = sizeof(sysctlValue32);
if (!sysctlbyname("hw.physicalcpu_max", &sysctlValue32, &len, NULL, 0)) {
physicalCPUs = static_cast<int>(sysctlValue32);
}
MOZ_ASSERT(sizeof(sysctlValue32) == len);
len = sizeof(sysctlValue32);
if (!sysctlbyname("hw.logicalcpu_max", &sysctlValue32, &len, NULL, 0)) {
logicalCPUs = static_cast<int>(sysctlValue32);
}
MOZ_ASSERT(sizeof(sysctlValue32) == len);
len = sizeof(sysctlValue64);
if (!sysctlbyname("hw.l2cachesize", &sysctlValue64, &len, NULL, 0)) {
cacheSizeL2 = static_cast<int>(sysctlValue64/1024);
}
MOZ_ASSERT(sizeof(sysctlValue64) == len);
len = sizeof(sysctlValue64);
if (!sysctlbyname("hw.l3cachesize", &sysctlValue64, &len, NULL, 0)) {
cacheSizeL3 = static_cast<int>(sysctlValue64/1024);
}
MOZ_ASSERT(sizeof(sysctlValue64) == len);
if (!sysctlbyname("machdep.cpu.vendor", NULL, &len, NULL, 0)) {
char* cpuVendorStr = new char[len];
if (!sysctlbyname("machdep.cpu.vendor", cpuVendorStr, &len, NULL, 0)) {
cpuVendor = cpuVendorStr;
}
delete [] cpuVendorStr;
}
len = sizeof(sysctlValue32);
if (!sysctlbyname("machdep.cpu.family", &sysctlValue32, &len, NULL, 0)) {
cpuFamily = static_cast<int>(sysctlValue32);
}
MOZ_ASSERT(sizeof(sysctlValue32) == len);
len = sizeof(sysctlValue32);
if (!sysctlbyname("machdep.cpu.model", &sysctlValue32, &len, NULL, 0)) {
cpuModel = static_cast<int>(sysctlValue32);
}
MOZ_ASSERT(sizeof(sysctlValue32) == len);
len = sizeof(sysctlValue32);
if (!sysctlbyname("machdep.cpu.stepping", &sysctlValue32, &len, NULL, 0)) {
cpuStepping = static_cast<int>(sysctlValue32);
}
MOZ_ASSERT(sizeof(sysctlValue32) == len);
#elif defined (MOZ_WIDGET_GTK)
// Get vendor, family, model, stepping, physical cores, L3 cache size
// from /proc/cpuinfo file
{
std::map<nsCString, nsCString> keyValuePairs;
SimpleParseKeyValuePairs("/proc/cpuinfo", keyValuePairs);
// cpuVendor from "vendor_id"
cpuVendor.Assign(keyValuePairs[NS_LITERAL_CSTRING("vendor_id")]);
{
// cpuFamily from "cpu family"
Tokenizer::Token t;
Tokenizer p(keyValuePairs[NS_LITERAL_CSTRING("cpu family")]);
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
cpuFamily = static_cast<int>(t.AsInteger());
}
}
{
// cpuModel from "model"
Tokenizer::Token t;
Tokenizer p(keyValuePairs[NS_LITERAL_CSTRING("model")]);
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
cpuModel = static_cast<int>(t.AsInteger());
}
}
{
// cpuStepping from "stepping"
Tokenizer::Token t;
Tokenizer p(keyValuePairs[NS_LITERAL_CSTRING("stepping")]);
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
cpuStepping = static_cast<int>(t.AsInteger());
}
}
{
// physicalCPUs from "cpu cores"
Tokenizer::Token t;
Tokenizer p(keyValuePairs[NS_LITERAL_CSTRING("cpu cores")]);
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
physicalCPUs = static_cast<int>(t.AsInteger());
}
}
{
// cacheSizeL3 from "cache size"
Tokenizer::Token t;
Tokenizer p(keyValuePairs[NS_LITERAL_CSTRING("cache size")]);
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
cacheSizeL3 = static_cast<int>(t.AsInteger());
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_WORD &&
t.AsString() != NS_LITERAL_CSTRING("KB")) {
// If we get here, there was some text after the cache size value
// and that text was not KB. For now, just don't report the
// L3 cache.
cacheSizeL3 = -1;
}
}
}
}
{
// Get cpuSpeed from another file.
std::ifstream input("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq");
std::string line;
if (getline(input, line)) {
Tokenizer::Token t;
Tokenizer p(line.c_str());
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
cpuSpeed = static_cast<int>(t.AsInteger()/1000);
}
}
}
{
// Get cacheSizeL2 from yet another file
std::ifstream input("/sys/devices/system/cpu/cpu0/cache/index2/size");
std::string line;
if (getline(input, line)) {
Tokenizer::Token t;
Tokenizer p(line.c_str(), nullptr, "K");
if (p.Next(t) && t.Type() == Tokenizer::TOKEN_INTEGER &&
t.AsInteger() <= INT32_MAX) {
cacheSizeL2 = static_cast<int>(t.AsInteger());
}
}
}
SetInt32Property(NS_LITERAL_STRING("cpucount"), PR_GetNumberOfProcessors());
#else
SetInt32Property(NS_LITERAL_STRING("cpucount"), PR_GetNumberOfProcessors());
#endif
if (virtualMem) SetUint64Property(NS_LITERAL_STRING("virtualmemsize"), virtualMem);
if (cpuSpeed >= 0) SetInt32Property(NS_LITERAL_STRING("cpuspeed"), cpuSpeed);
if (!cpuVendor.IsEmpty()) SetPropertyAsACString(NS_LITERAL_STRING("cpuvendor"), cpuVendor);
if (cpuFamily >= 0) SetInt32Property(NS_LITERAL_STRING("cpufamily"), cpuFamily);
if (cpuModel >= 0) SetInt32Property(NS_LITERAL_STRING("cpumodel"), cpuModel);
if (cpuStepping >= 0) SetInt32Property(NS_LITERAL_STRING("cpustepping"), cpuStepping);
if (logicalCPUs >= 0) SetInt32Property(NS_LITERAL_STRING("cpucount"), logicalCPUs);
if (physicalCPUs >= 0) SetInt32Property(NS_LITERAL_STRING("cpucores"), physicalCPUs);
if (cacheSizeL2 >= 0) SetInt32Property(NS_LITERAL_STRING("cpucachel2"), cacheSizeL2);
if (cacheSizeL3 >= 0) SetInt32Property(NS_LITERAL_STRING("cpucachel3"), cacheSizeL3);
for (uint32_t i = 0; i < ArrayLength(cpuPropItems); i++) {
rv = SetPropertyAsBool(NS_ConvertASCIItoUTF16(cpuPropItems[i].name),
cpuPropItems[i].propfun());
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
#ifdef XP_WIN
BOOL isWow64;
BOOL gotWow64Value = IsWow64Process(GetCurrentProcess(), &isWow64);
NS_WARN_IF_FALSE(gotWow64Value, "IsWow64Process failed");
if (gotWow64Value) {
rv = SetPropertyAsBool(NS_LITERAL_STRING("isWow64"), !!isWow64);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
if (NS_FAILED(GetProfileHDDInfo())) {
// We might have been called before profile-do-change. We'll observe that
// event so that we can fill this in later.
nsCOMPtr<nsIObserverService> obsService =
do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = obsService->AddObserver(this, "profile-do-change", false);
if (NS_FAILED(rv)) {
return rv;
}
}
nsAutoCString hddModel, hddRevision;
if (NS_SUCCEEDED(GetHDDInfo(NS_GRE_DIR, hddModel, hddRevision))) {
rv = SetPropertyAsACString(NS_LITERAL_STRING("binHDDModel"), hddModel);
NS_ENSURE_SUCCESS(rv, rv);
rv = SetPropertyAsACString(NS_LITERAL_STRING("binHDDRevision"),
hddRevision);
NS_ENSURE_SUCCESS(rv, rv);
}
if (NS_SUCCEEDED(GetHDDInfo(NS_WIN_WINDOWS_DIR, hddModel, hddRevision))) {
rv = SetPropertyAsACString(NS_LITERAL_STRING("winHDDModel"), hddModel);
NS_ENSURE_SUCCESS(rv, rv);
rv = SetPropertyAsACString(NS_LITERAL_STRING("winHDDRevision"),
hddRevision);
NS_ENSURE_SUCCESS(rv, rv);
}
nsAutoString countryCode;
if (NS_SUCCEEDED(GetCountryCode(countryCode))) {
rv = SetPropertyAsAString(NS_LITERAL_STRING("countryCode"), countryCode);
NS_ENSURE_SUCCESS(rv, rv);
}
uint32_t installYear = 0;
if (NS_SUCCEEDED(GetInstallYear(installYear))) {
rv = SetPropertyAsUint32(NS_LITERAL_STRING("installYear"), installYear);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
#endif
#if defined(XP_MACOSX)
nsAutoString countryCode;
if (NS_SUCCEEDED(GetSelectedCityInfo(countryCode))) {
rv = SetPropertyAsAString(NS_LITERAL_STRING("countryCode"), countryCode);
NS_ENSURE_SUCCESS(rv, rv);
}
#endif
#if defined(MOZ_WIDGET_GTK)
// This must be done here because NSPR can only separate OS's when compiled, not libraries.
// 64 bytes is going to be well enough for "GTK " followed by 3 integers
// separated with dots.
char gtkver[64];
ssize_t gtkver_len = 0;
#if MOZ_WIDGET_GTK == 2
extern int gtk_read_end_of_the_pipe;
if (gtk_read_end_of_the_pipe != -1) {
do {
gtkver_len = read(gtk_read_end_of_the_pipe, >kver, sizeof(gtkver));
} while (gtkver_len < 0 && errno == EINTR);
close(gtk_read_end_of_the_pipe);
}
#endif
if (gtkver_len <= 0) {
gtkver_len = snprintf(gtkver, sizeof(gtkver), "GTK %u.%u.%u",
gtk_major_version, gtk_minor_version,
gtk_micro_version);
}
nsAutoCString secondaryLibrary;
if (gtkver_len > 0) {
secondaryLibrary.Append(nsDependentCSubstring(gtkver, gtkver_len));
}
void* libpulse = dlopen("libpulse.so.0", RTLD_LAZY);
const char* libpulseVersion = "not-available";
if (libpulse) {
auto pa_get_library_version = reinterpret_cast<const char* (*)()>
(dlsym(libpulse, "pa_get_library_version"));
if (pa_get_library_version) {
libpulseVersion = pa_get_library_version();
}
}
secondaryLibrary.AppendPrintf(",libpulse %s", libpulseVersion);
if (libpulse) {
dlclose(libpulse);
}
rv = SetPropertyAsACString(NS_LITERAL_STRING("secondaryLibrary"),
secondaryLibrary);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
#endif
#ifdef MOZ_WIDGET_ANDROID
AndroidSystemInfo info;
if (XRE_IsContentProcess()) {
dom::ContentChild* child = dom::ContentChild::GetSingleton();
if (child) {
child->SendGetAndroidSystemInfo(&info);
SetupAndroidInfo(info);
}
} else {
GetAndroidSystemInfo(&info);
SetupAndroidInfo(info);
}
#endif
#ifdef MOZ_WIDGET_GONK
char sdk[PROP_VALUE_MAX];
if (__system_property_get("ro.build.version.sdk", sdk)) {
android_sdk_version = atoi(sdk);
SetPropertyAsInt32(NS_LITERAL_STRING("sdk_version"), android_sdk_version);
SetPropertyAsACString(NS_LITERAL_STRING("secondaryLibrary"),
nsPrintfCString("SDK %u", android_sdk_version));
}
char characteristics[PROP_VALUE_MAX];
if (__system_property_get("ro.build.characteristics", characteristics)) {
if (!strcmp(characteristics, "tablet")) {
SetPropertyAsBool(NS_LITERAL_STRING("tablet"), true);
} else if (!strcmp(characteristics, "tv")) {
SetPropertyAsBool(NS_LITERAL_STRING("tv"), true);
}
}
nsAutoString str;
rv = GetPropertyAsAString(NS_LITERAL_STRING("version"), str);
if (NS_SUCCEEDED(rv)) {
SetPropertyAsAString(NS_LITERAL_STRING("kernel_version"), str);
}
const nsAdoptingString& b2g_os_name =
mozilla::Preferences::GetString("b2g.osName");
if (b2g_os_name) {
SetPropertyAsAString(NS_LITERAL_STRING("name"), b2g_os_name);
}
const nsAdoptingString& b2g_version =
mozilla::Preferences::GetString("b2g.version");
if (b2g_version) {
SetPropertyAsAString(NS_LITERAL_STRING("version"), b2g_version);
}
#endif
#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
SandboxInfo sandInfo = SandboxInfo::Get();
SetPropertyAsBool(NS_LITERAL_STRING("hasSeccompBPF"),
sandInfo.Test(SandboxInfo::kHasSeccompBPF));
SetPropertyAsBool(NS_LITERAL_STRING("hasSeccompTSync"),
sandInfo.Test(SandboxInfo::kHasSeccompTSync));
SetPropertyAsBool(NS_LITERAL_STRING("hasUserNamespaces"),
sandInfo.Test(SandboxInfo::kHasUserNamespaces));
SetPropertyAsBool(NS_LITERAL_STRING("hasPrivilegedUserNamespaces"),
sandInfo.Test(SandboxInfo::kHasPrivilegedUserNamespaces));
if (sandInfo.Test(SandboxInfo::kEnabledForContent)) {
SetPropertyAsBool(NS_LITERAL_STRING("canSandboxContent"),
sandInfo.CanSandboxContent());
}
if (sandInfo.Test(SandboxInfo::kEnabledForMedia)) {
SetPropertyAsBool(NS_LITERAL_STRING("canSandboxMedia"),
sandInfo.CanSandboxMedia());
}
#endif // XP_LINUX && MOZ_SANDBOX
return NS_OK;
}
