void nsEudoraCompose::ExtractType( nsString& str)
{
nsString tStr;
PRInt32 idx = str.FindChar( ';');
if (idx != -1) {
str.Left( tStr, idx);
str = tStr;
}
str.Trim( kWhitespace);
if ((str.CharAt( 0) == '"') && (str.Length() > 2)) {
str.Mid( tStr, 1, str.Length() - 2);
str = tStr;
str.Trim( kWhitespace);
}
// if multipart then ignore it since no outlook message body is ever
// valid multipart!
if (str.Length() > 10) {
str.Left( tStr, 10);
if (tStr.LowerCaseEqualsLiteral("multipart/"))
str.Truncate();
}
}
void
mozTXTToHTMLConv::ScanTXT(const PRUnichar * aInString, PRInt32 aInStringLength, PRUint32 whattodo, nsString& aOutString)
{
PRBool doURLs = 0 != (whattodo & kURLs);
PRBool doGlyphSubstitution = 0 != (whattodo & kGlyphSubstitution);
PRBool doStructPhrase = 0 != (whattodo & kStructPhrase);
PRUint32 structPhrase_strong = 0; // Number of currently open tags
PRUint32 structPhrase_underline = 0;
PRUint32 structPhrase_italic = 0;
PRUint32 structPhrase_code = 0;
nsAutoString outputHTML; // moved here for performance increase
for(PRUint32 i = 0; PRInt32(i) < aInStringLength;)
{
if (doGlyphSubstitution)
{
PRInt32 glyphTextLen;
if (GlyphHit(&aInString[i], aInStringLength - i, i == 0, aOutString, glyphTextLen))
{
i += glyphTextLen;
continue;
}
}
if (doStructPhrase)
{
const PRUnichar * newOffset = aInString;
PRInt32 newLength = aInStringLength;
if (i > 0 ) // skip the first element?
{
newOffset = &aInString[i-1];
newLength = aInStringLength - i + 1;
}
switch (aInString[i]) // Performance increase
{
case '*':
if (StructPhraseHit(newOffset, newLength, i == 0,
NS_LITERAL_STRING("*").get(), 1,
"b", "class=\"moz-txt-star\"",
aOutString, structPhrase_strong))
{
i++;
continue;
}
break;
case '/':
if (StructPhraseHit(newOffset, newLength, i == 0,
NS_LITERAL_STRING("/").get(), 1,
"i", "class=\"moz-txt-slash\"",
aOutString, structPhrase_italic))
{
i++;
continue;
}
break;
case '_':
if (StructPhraseHit(newOffset, newLength, i == 0,
NS_LITERAL_STRING("_").get(), 1,
"span" /* <u> is deprecated */,
"class=\"moz-txt-underscore\"",
aOutString, structPhrase_underline))
{
i++;
continue;
}
break;
case '|':
if (StructPhraseHit(newOffset, newLength, i == 0,
NS_LITERAL_STRING("|").get(), 1,
"code", "class=\"moz-txt-verticalline\"",
aOutString, structPhrase_code))
{
i++;
continue;
}
break;
}
}
if (doURLs)
{
switch (aInString[i])
{
case ':':
case '@':
case '.':
if ( (i == 0 || ((i > 0) && aInString[i - 1] != ' ')) && aInString[i +1] != ' ') // Performance increase
{
PRInt32 replaceBefore;
PRInt32 replaceAfter;
if (FindURL(aInString, aInStringLength, i, whattodo,
outputHTML, replaceBefore, replaceAfter)
&& structPhrase_strong + structPhrase_italic +
structPhrase_underline + structPhrase_code == 0
/* workaround for bug #19445 */ )
{
aOutString.Cut(aOutString.Length() - replaceBefore, replaceBefore);
aOutString += outputHTML;
i += replaceAfter + 1;
continue;
}
}
break;
} //switch
}
switch (aInString[i])
{
// Special symbols
case '<':
case '>':
case '&':
EscapeChar(aInString[i], aOutString, PR_FALSE);
i++;
break;
// Normal characters
default:
aOutString += aInString[i];
i++;
break;
}
}
}
// NOTE: the converted html for the phrase is appended to aOutString
// tagHTML and attributeHTML are plain ASCII (literal strings, in fact)
PRBool
mozTXTToHTMLConv::StructPhraseHit(const PRUnichar * aInString, PRInt32 aInStringLength, PRBool col0,
const PRUnichar* tagTXT, PRInt32 aTagTXTLen,
const char* tagHTML, const char* attributeHTML,
nsString& aOutString, PRUint32& openTags)
{
/* We're searching for the following pattern:
LT_DELIMITER - "*" - ALPHA -
[ some text (maybe more "*"-pairs) - ALPHA ] "*" - LT_DELIMITER.
<strong> is only inserted, if existance of a pair could be verified
We use the first opening/closing tag, if we can choose */
const PRUnichar * newOffset = aInString;
PRInt32 newLength = aInStringLength;
if (!col0) // skip the first element?
{
newOffset = &aInString[1];
newLength = aInStringLength - 1;
}
// opening tag
if
(
ItMatchesDelimited(aInString, aInStringLength, tagTXT, aTagTXTLen,
(col0 ? LT_IGNORE : LT_DELIMITER), LT_ALPHA) // is opening tag
&& NumberOfMatches(newOffset, newLength, tagTXT, aTagTXTLen,
LT_ALPHA, LT_DELIMITER) // remaining closing tags
> openTags
)
{
openTags++;
aOutString.AppendLiteral("<");
aOutString.AppendASCII(tagHTML);
aOutString.Append(PRUnichar(' '));
aOutString.AppendASCII(attributeHTML);
aOutString.AppendLiteral("><span class=\"moz-txt-tag\">");
aOutString.Append(tagTXT);
aOutString.AppendLiteral("</span>");
return PR_TRUE;
}
// closing tag
else if (openTags > 0
&& ItMatchesDelimited(aInString, aInStringLength, tagTXT, aTagTXTLen, LT_ALPHA, LT_DELIMITER))
{
openTags--;
aOutString.AppendLiteral("<span class=\"moz-txt-tag\">");
aOutString.Append(tagTXT);
aOutString.AppendLiteral("</span></");
aOutString.AppendASCII(tagHTML);
aOutString.Append(PRUnichar('>'));
return PR_TRUE;
}
return PR_FALSE;
}
static void
ListInterestingFiles(nsString& aAnnotation, nsIFile* aFile,
const nsTArray<nsString>& aInterestingFilenames)
{
nsString filename;
aFile->GetLeafName(filename);
for (const nsString& interestingFilename : aInterestingFilenames) {
if (interestingFilename == filename) {
nsString path;
aFile->GetPath(path);
aAnnotation.AppendLiteral(" ");
aAnnotation.Append(path);
aAnnotation.AppendLiteral(" (");
int64_t size;
if (NS_SUCCEEDED(aFile->GetFileSize(&size))) {
aAnnotation.AppendPrintf("%ld", size);
} else {
aAnnotation.AppendLiteral("???");
}
aAnnotation.AppendLiteral(" bytes, crc32 = ");
uint32_t crc;
nsresult rv = ComputeCRC32(aFile, &crc);
if (NS_SUCCEEDED(rv)) {
aAnnotation.AppendPrintf("0x%08x)\n", crc);
} else {
aAnnotation.AppendPrintf("error 0x%08x)\n", uint32_t(rv));
}
return;
}
}
bool isDir = false;
aFile->IsDirectory(&isDir);
if (!isDir) {
return;
}
nsCOMPtr<nsISimpleEnumerator> entries;
if (NS_FAILED(aFile->GetDirectoryEntries(getter_AddRefs(entries)))) {
aAnnotation.AppendLiteral(" (failed to enumerated directory)\n");
return;
}
for (;;) {
bool hasMore = false;
if (NS_FAILED(entries->HasMoreElements(&hasMore))) {
aAnnotation.AppendLiteral(" (failed during directory enumeration)\n");
return;
}
if (!hasMore) {
break;
}
nsCOMPtr<nsISupports> entry;
if (NS_FAILED(entries->GetNext(getter_AddRefs(entry)))) {
aAnnotation.AppendLiteral(" (failed during directory enumeration)\n");
return;
}
nsCOMPtr<nsIFile> file = do_QueryInterface(entry);
if (file) {
ListInterestingFiles(aAnnotation, file, aInterestingFilenames);
}
}
}
void
nsCSSScanner::ParseAndAppendEscape(nsString& aOutput)
{
PRInt32 ch = Peek();
if (ch < 0) {
aOutput.Append(CSS_ESCAPE);
return;
}
if (IsHexDigit(ch)) {
PRInt32 rv = 0;
int i;
for (i = 0; i < 6; i++) { // up to six digits
ch = Read();
if (ch < 0) {
// Whoops: error or premature eof
break;
}
if (!IsHexDigit(ch) && !IsWhitespace(ch)) {
Pushback(ch);
break;
} else if (IsHexDigit(ch)) {
rv = rv * 16 + HexDigitValue(ch);
} else {
NS_ASSERTION(IsWhitespace(ch), "bad control flow");
// single space ends escape
break;
}
}
if (6 == i) { // look for trailing whitespace and eat it
ch = Peek();
if (IsWhitespace(ch)) {
(void) Read();
}
}
NS_ASSERTION(rv >= 0, "How did rv become negative?");
// "[at most six hexadecimal digits following a backslash] stand
// for the ISO 10646 character with that number, which must not be
// zero. (It is undefined in CSS 2.1 what happens if a style sheet
// does contain a character with Unicode codepoint zero.)"
// -- CSS2.1 section 4.1.3
//
// Silently deleting \0 opens a content-filtration loophole (see
// bug 228856), so what we do instead is pretend the "cancels the
// meaning of special characters" rule applied.
if (rv > 0) {
AppendUCS4ToUTF16(ENSURE_VALID_CHAR(rv), aOutput);
} else {
while (i--)
aOutput.Append('0');
if (IsWhitespace(ch))
Pushback(ch);
}
return;
}
// "Any character except a hexidecimal digit can be escaped to
// remove its special meaning by putting a backslash in front"
// -- CSS1 spec section 7.1
ch = Read(); // Consume the escaped character
if ((ch > 0) && (ch != '\n')) {
aOutput.Append(ch);
}
}
static bool
SetOperator(OperatorData* aOperatorData,
nsOperatorFlags aForm,
const nsCString& aOperator,
nsString& aAttributes)
{
static const char16_t kNullCh = char16_t('\0');
// aOperator is in the expanded format \uNNNN\uNNNN ...
// First compress these Unicode points to the internal nsString format
int32_t i = 0;
nsAutoString name, value;
int32_t len = aOperator.Length();
char16_t c = aOperator[i++];
uint32_t state = 0;
char16_t uchar = 0;
while (i <= len) {
if (0 == state) {
if (c != '\\')
return false;
if (i < len)
c = aOperator[i];
i++;
if (('u' != c) && ('U' != c))
return false;
if (i < len)
c = aOperator[i];
i++;
state++;
}
else {
if (('0' <= c) && (c <= '9'))
uchar = (uchar << 4) | (c - '0');
else if (('a' <= c) && (c <= 'f'))
uchar = (uchar << 4) | (c - 'a' + 0x0a);
else if (('A' <= c) && (c <= 'F'))
uchar = (uchar << 4) | (c - 'A' + 0x0a);
else return false;
if (i < len)
c = aOperator[i];
i++;
state++;
if (5 == state) {
value.Append(uchar);
uchar = 0;
state = 0;
}
}
}
if (0 != state) return false;
// Quick return when the caller doesn't care about the attributes and just wants
// to know if this is a valid operator (this is the case at the first pass of the
// parsing of the dictionary in InitOperators())
if (!aForm) return true;
// Add operator to hash table
aOperatorData->mFlags |= aForm;
aOperatorData->mStr.Assign(value);
value.AppendInt(aForm, 10);
gOperatorTable->Put(value, aOperatorData);
#ifdef DEBUG
NS_LossyConvertUTF16toASCII str(aAttributes);
#endif
// Loop over the space-delimited list of attributes to get the name:value pairs
aAttributes.Append(kNullCh); // put an extra null at the end
char16_t* start = aAttributes.BeginWriting();
char16_t* end = start;
while ((kNullCh != *start) && (kDashCh != *start)) {
name.SetLength(0);
value.SetLength(0);
// skip leading space, the dash amounts to the end of the line
while ((kNullCh!=*start) && (kDashCh!=*start) && nsCRT::IsAsciiSpace(*start)) {
++start;
}
end = start;
// look for ':'
while ((kNullCh!=*end) && (kDashCh!=*end) && !nsCRT::IsAsciiSpace(*end) &&
(kColonCh!=*end)) {
++end;
}
// If ':' is not found, then it's a boolean property
bool IsBooleanProperty = (kColonCh != *end);
*end = kNullCh; // end segment here
// this segment is the name
if (start < end) {
name.Assign(start);
}
if (IsBooleanProperty) {
SetBooleanProperty(aOperatorData, name);
} else {
start = ++end;
// look for space or end of line
while ((kNullCh!=*end) && (kDashCh!=*end) &&
!nsCRT::IsAsciiSpace(*end)) {
++end;
}
*end = kNullCh; // end segment here
if (start < end) {
// this segment is the value
value.Assign(start);
}
SetProperty(aOperatorData, name, value);
}
start = ++end;
}
return true;
}
bool
nsHttpChannelAuthProvider::ConfirmAuth(const nsString &bundleKey,
bool doYesNoPrompt)
{
// skip prompting the user if
// 1) we've already prompted the user
// 2) we're not a toplevel channel
// 3) the userpass length is less than the "phishy" threshold
uint32_t loadFlags;
nsresult rv = mAuthChannel->GetLoadFlags(&loadFlags);
if (NS_FAILED(rv))
return true;
if (mSuppressDefensiveAuth ||
!(loadFlags & nsIChannel::LOAD_INITIAL_DOCUMENT_URI))
return true;
nsAutoCString userPass;
rv = mURI->GetUserPass(userPass);
if (NS_FAILED(rv) ||
(userPass.Length() < gHttpHandler->PhishyUserPassLength()))
return true;
// we try to confirm by prompting the user. if we cannot do so, then
// assume the user said ok. this is done to keep things working in
// embedded builds, where the string bundle might not be present, etc.
nsCOMPtr<nsIStringBundleService> bundleService =
do_GetService(NS_STRINGBUNDLE_CONTRACTID);
if (!bundleService)
return true;
nsCOMPtr<nsIStringBundle> bundle;
bundleService->CreateBundle(NECKO_MSGS_URL, getter_AddRefs(bundle));
if (!bundle)
return true;
nsAutoCString host;
rv = mURI->GetHost(host);
if (NS_FAILED(rv))
return true;
nsAutoCString user;
rv = mURI->GetUsername(user);
if (NS_FAILED(rv))
return true;
NS_ConvertUTF8toUTF16 ucsHost(host), ucsUser(user);
const char16_t *strs[2] = { ucsHost.get(), ucsUser.get() };
nsXPIDLString msg;
bundle->FormatStringFromName(bundleKey.get(), strs, 2, getter_Copies(msg));
if (!msg)
return true;
nsCOMPtr<nsIInterfaceRequestor> callbacks;
rv = mAuthChannel->GetNotificationCallbacks(getter_AddRefs(callbacks));
if (NS_FAILED(rv))
return true;
nsCOMPtr<nsILoadGroup> loadGroup;
rv = mAuthChannel->GetLoadGroup(getter_AddRefs(loadGroup));
if (NS_FAILED(rv))
return true;
nsCOMPtr<nsIPrompt> prompt;
NS_QueryNotificationCallbacks(callbacks, loadGroup, NS_GET_IID(nsIPrompt),
getter_AddRefs(prompt));
if (!prompt)
return true;
// do not prompt again
mSuppressDefensiveAuth = true;
bool confirmed;
if (doYesNoPrompt) {
int32_t choice;
bool checkState = false;
rv = prompt->ConfirmEx(nullptr, msg,
nsIPrompt::BUTTON_POS_1_DEFAULT +
nsIPrompt::STD_YES_NO_BUTTONS,
nullptr, nullptr, nullptr, nullptr,
&checkState, &choice);
if (NS_FAILED(rv))
return true;
confirmed = choice == 0;
}
else {
rv = prompt->Confirm(nullptr, msg, &confirmed);
if (NS_FAILED(rv))
return true;
}
return confirmed;
}
void
setPath(const nsAString& aPath) {
mPath.Assign(aPath);
NormalizeFilePath();
}
void
GetReversedHostname(const nsString& aForward, nsString& aRevHost)
{
ReverseString(aForward, aRevHost);
aRevHost.Append(PRUnichar('.'));
}
void
ApplicationAccessible::Description(nsString& aDescription)
{
aDescription.Truncate();
}
ENameValueFlag
XULMenubarAccessible::NativeName(nsString& aName)
{
aName.AssignLiteral("Application");
return eNameOK;
}
void
ApplicationAccessible::Value(nsString& aValue)
{
aValue.Truncate();
}
void
nsCSSScanner::ParseAndAppendEscape(nsresult& aErrorCode, nsString& aOutput)
{
PRUint8* lexTable = gLexTable;
PRInt32 ch = Peek(aErrorCode);
if (ch < 0) {
aOutput.Append(CSS_ESCAPE);
return;
}
if ((ch <= 255) && ((lexTable[ch] & IS_HEX_DIGIT) != 0)) {
PRInt32 rv = 0;
int i;
for (i = 0; i < 6; i++) { // up to six digits
ch = Read(aErrorCode);
if (ch < 0) {
// Whoops: error or premature eof
break;
}
if (ch >= 256 || (lexTable[ch] & (IS_HEX_DIGIT | IS_WHITESPACE)) == 0) {
Unread();
break;
} else if ((lexTable[ch] & IS_HEX_DIGIT) != 0) {
if ((lexTable[ch] & IS_DIGIT) != 0) {
rv = rv * 16 + (ch - '0');
} else {
// Note: c&7 just keeps the low three bits which causes
// upper and lower case alphabetics to both yield their
// "relative to 10" value for computing the hex value.
rv = rv * 16 + ((ch & 0x7) + 9);
}
} else {
NS_ASSERTION((lexTable[ch] & IS_WHITESPACE) != 0, "bad control flow");
// single space ends escape
if (ch == '\r' && Peek(aErrorCode) == '\n') {
// if CR/LF, eat LF too
Read(aErrorCode);
}
break;
}
}
if (6 == i) { // look for trailing whitespace and eat it
ch = Peek(aErrorCode);
if ((0 <= ch) && (ch <= 255) &&
((lexTable[ch] & IS_WHITESPACE) != 0)) {
(void) Read(aErrorCode);
// special case: if trailing whitespace is CR/LF, eat both chars.
if (ch == '\r' && Peek(aErrorCode) == '\n') {
(void) Read(aErrorCode);
// if we hit the "\0" special case below, we'll push back
// only the '\r', but that's okay, because '\r' by itself
// is still a newline.
}
}
}
NS_ASSERTION(rv >= 0, "How did rv become negative?");
// "[at most six hexadecimal digits following a backslash] stand
// for the ISO 10646 character with that number, which must not be
// zero. (It is undefined in CSS 2.1 what happens if a style sheet
// does contain a character with Unicode codepoint zero.)"
// -- CSS2.1 section 4.1.3
//
// Silently deleting \0 opens a content-filtration loophole (see
// bug 228856), so what we do instead is pretend the "cancels the
// meaning of special characters" rule applied.
if (rv > 0) {
AppendUCS4ToUTF16(ENSURE_VALID_CHAR(rv), aOutput);
} else {
while (i--)
aOutput.Append('0');
if ((0 <= ch) && (ch <= 255) && ((lexTable[ch] & IS_WHITESPACE) != 0))
Pushback(ch);
}
return;
} else {
// "Any character except a hexidecimal digit can be escaped to
// remove its special meaning by putting a backslash in front"
// -- CSS1 spec section 7.1
if (!EatNewline(aErrorCode)) { // skip escaped newline
(void) Read(aErrorCode);
if (ch > 0) {
aOutput.Append(ch);
}
}
return;
}
}
/**
* Returns whether an escape was succesfully parsed; if it was not,
* the backslash needs to be its own symbol token.
*/
bool
nsCSSScanner::ParseAndAppendEscape(nsString& aOutput, bool aInString)
{
int32_t ch = Read();
if (ch < 0) {
return false;
}
if (IsHexDigit(ch)) {
int32_t rv = 0;
int i;
Pushback(ch);
for (i = 0; i < 6; i++) { // up to six digits
ch = Read();
if (ch < 0) {
// Whoops: error or premature eof
break;
}
if (!IsHexDigit(ch) && !IsWhitespace(ch)) {
Pushback(ch);
break;
} else if (IsHexDigit(ch)) {
rv = rv * 16 + HexDigitValue(ch);
} else {
NS_ASSERTION(IsWhitespace(ch), "bad control flow");
// single space ends escape
break;
}
}
if (6 == i) { // look for trailing whitespace and eat it
ch = Peek();
if (IsWhitespace(ch)) {
(void) Read();
}
}
NS_ASSERTION(rv >= 0, "How did rv become negative?");
// "[at most six hexadecimal digits following a backslash] stand
// for the ISO 10646 character with that number, which must not be
// zero. (It is undefined in CSS 2.1 what happens if a style sheet
// does contain a character with Unicode codepoint zero.)"
// -- CSS2.1 section 4.1.3
//
// Silently deleting \0 opens a content-filtration loophole (see
// bug 228856), so what we do instead is pretend the "cancels the
// meaning of special characters" rule applied.
if (rv > 0) {
AppendUCS4ToUTF16(ENSURE_VALID_CHAR(rv), aOutput);
} else {
while (i--)
aOutput.Append('0');
if (IsWhitespace(ch))
Pushback(ch);
}
return true;
}
// "Any character except a hexidecimal digit can be escaped to
// remove its special meaning by putting a backslash in front"
// -- CSS1 spec section 7.1
if (ch == '\n') {
if (!aInString) {
// Outside of strings (which includes url() that contains a
// string), escaped newlines aren't special, and just tokenize as
// eCSSToken_Symbol (DELIM).
Pushback(ch);
return false;
}
// In strings (and in url() containing a string), escaped newlines
// are just dropped to allow splitting over multiple lines.
} else {
aOutput.Append(ch);
}
return true;
}
NS_IMETHODIMP
nsThebesRenderingContext::GetWidth(const nsString& aString, nscoord &aWidth,
PRInt32 *aFontID)
{
return GetWidth(aString.get(), aString.Length(), aWidth, aFontID);
}
int32_t
GfxInfoBase::FindBlocklistedDeviceInList(const nsTArray<GfxDriverInfo>& info,
nsAString& aSuggestedVersion,
int32_t aFeature,
OperatingSystem os)
{
int32_t status = nsIGfxInfo::FEATURE_STATUS_UNKNOWN;
uint32_t i = 0;
for (; i < info.Length(); i++) {
// Do the operating system check first, no point in getting the driver
// info if we won't need to use it. Note we also catch and skips the
// application version mismatches that would leave operating system
// set to unknown.
if (info[i].mOperatingSystem == DRIVER_OS_UNKNOWN ||
(info[i].mOperatingSystem != DRIVER_OS_ALL &&
info[i].mOperatingSystem != os))
{
continue;
}
if (info[i].mOperatingSystemVersion && info[i].mOperatingSystemVersion != OperatingSystemVersion()) {
continue;
}
// XXX: it would be better not to do this everytime round the loop
nsAutoString adapterVendorID;
nsAutoString adapterDeviceID;
nsAutoString adapterDriverVersionString;
if (info[i].mGpu2) {
if (NS_FAILED(GetAdapterVendorID2(adapterVendorID)) ||
NS_FAILED(GetAdapterDeviceID2(adapterDeviceID)) ||
NS_FAILED(GetAdapterDriverVersion2(adapterDriverVersionString)))
{
return 0;
}
} else {
if (NS_FAILED(GetAdapterVendorID(adapterVendorID)) ||
NS_FAILED(GetAdapterDeviceID(adapterDeviceID)) ||
NS_FAILED(GetAdapterDriverVersion(adapterDriverVersionString)))
{
return 0;
}
}
#if defined(XP_WIN) || defined(ANDROID)
uint64_t driverVersion;
ParseDriverVersion(adapterDriverVersionString, &driverVersion);
#endif
if (!info[i].mAdapterVendor.Equals(GfxDriverInfo::GetDeviceVendor(VendorAll), nsCaseInsensitiveStringComparator()) &&
!info[i].mAdapterVendor.Equals(adapterVendorID, nsCaseInsensitiveStringComparator())) {
continue;
}
if (info[i].mDevices != GfxDriverInfo::allDevices && info[i].mDevices->Length()) {
bool deviceMatches = false;
for (uint32_t j = 0; j < info[i].mDevices->Length(); j++) {
if ((*info[i].mDevices)[j].Equals(adapterDeviceID, nsCaseInsensitiveStringComparator())) {
deviceMatches = true;
break;
}
}
if (!deviceMatches) {
continue;
}
}
bool match = false;
if (!info[i].mHardware.IsEmpty() && !info[i].mHardware.Equals(Hardware())) {
continue;
}
if (!info[i].mModel.IsEmpty() && !info[i].mModel.Equals(Model())) {
continue;
}
if (!info[i].mProduct.IsEmpty() && !info[i].mProduct.Equals(Product())) {
continue;
}
if (!info[i].mManufacturer.IsEmpty() && !info[i].mManufacturer.Equals(Manufacturer())) {
continue;
}
#if defined(XP_WIN) || defined(ANDROID)
switch (info[i].mComparisonOp) {
case DRIVER_LESS_THAN:
match = driverVersion < info[i].mDriverVersion;
break;
case DRIVER_LESS_THAN_OR_EQUAL:
match = driverVersion <= info[i].mDriverVersion;
break;
case DRIVER_GREATER_THAN:
match = driverVersion > info[i].mDriverVersion;
break;
case DRIVER_GREATER_THAN_OR_EQUAL:
match = driverVersion >= info[i].mDriverVersion;
break;
case DRIVER_EQUAL:
match = driverVersion == info[i].mDriverVersion;
break;
case DRIVER_NOT_EQUAL:
match = driverVersion != info[i].mDriverVersion;
break;
case DRIVER_BETWEEN_EXCLUSIVE:
match = driverVersion > info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax;
break;
case DRIVER_BETWEEN_INCLUSIVE:
match = driverVersion >= info[i].mDriverVersion && driverVersion <= info[i].mDriverVersionMax;
break;
case DRIVER_BETWEEN_INCLUSIVE_START:
match = driverVersion >= info[i].mDriverVersion && driverVersion < info[i].mDriverVersionMax;
break;
case DRIVER_COMPARISON_IGNORED:
// We don't have a comparison op, so we match everything.
match = true;
break;
default:
NS_WARNING("Bogus op in GfxDriverInfo");
break;
}
#else
// We don't care what driver version it was. We only check OS version and if
// the device matches.
match = true;
#endif
if (match || info[i].mDriverVersion == GfxDriverInfo::allDriverVersions) {
if (info[i].mFeature == GfxDriverInfo::allFeatures ||
info[i].mFeature == aFeature)
{
status = info[i].mFeatureStatus;
break;
}
}
}
#if defined(XP_WIN)
// As a very special case, we block D2D on machines with an NVidia 310M GPU
// as either the primary or secondary adapter. D2D is also blocked when the
// NV 310M is the primary adapter (using the standard blocklisting mechanism).
// If the primary GPU already matched something in the blocklist then we
// ignore this special rule. See bug 1008759.
if (status == nsIGfxInfo::FEATURE_STATUS_UNKNOWN &&
(aFeature == nsIGfxInfo::FEATURE_DIRECT2D)) {
nsAutoString adapterVendorID2;
nsAutoString adapterDeviceID2;
if ((!NS_FAILED(GetAdapterVendorID2(adapterVendorID2))) &&
(!NS_FAILED(GetAdapterDeviceID2(adapterDeviceID2))))
{
nsAString &nvVendorID = (nsAString &)GfxDriverInfo::GetDeviceVendor(VendorNVIDIA);
const nsString nv310mDeviceId = NS_LITERAL_STRING("0x0A70");
if (nvVendorID.Equals(adapterVendorID2, nsCaseInsensitiveStringComparator()) &&
nv310mDeviceId.Equals(adapterDeviceID2, nsCaseInsensitiveStringComparator())) {
status = nsIGfxInfo::FEATURE_BLOCKED_DEVICE;
}
}
}
// Depends on Windows driver versioning. We don't pass a GfxDriverInfo object
// back to the Windows handler, so we must handle this here.
if (status == FEATURE_BLOCKED_DRIVER_VERSION) {
if (info[i].mSuggestedVersion) {
aSuggestedVersion.AppendPrintf("%s", info[i].mSuggestedVersion);
} else if (info[i].mComparisonOp == DRIVER_LESS_THAN &&
info[i].mDriverVersion != GfxDriverInfo::allDriverVersions)
{
aSuggestedVersion.AppendPrintf("%lld.%lld.%lld.%lld",
(info[i].mDriverVersion & 0xffff000000000000) >> 48,
(info[i].mDriverVersion & 0x0000ffff00000000) >> 32,
(info[i].mDriverVersion & 0x00000000ffff0000) >> 16,
(info[i].mDriverVersion & 0x000000000000ffff));
}
}
NS_IMETHODIMP
nsThebesRenderingContext::DrawString(const nsString& aString, nscoord aX, nscoord aY,
PRInt32 aFontID, const nscoord* aSpacing)
{
return DrawString(aString.get(), aString.Length(), aX, aY, aFontID, aSpacing);
}
// returns TRUE if SAN was used to produce names
// return FALSE if nothing was produced
// names => a single name or a list of names
// multipleNames => whether multiple names were delivered
static bool
GetSubjectAltNames(CERTCertificate *nssCert,
nsINSSComponent *component,
nsString &allNames,
uint32_t &nameCount)
{
allNames.Truncate();
nameCount = 0;
SECItem altNameExtension = {siBuffer, nullptr, 0 };
CERTGeneralName *sanNameList = nullptr;
SECStatus rv = CERT_FindCertExtension(nssCert, SEC_OID_X509_SUBJECT_ALT_NAME,
&altNameExtension);
if (rv != SECSuccess) {
return false;
}
ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
if (!arena) {
return false;
}
sanNameList = CERT_DecodeAltNameExtension(arena.get(), &altNameExtension);
if (!sanNameList) {
return false;
}
SECITEM_FreeItem(&altNameExtension, false);
CERTGeneralName *current = sanNameList;
do {
nsAutoString name;
switch (current->type) {
case certDNSName:
{
nsDependentCSubstring nameFromCert(reinterpret_cast<char*>
(current->name.other.data),
current->name.other.len);
// dNSName fields are defined as type IA5String and thus should
// be limited to ASCII characters.
if (IsASCII(nameFromCert)) {
name.Assign(NS_ConvertASCIItoUTF16(nameFromCert));
if (!allNames.IsEmpty()) {
allNames.AppendLiteral(", ");
}
++nameCount;
allNames.Append(name);
}
}
break;
case certIPAddress:
{
char buf[INET6_ADDRSTRLEN];
PRNetAddr addr;
if (current->name.other.len == 4) {
addr.inet.family = PR_AF_INET;
memcpy(&addr.inet.ip, current->name.other.data, current->name.other.len);
PR_NetAddrToString(&addr, buf, sizeof(buf));
name.AssignASCII(buf);
} else if (current->name.other.len == 16) {
addr.ipv6.family = PR_AF_INET6;
memcpy(&addr.ipv6.ip, current->name.other.data, current->name.other.len);
PR_NetAddrToString(&addr, buf, sizeof(buf));
name.AssignASCII(buf);
} else {
/* invalid IP address */
}
if (!name.IsEmpty()) {
if (!allNames.IsEmpty()) {
allNames.AppendLiteral(", ");
}
++nameCount;
allNames.Append(name);
}
break;
}
default: // all other types of names are ignored
break;
}
current = CERT_GetNextGeneralName(current);
} while (current != sanNameList); // double linked
return true;
}
// static
void
nsTextEditRules::HandleNewLines(nsString &aString,
int32_t aNewlineHandling)
{
if (aNewlineHandling < 0) {
int32_t caretStyle;
nsPlaintextEditor::GetDefaultEditorPrefs(aNewlineHandling, caretStyle);
}
switch(aNewlineHandling)
{
case nsIPlaintextEditor::eNewlinesReplaceWithSpaces:
// Strip trailing newlines first so we don't wind up with trailing spaces
aString.Trim(CRLF, false, true);
aString.ReplaceChar(CRLF, ' ');
break;
case nsIPlaintextEditor::eNewlinesStrip:
aString.StripChars(CRLF);
break;
case nsIPlaintextEditor::eNewlinesPasteToFirst:
default:
{
int32_t firstCRLF = aString.FindCharInSet(CRLF);
// we get first *non-empty* line.
int32_t offset = 0;
while (firstCRLF == offset)
{
offset++;
firstCRLF = aString.FindCharInSet(CRLF, offset);
}
if (firstCRLF > 0)
aString.Truncate(firstCRLF);
if (offset > 0)
aString.Cut(0, offset);
}
break;
case nsIPlaintextEditor::eNewlinesReplaceWithCommas:
aString.Trim(CRLF, true, true);
aString.ReplaceChar(CRLF, ',');
break;
case nsIPlaintextEditor::eNewlinesStripSurroundingWhitespace:
{
nsString result;
uint32_t offset = 0;
while (offset < aString.Length())
{
int32_t nextCRLF = aString.FindCharInSet(CRLF, offset);
if (nextCRLF < 0) {
result.Append(nsDependentSubstring(aString, offset));
break;
}
uint32_t wsBegin = nextCRLF;
// look backwards for the first non-whitespace char
while (wsBegin > offset && NS_IS_SPACE(aString[wsBegin - 1]))
--wsBegin;
result.Append(nsDependentSubstring(aString, offset, wsBegin - offset));
offset = nextCRLF + 1;
while (offset < aString.Length() && NS_IS_SPACE(aString[offset]))
++offset;
}
aString = result;
}
break;
case nsIPlaintextEditor::eNewlinesPasteIntact:
// even if we're pasting newlines, don't paste leading/trailing ones
aString.Trim(CRLF, true, true);
break;
}
}
static void
AppendErrorTextMismatch(const nsString &host,
nsIX509Cert* ix509,
nsINSSComponent *component,
bool wantsHtml,
nsString &returnedMessage)
{
const char16_t *params[1];
nsresult rv;
ScopedCERTCertificate nssCert(ix509->GetCert());
if (!nssCert) {
// We are unable to extract the valid names, say "not valid for name".
params[0] = host.get();
nsString formattedString;
rv = component->PIPBundleFormatStringFromName("certErrorMismatch",
params, 1,
formattedString);
if (NS_SUCCEEDED(rv)) {
returnedMessage.Append(formattedString);
returnedMessage.Append('\n');
}
return;
}
nsString allNames;
uint32_t nameCount = 0;
bool useSAN = false;
if (nssCert)
useSAN = GetSubjectAltNames(nssCert.get(), component, allNames, nameCount);
if (!useSAN) {
char *certName = CERT_GetCommonName(&nssCert->subject);
if (certName) {
nsDependentCSubstring commonName(certName, strlen(certName));
if (IsUTF8(commonName)) {
// Bug 1024781
// We should actually check that the common name is a valid dns name or
// ip address and not any string value before adding it to the display
// list.
++nameCount;
allNames.Assign(NS_ConvertUTF8toUTF16(commonName));
}
PORT_Free(certName);
}
}
if (nameCount > 1) {
nsString message;
rv = component->GetPIPNSSBundleString("certErrorMismatchMultiple",
message);
if (NS_SUCCEEDED(rv)) {
returnedMessage.Append(message);
returnedMessage.AppendLiteral("\n ");
returnedMessage.Append(allNames);
returnedMessage.AppendLiteral(" \n");
}
}
else if (nameCount == 1) {
const char16_t *params[1];
params[0] = allNames.get();
const char *stringID;
if (wantsHtml)
stringID = "certErrorMismatchSingle2";
else
stringID = "certErrorMismatchSinglePlain";
nsString formattedString;
rv = component->PIPBundleFormatStringFromName(stringID,
params, 1,
formattedString);
if (NS_SUCCEEDED(rv)) {
returnedMessage.Append(formattedString);
returnedMessage.Append('\n');
}
}
else { // nameCount == 0
nsString message;
nsresult rv = component->GetPIPNSSBundleString("certErrorMismatchNoNames",
message);
if (NS_SUCCEEDED(rv)) {
returnedMessage.Append(message);
returnedMessage.Append('\n');
}
}
}
bool
nsMessengerUnixIntegration::BuildNotificationBody(nsIMsgDBHdr *aHdr,
nsIStringBundle *aBundle,
nsString &aBody)
{
nsAutoString alertBody;
bool showPreview = true;
bool showSubject = true;
bool showSender = true;
PRInt32 previewLength = SHOW_ALERT_PREVIEW_LENGTH_DEFAULT;
nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (!prefBranch)
return PR_FALSE;
prefBranch->GetBoolPref(SHOW_ALERT_PREVIEW, &showPreview);
prefBranch->GetBoolPref(SHOW_ALERT_SENDER, &showSender);
prefBranch->GetBoolPref(SHOW_ALERT_SUBJECT, &showSubject);
prefBranch->GetIntPref(SHOW_ALERT_PREVIEW_LENGTH, &previewLength);
nsCOMPtr<nsIMsgHeaderParser> parser = do_GetService(NS_MAILNEWS_MIME_HEADER_PARSER_CONTRACTID);
if (!parser)
return PR_FALSE;
nsCOMPtr<nsIMsgFolder> folder;
aHdr->GetFolder(getter_AddRefs(folder));
if (!folder)
return PR_FALSE;
nsCString msgURI;
folder->GetUriForMsg(aHdr, msgURI);
bool localOnly;
PRUint32 msgURIIndex = mFetchingURIs.IndexOf(msgURI);
if (msgURIIndex == -1)
{
localOnly = PR_FALSE;
mFetchingURIs.AppendElement(msgURI);
}
else
localOnly = PR_TRUE;
PRUint32 messageKey;
if (NS_FAILED(aHdr->GetMessageKey(&messageKey)))
return PR_FALSE;
bool asyncResult = false;
nsresult rv = folder->FetchMsgPreviewText(&messageKey, 1,
localOnly, this,
&asyncResult);
// If we're still waiting on getting the message previews,
// bail early. We'll come back later when the async operation
// finishes.
if (NS_FAILED(rv) || asyncResult)
return PR_FALSE;
// If we got here, that means that we've retrieved the message preview,
// so we can stop tracking it with our mFetchingURIs array.
if (msgURIIndex != -1)
mFetchingURIs.RemoveElementAt(msgURIIndex);
nsCString utf8previewString;
if (showPreview &&
NS_FAILED(aHdr->GetStringProperty("preview", getter_Copies(utf8previewString))))
return PR_FALSE;
// need listener that mailbox is remote such as IMAP
// to generate preview message
nsString previewString;
CopyUTF8toUTF16(utf8previewString, previewString);
nsString subject;
if (showSubject && NS_FAILED(aHdr->GetMime2DecodedSubject(subject)))
return PR_FALSE;
nsString author;
if (showSender)
{
if (NS_FAILED(aHdr->GetMime2DecodedAuthor(author)))
return PR_FALSE;
PRUnichar **emails;
PRUnichar **names;
PRUnichar **fullnames;
PRUint32 num;
if (NS_FAILED(parser->ParseHeadersWithArray(author.get(),
&emails,
&names,
&fullnames, &num)))
return PR_FALSE;
if (num > 0)
{
author.Assign(names[0] ? names[0] : emails[0]);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(num, emails);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(num, names);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(num, fullnames);
}
}
if (showSubject && showSender)
{
nsString msgTitle;
const PRUnichar *formatStrings[] =
{
subject.get(), author.get()
};
aBundle->FormatStringFromName(NS_LITERAL_STRING("newMailNotification_messagetitle").get(),
formatStrings, 2, getter_Copies(msgTitle));
alertBody.Append(msgTitle);
}
else if (showSubject)
alertBody.Append(subject);
else if (showSender)
alertBody.Append(author);
if (showPreview && (showSubject || showSender))
{
alertBody.AppendLiteral("\n");
}
if (showPreview)
alertBody.Append(StringHead(previewString, previewLength));
if (alertBody.IsEmpty())
return PR_FALSE;
aBody.Assign(alertBody);
return PR_TRUE;
}
/* Formats an error message for overridable certificate errors (of type
* OverridableCertErrorMessage). Use formatPlainErrorMessage to format
* non-overridable cert errors and non-cert-related errors.
*/
static nsresult
formatOverridableCertErrorMessage(nsISSLStatus & sslStatus,
PRErrorCode errorCodeToReport,
const nsXPIDLCString & host, int32_t port,
bool suppressPort443,
bool wantsHtml,
nsString & returnedMessage)
{
static NS_DEFINE_CID(kNSSComponentCID, NS_NSSCOMPONENT_CID);
const char16_t *params[1];
nsresult rv;
nsAutoString hostWithPort;
nsAutoString hostWithoutPort;
// For now, hide port when it's 443 and we're reporting the error.
// In the future a better mechanism should be used
// to make a decision about showing the port number, possibly by requiring
// the context object to implement a specific interface.
// The motivation is that Mozilla browser would like to hide the port number
// in error pages in the common case.
hostWithoutPort.AppendASCII(host);
if (suppressPort443 && port == 443) {
params[0] = hostWithoutPort.get();
} else {
hostWithPort.AppendASCII(host);
hostWithPort.Append(':');
hostWithPort.AppendInt(port);
params[0] = hostWithPort.get();
}
nsCOMPtr<nsINSSComponent> component = do_GetService(kNSSComponentCID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
returnedMessage.Truncate();
rv = component->PIPBundleFormatStringFromName("certErrorIntro", params, 1,
returnedMessage);
NS_ENSURE_SUCCESS(rv, rv);
returnedMessage.AppendLiteral("\n\n");
RefPtr<nsIX509Cert> ix509;
rv = sslStatus.GetServerCert(byRef(ix509));
NS_ENSURE_SUCCESS(rv, rv);
bool isUntrusted;
rv = sslStatus.GetIsUntrusted(&isUntrusted);
NS_ENSURE_SUCCESS(rv, rv);
if (isUntrusted) {
AppendErrorTextUntrusted(errorCodeToReport, hostWithoutPort, ix509,
component, returnedMessage);
}
bool isDomainMismatch;
rv = sslStatus.GetIsDomainMismatch(&isDomainMismatch);
NS_ENSURE_SUCCESS(rv, rv);
if (isDomainMismatch) {
AppendErrorTextMismatch(hostWithoutPort, ix509, component, wantsHtml, returnedMessage);
}
bool isNotValidAtThisTime;
rv = sslStatus.GetIsNotValidAtThisTime(&isNotValidAtThisTime);
NS_ENSURE_SUCCESS(rv, rv);
if (isNotValidAtThisTime) {
AppendErrorTextTime(ix509, component, returnedMessage);
}
AppendErrorTextCode(errorCodeToReport, component, returnedMessage);
return NS_OK;
}
// parse an input string in the following format (see bug 148326 for testcases):
// [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | css-unit | namedspace)
bool
nsMathMLmpaddedFrame::ParseAttribute(nsString& aString,
int32_t& aSign,
nsCSSValue& aCSSValue,
int32_t& aPseudoUnit)
{
aCSSValue.Reset();
aSign = NS_MATHML_SIGN_INVALID;
aPseudoUnit = NS_MATHML_PSEUDO_UNIT_UNSPECIFIED;
aString.CompressWhitespace(); // aString is not a const in this code
int32_t stringLength = aString.Length();
if (!stringLength)
return false;
nsAutoString number, unit;
//////////////////////
// see if the sign is there
int32_t i = 0;
if (aString[0] == '+') {
aSign = NS_MATHML_SIGN_PLUS;
i++;
}
else if (aString[0] == '-') {
aSign = NS_MATHML_SIGN_MINUS;
i++;
}
else
aSign = NS_MATHML_SIGN_UNSPECIFIED;
// get the number
bool gotDot = false, gotPercent = false;
for (; i < stringLength; i++) {
char16_t c = aString[i];
if (gotDot && c == '.') {
// error - two dots encountered
aSign = NS_MATHML_SIGN_INVALID;
return false;
}
if (c == '.')
gotDot = true;
else if (!nsCRT::IsAsciiDigit(c)) {
break;
}
number.Append(c);
}
// catch error if we didn't enter the loop above... we could simply initialize
// floatValue = 1, to cater for cases such as width="height", but that wouldn't
// be in line with the spec which requires an explicit number
if (number.IsEmpty()) {
aSign = NS_MATHML_SIGN_INVALID;
return false;
}
nsresult errorCode;
float floatValue = number.ToFloat(&errorCode);
if (NS_FAILED(errorCode)) {
aSign = NS_MATHML_SIGN_INVALID;
return false;
}
// see if this is a percentage-based value
if (i < stringLength && aString[i] == '%') {
i++;
gotPercent = true;
}
// the remainder now should be a css-unit, or a pseudo-unit, or a named-space
aString.Right(unit, stringLength - i);
if (unit.IsEmpty()) {
if (gotPercent) {
// case ["+"|"-"] unsigned-number "%"
aCSSValue.SetPercentValue(floatValue / 100.0f);
aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
return true;
} else {
// case ["+"|"-"] unsigned-number
// XXXfredw: should we allow non-zero unitless values? See bug 757703.
if (!floatValue) {
aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
return true;
}
}
}
else if (unit.EqualsLiteral("width")) aPseudoUnit = NS_MATHML_PSEUDO_UNIT_WIDTH;
else if (unit.EqualsLiteral("height")) aPseudoUnit = NS_MATHML_PSEUDO_UNIT_HEIGHT;
else if (unit.EqualsLiteral("depth")) aPseudoUnit = NS_MATHML_PSEUDO_UNIT_DEPTH;
else if (!gotPercent) { // percentage can only apply to a pseudo-unit
// see if the unit is a named-space
if (nsMathMLElement::ParseNamedSpaceValue(unit, aCSSValue,
nsMathMLElement::
PARSE_ALLOW_NEGATIVE)) {
// re-scale properly, and we know that the unit of the named-space is 'em'
floatValue *= aCSSValue.GetFloatValue();
aCSSValue.SetFloatValue(floatValue, eCSSUnit_EM);
aPseudoUnit = NS_MATHML_PSEUDO_UNIT_NAMEDSPACE;
return true;
}
// see if the input was just a CSS value
// We are not supposed to have a unitless, percent, negative or namedspace
// value here.
number.Append(unit); // leave the sign out if it was there
if (nsMathMLElement::ParseNumericValue(number, aCSSValue,
nsMathMLElement::
PARSE_SUPPRESS_WARNINGS, nullptr))
return true;
}
// if we enter here, we have a number that will act as a multiplier on a pseudo-unit
if (aPseudoUnit != NS_MATHML_PSEUDO_UNIT_UNSPECIFIED) {
if (gotPercent)
aCSSValue.SetPercentValue(floatValue / 100.0f);
else
aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
return true;
}
#ifdef DEBUG
printf("mpadded: attribute with bad numeric value: %s\n",
NS_LossyConvertUTF16toASCII(aString).get());
#endif
// if we reach here, it means we encounter an unexpected input
aSign = NS_MATHML_SIGN_INVALID;
return false;
}
/* static */ nsresult
nsScriptLoader::ConvertToUTF16(nsIChannel* aChannel, const PRUint8* aData,
PRUint32 aLength, const nsString& aHintCharset,
nsIDocument* aDocument, nsString& aString)
{
if (!aLength) {
aString.Truncate();
return NS_OK;
}
nsCAutoString characterSet;
nsresult rv = NS_OK;
if (aChannel) {
rv = aChannel->GetContentCharset(characterSet);
}
if (!aHintCharset.IsEmpty() && (NS_FAILED(rv) || characterSet.IsEmpty())) {
// charset name is always ASCII.
LossyCopyUTF16toASCII(aHintCharset, characterSet);
}
if (NS_FAILED(rv) || characterSet.IsEmpty()) {
DetectByteOrderMark(aData, aLength, characterSet);
}
if (characterSet.IsEmpty() && aDocument) {
// charset from document default
characterSet = aDocument->GetDocumentCharacterSet();
}
if (characterSet.IsEmpty()) {
// fall back to ISO-8859-1, see bug 118404
characterSet.AssignLiteral("ISO-8859-1");
}
nsCOMPtr<nsICharsetConverterManager> charsetConv =
do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
nsCOMPtr<nsIUnicodeDecoder> unicodeDecoder;
if (NS_SUCCEEDED(rv) && charsetConv) {
rv = charsetConv->GetUnicodeDecoder(characterSet.get(),
getter_AddRefs(unicodeDecoder));
if (NS_FAILED(rv)) {
// fall back to ISO-8859-1 if charset is not supported. (bug 230104)
rv = charsetConv->GetUnicodeDecoderRaw("ISO-8859-1",
getter_AddRefs(unicodeDecoder));
}
}
// converts from the charset to unicode
if (NS_SUCCEEDED(rv)) {
PRInt32 unicodeLength = 0;
rv = unicodeDecoder->GetMaxLength(reinterpret_cast<const char*>(aData),
aLength, &unicodeLength);
if (NS_SUCCEEDED(rv)) {
if (!EnsureStringLength(aString, unicodeLength))
return NS_ERROR_OUT_OF_MEMORY;
PRUnichar *ustr = aString.BeginWriting();
PRInt32 consumedLength = 0;
PRInt32 originalLength = aLength;
PRInt32 convertedLength = 0;
PRInt32 bufferLength = unicodeLength;
do {
rv = unicodeDecoder->Convert(reinterpret_cast<const char*>(aData),
(PRInt32 *) &aLength, ustr,
&unicodeLength);
if (NS_FAILED(rv)) {
// if we failed, we consume one byte, replace it with U+FFFD
// and try the conversion again.
ustr[unicodeLength++] = (PRUnichar)0xFFFD;
ustr += unicodeLength;
unicodeDecoder->Reset();
}
aData += ++aLength;
consumedLength += aLength;
aLength = originalLength - consumedLength;
convertedLength += unicodeLength;
unicodeLength = bufferLength - convertedLength;
} while (NS_FAILED(rv) && (originalLength > consumedLength) && (bufferLength > convertedLength));
aString.SetLength(convertedLength);
}
}
return rv;
}
void
nsCSSToken::AppendToString(nsString& aBuffer)
{
switch (mType) {
case eCSSToken_AtKeyword:
aBuffer.Append(PRUnichar('@')); // fall through intentional
case eCSSToken_Ident:
case eCSSToken_WhiteSpace:
case eCSSToken_Function:
case eCSSToken_HTMLComment:
case eCSSToken_URange:
aBuffer.Append(mIdent);
if (mType == eCSSToken_Function)
aBuffer.Append(PRUnichar('('));
break;
case eCSSToken_URL:
case eCSSToken_Bad_URL:
aBuffer.AppendLiteral("url(");
if (mSymbol != PRUnichar(0)) {
aBuffer.Append(mSymbol);
}
aBuffer.Append(mIdent);
if (mSymbol != PRUnichar(0)) {
aBuffer.Append(mSymbol);
}
if (mType == eCSSToken_URL) {
aBuffer.Append(PRUnichar(')'));
}
break;
case eCSSToken_Number:
if (mIntegerValid) {
aBuffer.AppendInt(mInteger, 10);
}
else {
aBuffer.AppendFloat(mNumber);
}
break;
case eCSSToken_Percentage:
NS_ASSERTION(!mIntegerValid, "How did a percentage token get this set?");
aBuffer.AppendFloat(mNumber * 100.0f);
aBuffer.Append(PRUnichar('%')); // STRING USE WARNING: technically, this should be |AppendWithConversion|
break;
case eCSSToken_Dimension:
if (mIntegerValid) {
aBuffer.AppendInt(mInteger, 10);
}
else {
aBuffer.AppendFloat(mNumber);
}
aBuffer.Append(mIdent);
break;
case eCSSToken_String:
aBuffer.Append(mSymbol);
aBuffer.Append(mIdent); // fall through intentional
case eCSSToken_Symbol:
aBuffer.Append(mSymbol);
break;
case eCSSToken_ID:
case eCSSToken_Ref:
aBuffer.Append(PRUnichar('#'));
aBuffer.Append(mIdent);
break;
case eCSSToken_Includes:
aBuffer.AppendLiteral("~=");
break;
case eCSSToken_Dashmatch:
aBuffer.AppendLiteral("|=");
break;
case eCSSToken_Beginsmatch:
aBuffer.AppendLiteral("^=");
break;
case eCSSToken_Endsmatch:
aBuffer.AppendLiteral("$=");
break;
case eCSSToken_Containsmatch:
aBuffer.AppendLiteral("*=");
break;
case eCSSToken_Bad_String:
aBuffer.Append(mSymbol);
aBuffer.Append(mIdent);
break;
default:
NS_ERROR("invalid token type");
break;
}
}
// This implements part of the algorithm for legacy behavior described in
// http://www.whatwg.org/specs/web-apps/current-work/complete/common-microsyntaxes.html#rules-for-parsing-a-legacy-color-value
NS_GFX_(bool) NS_LooseHexToRGB(const nsString& aColorSpec, nscolor* aResult)
{
if (aColorSpec.EqualsLiteral("transparent")) {
return false;
}
int nameLen = aColorSpec.Length();
const PRUnichar* colorSpec = aColorSpec.get();
if (nameLen > 128) {
nameLen = 128;
}
if ('#' == colorSpec[0]) {
++colorSpec;
--nameLen;
}
// digits per component
int dpc = (nameLen + 2) / 3;
int newdpc = dpc;
// Use only the rightmost 8 characters of each component.
if (newdpc > 8) {
nameLen -= newdpc - 8;
colorSpec += newdpc - 8;
newdpc = 8;
}
// And then keep trimming characters at the left until we'd trim one
// that would leave a nonzero value, but not past 2 characters per
// component.
while (newdpc > 2) {
bool haveNonzero = false;
for (int c = 0; c < 3; ++c) {
NS_ABORT_IF_FALSE(c * dpc < nameLen,
"should not pass end of string while newdpc > 2");
PRUnichar ch = colorSpec[c * dpc];
if (('1' <= ch && ch <= '9') ||
('A' <= ch && ch <= 'F') ||
('a' <= ch && ch <= 'f')) {
haveNonzero = true;
break;
}
}
if (haveNonzero) {
break;
}
--newdpc;
--nameLen;
++colorSpec;
}
// Translate components from hex to binary
int r = ComponentValue(colorSpec, nameLen, 0, dpc);
int g = ComponentValue(colorSpec, nameLen, 1, dpc);
int b = ComponentValue(colorSpec, nameLen, 2, dpc);
NS_ASSERTION((r >= 0) && (r <= 255), "bad r");
NS_ASSERTION((g >= 0) && (g <= 255), "bad g");
NS_ASSERTION((b >= 0) && (b <= 255), "bad b");
*aResult = NS_RGB(r, g, b);
return true;
}
void
mozTXTToHTMLConv::ScanHTML(nsString& aInString, PRUint32 whattodo, nsString &aOutString)
{
// some common variables we were recalculating
// every time inside the for loop...
PRInt32 lengthOfInString = aInString.Length();
const PRUnichar * uniBuffer = aInString.get();
#ifdef DEBUG_BenB_Perf
PRTime parsing_start = PR_IntervalNow();
#endif
// Look for simple entities not included in a tags and scan them.
/* Skip all tags ("<[...]>") and content in an a tag ("<a[...]</a>")
or in a tag ("<!--[...]-->").
Unescape the rest (text between tags) and pass it to ScanTXT. */
for (PRInt32 i = 0; PRUint32(i) < lengthOfInString;)
{
if (aInString[i] == '<') // html tag
{
PRUint32 start = PRUint32(i);
if (nsCRT::ToLower((char)aInString[PRUint32(i) + 1]) == 'a')
// if a tag, skip until </a>
{
i = aInString.Find("</a>", PR_TRUE, i);
if (i == kNotFound)
i = lengthOfInString;
else
i += 4;
}
else if (aInString[PRUint32(i) + 1] == '!' && aInString[PRUint32(i) + 2] == '-' &&
aInString[PRUint32(i) + 3] == '-')
//if out-commended code, skip until -->
{
i = aInString.Find("-->", PR_FALSE, i);
if (i == kNotFound)
i = lengthOfInString;
else
i += 3;
}
else // just skip tag (attributes etc.)
{
i = aInString.FindChar('>', i);
if (i == kNotFound)
i = lengthOfInString;
else
i++;
}
aOutString.Append(&uniBuffer[start], PRUint32(i) - start);
}
else
{
PRUint32 start = PRUint32(i);
i = aInString.FindChar('<', i);
if (i == kNotFound)
i = lengthOfInString;
nsString tempString;
tempString.SetCapacity(PRUint32((PRUint32(i) - start) * growthRate));
UnescapeStr(uniBuffer, start, PRUint32(i) - start, tempString);
ScanTXT(tempString.get(), tempString.Length(), whattodo, aOutString);
}
}
#ifdef DEBUG_BenB_Perf
printf("ScanHTML time: %d ms\n", PR_IntervalToMilliseconds(PR_IntervalNow() - parsing_start));
#endif
}
// Opening Thunderbird's new mail alert notification window
// aUserInitiated --> true if we are opening the alert notification in response to a user action
// like clicking on the biff icon
nsresult nsMessengerWinIntegration::ShowNewAlertNotification(bool aUserInitiated, const nsString& aAlertTitle, const nsString& aAlertText)
{
nsresult rv;
// if we are already in the process of showing an alert, don't try to show another....
if (mAlertInProgress)
return NS_OK;
nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
bool showBalloon = false;
prefBranch->GetBoolPref(SHOW_BALLOON_PREF, &showBalloon);
sBiffIconData.szInfo[0] = '\0';
if (showBalloon) {
::wcsncpy( sBiffIconData.szInfoTitle, aAlertTitle.get(), kMaxBalloonTitle);
::wcsncpy( sBiffIconData.szInfo, aAlertText.get(), kMaxBalloonSize);
}
bool showAlert = true;
if (prefBranch)
prefBranch->GetBoolPref(SHOW_ALERT_PREF, &showAlert);
// check if we are allowed to show a notification
if (showAlert && mSHQueryUserNotificationState) {
MOZ_QUERY_USER_NOTIFICATION_STATE qstate;
if (SUCCEEDED(mSHQueryUserNotificationState(&qstate))) {
if (qstate != QUNS_ACCEPTS_NOTIFICATIONS) {
showAlert = false;
}
}
}
if (showAlert)
{
nsCOMPtr<nsIMutableArray> argsArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
// pass in the array of folders with unread messages
nsCOMPtr<nsISupportsInterfacePointer> ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
ifptr->SetData(mFoldersWithNewMail);
ifptr->SetDataIID(&NS_GET_IID(nsIArray));
rv = argsArray->AppendElement(ifptr, false);
NS_ENSURE_SUCCESS(rv, rv);
// pass in the observer
ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsISupports> supports = do_QueryInterface(static_cast<nsIMessengerOSIntegration*>(this));
ifptr->SetData(supports);
ifptr->SetDataIID(&NS_GET_IID(nsIObserver));
rv = argsArray->AppendElement(ifptr, false);
NS_ENSURE_SUCCESS(rv, rv);
// pass in the animation flag
nsCOMPtr<nsISupportsPRBool> scriptableUserInitiated (do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
scriptableUserInitiated->SetData(aUserInitiated);
rv = argsArray->AppendElement(scriptableUserInitiated, false);
NS_ENSURE_SUCCESS(rv, rv);
// pass in the alert origin
nsCOMPtr<nsISupportsPRUint8> scriptableOrigin (do_CreateInstance(NS_SUPPORTS_PRUINT8_CONTRACTID));
NS_ENSURE_TRUE(scriptableOrigin, NS_ERROR_FAILURE);
scriptableOrigin->SetData(0);
int32_t origin = 0;
#ifdef MOZ_THUNDERBIRD
origin = LookAndFeel::GetInt(LookAndFeel::eIntID_AlertNotificationOrigin);
#else
// Get task bar window handle
HWND shellWindow = FindWindowW(L"Shell_TrayWnd", NULL);
rv = prefBranch->GetIntPref(ALERT_ORIGIN_PREF, &origin);
if (NS_FAILED(rv) && (shellWindow != NULL))
{
// Determine position
APPBARDATA appBarData;
appBarData.hWnd = shellWindow;
appBarData.cbSize = sizeof(appBarData);
if (SHAppBarMessage(ABM_GETTASKBARPOS, &appBarData))
{
// Set alert origin as a bit field - see LookAndFeel.h
// 0 represents bottom right, sliding vertically.
switch(appBarData.uEdge)
{
case ABE_LEFT:
origin = NS_ALERT_HORIZONTAL | NS_ALERT_LEFT;
break;
case ABE_RIGHT:
origin = NS_ALERT_HORIZONTAL;
break;
case ABE_TOP:
origin = NS_ALERT_TOP;
// fall through for the right-to-left handling.
case ABE_BOTTOM:
// If the task bar is right-to-left,
// move the origin to the left
if (::GetWindowLong(shellWindow, GWL_EXSTYLE) &
WS_EX_LAYOUTRTL)
origin |= NS_ALERT_LEFT;
break;
}
}
}
#endif
scriptableOrigin->SetData(origin);
rv = argsArray->AppendElement(scriptableOrigin, false);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
nsCOMPtr<nsIDOMWindow> newWindow;
rv = wwatch->OpenWindow(0, ALERT_CHROME_URL, "_blank",
"chrome,dialog=yes,titlebar=no,popup=yes", argsArray,
getter_AddRefs(newWindow));
mAlertInProgress = true;
}
// if the user has turned off the mail alert, or openWindow generated an error,
// then go straight to the system tray.
if (!showAlert || NS_FAILED(rv))
AlertFinished();
return rv;
}
// the glyph is appended to aOutputString instead of the original string...
PRBool
mozTXTToHTMLConv::GlyphHit(const PRUnichar * aInString, PRInt32 aInLength, PRBool col0,
nsString& aOutputString, PRInt32& glyphTextLen)
{
PRUnichar text0 = aInString[0];
PRUnichar text1 = aInString[1];
PRUnichar firstChar = (col0 ? text0 : text1);
// temporary variable used to store the glyph html text
nsAutoString outputHTML;
PRBool bTestSmilie;
PRBool bArg;
int i;
// refactor some of this mess to avoid code duplication and speed execution a bit
// there are two cases that need to be tried one after another. To avoid a lot of
// duplicate code, rolling into a loop
i = 0;
while ( i < 2 )
{
bTestSmilie = PR_FALSE;
if ( !i && (firstChar == ':' || firstChar == ';' || firstChar == '=' || firstChar == '>' || firstChar == '8' || firstChar == 'O'))
{
// first test passed
bTestSmilie = PR_TRUE;
bArg = col0;
}
if ( i && col0 && ( text1 == ':' || text1 == ';' || text1 == '=' || text1 == '>' || text1 == '8' || text1 == 'O' ) )
{
// second test passed
bTestSmilie = PR_TRUE;
bArg = PR_FALSE;
}
if ( bTestSmilie && (
SmilyHit(aInString, aInLength, bArg,
":-)",
"moz-smiley-s1", // smile
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":)",
"moz-smiley-s1", // smile
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-D",
"moz-smiley-s5", // laughing
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-(",
"moz-smiley-s2", // frown
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":(",
"moz-smiley-s2", // frown
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-[",
"moz-smiley-s6", // embarassed
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
";-)",
"moz-smiley-s3", // wink
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, col0,
";)",
"moz-smiley-s3", // wink
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-\\",
"moz-smiley-s7", // undecided
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-P",
"moz-smiley-s4", // tongue
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
";-P",
"moz-smiley-s4", // tongue
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
"=-O",
"moz-smiley-s8", // surprise
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-*",
"moz-smiley-s9", // kiss
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
">:o",
"moz-smiley-s10", // yell
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
">:-o",
"moz-smiley-s10", // yell
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
"8-)",
"moz-smiley-s11", // cool
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-$",
"moz-smiley-s12", // money
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-!",
"moz-smiley-s13", // foot
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
"O:-)",
"moz-smiley-s14", // innocent
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":'(",
"moz-smiley-s15", // cry
outputHTML, glyphTextLen) ||
SmilyHit(aInString, aInLength, bArg,
":-X",
"moz-smiley-s16", // sealed
outputHTML, glyphTextLen)
)
)
{
aOutputString.Append(outputHTML);
return PR_TRUE;
}
i++;
}
if (text0 == '\f')
{
aOutputString.AppendLiteral("<span class='moz-txt-formfeed'></span>");
glyphTextLen = 1;
return PR_TRUE;
}
if (text0 == '+' || text1 == '+')
{
if (ItMatchesDelimited(aInString, aInLength,
NS_LITERAL_STRING(" +/-").get(), 4,
LT_IGNORE, LT_IGNORE))
{
aOutputString.AppendLiteral(" ±");
glyphTextLen = 4;
return PR_TRUE;
}
if (col0 && ItMatchesDelimited(aInString, aInLength,
NS_LITERAL_STRING("+/-").get(), 3,
LT_IGNORE, LT_IGNORE))
{
aOutputString.AppendLiteral("±");
glyphTextLen = 3;
return PR_TRUE;
}
}
// x^2 => x<sup>2</sup>, also handle powers x^-2, x^0.5
// implement regular expression /[\dA-Za-z\)\]}]\^-?\d+(\.\d+)*[^\dA-Za-z]/
if
(
text1 == '^'
&&
(
nsCRT::IsAsciiDigit(text0) || nsCRT::IsAsciiAlpha(text0) ||
text0 == ')' || text0 == ']' || text0 == '}'
)
&&
(
2 < aInLength && nsCRT::IsAsciiDigit(aInString[2]) ||
3 < aInLength && aInString[2] == '-' && nsCRT::IsAsciiDigit(aInString[3])
)
)
{
// Find first non-digit
PRInt32 delimPos = 3; // skip "^" and first digit (or '-')
for (; delimPos < aInLength
&&
(
nsCRT::IsAsciiDigit(aInString[delimPos]) ||
aInString[delimPos] == '.' && delimPos + 1 < aInLength &&
nsCRT::IsAsciiDigit(aInString[delimPos + 1])
);
delimPos++)
;
if (delimPos < aInLength && nsCRT::IsAsciiAlpha(aInString[delimPos]))
{
return PR_FALSE;
}
outputHTML.Truncate();
outputHTML += text0;
outputHTML.AppendLiteral("<sup class=\"moz-txt-sup\">");
aOutputString.Append(outputHTML);
aOutputString.Append(&aInString[2], delimPos - 2);
aOutputString.AppendLiteral("</sup>");
glyphTextLen = delimPos /* - 1 + 1 */ ;
return PR_TRUE;
}
/*
The following strings are not substituted:
|TXT |HTML |Reason
+------+---------+----------
-> ← Bug #454
=> ⇐ dito
<- → dito
<= ⇒ dito
(tm) ™ dito
1/4 ¼ is triggered by 1/4 Part 1, 2/4 Part 2, ...
3/4 ¾ dito
1/2 ½ similar
*/
return PR_FALSE;
}
void
nsRenderingContext::DrawString(const nsString& aString, nscoord aX, nscoord aY)
{
DrawString(aString.get(), aString.Length(), aX, aY);
}