/* void spoofDriverVersion (in DOMString aDriverVersion); */
NS_IMETHODIMP GfxInfo::SpoofDriverVersion(const nsAString & aDriverVersion)
{
CopyUTF16toUTF8(aDriverVersion, mVersion);
return NS_OK;
}
/* void spoofVendorID (in DOMString aVendorID); */
NS_IMETHODIMP GfxInfo::SpoofVendorID(const nsAString & aVendorID)
{
CopyUTF16toUTF8(aVendorID, mVendor);
return NS_OK;
}
/* void spoofDeviceID (in unsigned long aDeviceID); */
NS_IMETHODIMP GfxInfo::SpoofDeviceID(const nsAString & aDeviceID)
{
CopyUTF16toUTF8(aDeviceID, mRenderer);
return NS_OK;
}
static int
MimeInlineTextPlain_parse_line (const char *line, PRInt32 length, MimeObject *obj)
{
int status;
PRBool quoting = ( obj->options
&& ( obj->options->format_out == nsMimeOutput::nsMimeMessageQuoting ||
obj->options->format_out == nsMimeOutput::nsMimeMessageBodyQuoting
) ); // see above
PRBool plainHTML = quoting || (obj->options &&
obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs);
// see above
PRBool rawPlainText = obj->options &&
(obj->options->format_out == nsMimeOutput::nsMimeMessageFilterSniffer
|| obj->options->format_out == nsMimeOutput::nsMimeMessageAttach);
// this routine gets called for every line of data that comes through the
// mime converter. It's important to make sure we are efficient with
// how we allocate memory in this routine. be careful if you go to add
// more to this routine.
NS_ASSERTION(length > 0, "zero length");
if (length <= 0) return 0;
mozITXTToHTMLConv *conv = GetTextConverter(obj->options);
MimeInlineTextPlain *text = (MimeInlineTextPlain *) obj;
PRBool skipConversion = !conv || rawPlainText ||
(obj->options && obj->options->force_user_charset);
char *mailCharset = NULL;
nsresult rv;
if (!skipConversion)
{
nsDependentCString inputStr(line, length);
nsAutoString lineSourceStr;
// For 'SaveAs', |line| is in |mailCharset|.
// convert |line| to UTF-16 before 'html'izing (calling ScanTXT())
if (obj->options->format_out == nsMimeOutput::nsMimeMessageSaveAs)
{ // Get the mail charset of this message.
MimeInlineText *inlinetext = (MimeInlineText *) obj;
if (!inlinetext->initializeCharset)
((MimeInlineTextClass*)&mimeInlineTextClass)->initialize_charset(obj);
mailCharset = inlinetext->charset;
if (mailCharset && *mailCharset) {
rv = nsMsgI18NConvertToUnicode(mailCharset, inputStr, lineSourceStr);
NS_ENSURE_SUCCESS(rv, -1);
}
else // this probably never happens ...
CopyUTF8toUTF16(inputStr, lineSourceStr);
}
else // line is in UTF-8
CopyUTF8toUTF16(inputStr, lineSourceStr);
nsCAutoString prefaceResultStr; // Quoting stuff before the real text
// Recognize quotes
PRUint32 oldCiteLevel = text->mCiteLevel;
PRUint32 logicalLineStart = 0;
rv = conv->CiteLevelTXT(lineSourceStr.get(),
&logicalLineStart, &(text->mCiteLevel));
NS_ENSURE_SUCCESS(rv, -1);
// Find out, which recognitions to do
PRBool whattodo = obj->options->whattodo;
if (plainHTML)
{
if (quoting)
whattodo = 0; // This is done on Send. Don't do it twice.
else
whattodo = whattodo & ~mozITXTToHTMLConv::kGlyphSubstitution;
/* Do recognition for the case, the result is viewed in
Mozilla, but not GlyphSubstitution, because other UAs
might not be able to display the glyphs. */
if (!text->mBlockquoting)
text->mCiteLevel = 0;
}
// Write blockquote
if (text->mCiteLevel > oldCiteLevel)
{
prefaceResultStr += "</pre>";
for (PRUint32 i = 0; i < text->mCiteLevel - oldCiteLevel; i++)
{
nsCAutoString style;
MimeTextBuildPrefixCSS(text->mQuotedSizeSetting, text->mQuotedStyleSetting,
text->mCitationColor, style);
if (!plainHTML && !style.IsEmpty())
{
prefaceResultStr += "<blockquote type=cite style=\"";
prefaceResultStr += style;
prefaceResultStr += "\">";
}
else
prefaceResultStr += "<blockquote type=cite>";
}
prefaceResultStr += "<pre wrap>\n";
}
else if (text->mCiteLevel < oldCiteLevel)
{
prefaceResultStr += "</pre>";
for (PRUint32 i = 0; i < oldCiteLevel - text->mCiteLevel; i++)
prefaceResultStr += "</blockquote>";
prefaceResultStr += "<pre wrap>\n";
}
// Write plain text quoting tags
if (logicalLineStart != 0 && !(plainHTML && text->mBlockquoting))
{
if (!plainHTML)
prefaceResultStr += "<span class=\"moz-txt-citetags\">";
nsString citeTagsSource(StringHead(lineSourceStr, logicalLineStart));
// Convert to HTML
nsString citeTagsResultUnichar;
rv = conv->ScanTXT(citeTagsSource.get(), 0 /* no recognition */,
getter_Copies(citeTagsResultUnichar));
if (NS_FAILED(rv)) return -1;
prefaceResultStr.Append(NS_ConvertUTF16toUTF8(citeTagsResultUnichar));
if (!plainHTML)
prefaceResultStr += "</span>";
}
// recognize signature
if ((lineSourceStr.Length() >= 4)
&& lineSourceStr.First() == '-'
&& Substring(lineSourceStr, 0, 3).EqualsLiteral("-- ")
&& (lineSourceStr[3] == '\r' || lineSourceStr[3] == '\n') )
{
text->mIsSig = PR_TRUE;
if (!quoting)
prefaceResultStr += "<div class=\"moz-txt-sig\">";
}
/* This is the main TXT to HTML conversion:
escaping (very important), eventually recognizing etc. */
nsString lineResultUnichar;
rv = conv->ScanTXT(lineSourceStr.get() + logicalLineStart,
whattodo, getter_Copies(lineResultUnichar));
NS_ENSURE_SUCCESS(rv, -1);
if (!(text->mIsSig && quoting))
{
status = MimeObject_write(obj, prefaceResultStr.get(), prefaceResultStr.Length(), PR_TRUE);
if (status < 0) return status;
nsCAutoString outString;
if (obj->options->format_out != nsMimeOutput::nsMimeMessageSaveAs ||
!mailCharset || !*mailCharset)
CopyUTF16toUTF8(lineResultUnichar, outString);
else
{ // convert back to mailCharset before writing.
rv = nsMsgI18NConvertFromUnicode(mailCharset,
lineResultUnichar, outString);
NS_ENSURE_SUCCESS(rv, -1);
}
status = MimeObject_write(obj, outString.get(), outString.Length(), PR_TRUE);
}
else
{
status = NS_OK;
}
}
else
{
status = MimeObject_write(obj, line, length, PR_TRUE);
}
return status;
}
nsDBFolderInfo::nsDBFolderInfo(nsMsgDatabase *mdb)
: m_flags(0),
m_expiredMark(0),
m_expiredMarkColumnToken(0)
{
m_mdbTable = NULL;
m_mdbRow = NULL;
m_version = 1; // for upgrading...
m_IMAPHierarchySeparator = 0; // imap path separator
// mail only (for now)
m_folderSize = 0;
m_folderDate = 0;
m_expungedBytes = 0; // sum of size of deleted messages in folder
m_highWaterMessageKey = 0;
m_numUnreadMessages = 0;
m_numMessages = 0;
// IMAP only
m_ImapUidValidity = kUidUnknown;
m_totalPendingMessages =0;
m_unreadPendingMessages = 0;
m_mdbTokensInitialized = false;
m_charSetOverride = false;
if (!gFolderCharsetObserver)
{
nsresult rv;
nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
nsCOMPtr<nsIPrefBranch> prefBranch;
if (NS_SUCCEEDED(rv))
{
rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch));
}
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIPrefLocalizedString> pls;
rv = prefBranch->GetComplexValue(kMAILNEWS_VIEW_DEFAULT_CHARSET,
NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(pls));
if (NS_SUCCEEDED(rv))
{
nsString ucsval;
pls->ToString(getter_Copies(ucsval));
if (!ucsval.IsEmpty())
{
if (!gDefaultCharacterSet)
gDefaultCharacterSet = new nsCString;
if (gDefaultCharacterSet)
CopyUTF16toUTF8(ucsval, *gDefaultCharacterSet);
}
}
rv = prefBranch->GetBoolPref(kMAILNEWS_DEFAULT_CHARSET_OVERRIDE, &gDefaultCharacterOverride);
gFolderCharsetObserver = new nsFolderCharsetObserver();
NS_ASSERTION(gFolderCharsetObserver, "failed to create observer");
// register prefs callbacks
if (gFolderCharsetObserver)
{
NS_ADDREF(gFolderCharsetObserver);
rv = prefBranch->AddObserver(kMAILNEWS_VIEW_DEFAULT_CHARSET, gFolderCharsetObserver, false);
rv = prefBranch->AddObserver(kMAILNEWS_DEFAULT_CHARSET_OVERRIDE, gFolderCharsetObserver, false);
// also register for shutdown
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService)
{
rv = observerService->AddObserver(gFolderCharsetObserver, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
}
}
}
}
m_mdb = mdb;
if (mdb)
{
mdb_err err;
// mdb->AddRef();
err = m_mdb->GetStore()->StringToToken(mdb->GetEnv(), kDBFolderInfoScope, &m_rowScopeToken);
if (NS_SUCCEEDED(err))
{
err = m_mdb->GetStore()->StringToToken(mdb->GetEnv(), kDBFolderInfoTableKind, &m_tableKindToken);
if (NS_SUCCEEDED(err))
{
gDBFolderInfoOID.mOid_Scope = m_rowScopeToken;
gDBFolderInfoOID.mOid_Id = 1;
}
}
InitMDBInfo();
}
}
nsresult nsMsgI18NConvertFromUnicode(const char* aCharset,
const nsString& inString,
nsACString& outString,
bool aIsCharsetCanonical)
{
if (inString.IsEmpty()) {
outString.Truncate();
return NS_OK;
}
// Note: this will hide a possible error when the unicode text may contain more than one charset.
// (e.g. Latin1 + Japanese). Use nsMsgI18NSaveAsCharset instead to avoid that problem.
else if (!*aCharset || !PL_strcasecmp(aCharset, "us-ascii") ||
!PL_strcasecmp(aCharset, "ISO-8859-1")) {
LossyCopyUTF16toASCII(inString, outString);
return NS_OK;
}
else if (!PL_strcasecmp(aCharset, "UTF-8")) {
CopyUTF16toUTF8(inString, outString);
return NS_OK;
}
nsresult rv;
nsCOMPtr <nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsIUnicodeEncoder> encoder;
// get an unicode converter
if (aIsCharsetCanonical) // optimize for modified UTF-7 used by IMAP
rv = ccm->GetUnicodeEncoderRaw(aCharset, getter_AddRefs(encoder));
else
rv = ccm->GetUnicodeEncoder(aCharset, getter_AddRefs(encoder));
NS_ENSURE_SUCCESS(rv, rv);
rv = encoder->SetOutputErrorBehavior(nsIUnicodeEncoder::kOnError_Replace, nullptr, '?');
NS_ENSURE_SUCCESS(rv, rv);
const char16_t *originalSrcPtr = inString.get();
const char16_t *currentSrcPtr = originalSrcPtr;
int32_t originalUnicharLength = inString.Length();
int32_t srcLength;
int32_t dstLength;
char localbuf[512];
int32_t consumedLen = 0;
outString.Truncate();
// convert
while (consumedLen < originalUnicharLength) {
srcLength = originalUnicharLength - consumedLen;
dstLength = 512;
rv = encoder->Convert(currentSrcPtr, &srcLength, localbuf, &dstLength);
if (NS_FAILED(rv) || dstLength == 0)
break;
outString.Append(localbuf, dstLength);
currentSrcPtr += srcLength;
consumedLen = currentSrcPtr - originalSrcPtr; // src length used so far
}
rv = encoder->Finish(localbuf, &dstLength);
if (NS_SUCCEEDED(rv))
outString.Append(localbuf, dstLength);
return rv;
}
void
nsSuiteDirectoryProvider::AppendDistroSearchDirs(nsIProperties* aDirSvc,
nsCOMArray<nsIFile> &array)
{
nsCOMPtr<nsIFile> searchPlugins;
nsresult rv = aDirSvc->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
NS_GET_IID(nsIFile),
getter_AddRefs(searchPlugins));
if (NS_FAILED(rv))
return;
searchPlugins->AppendNative(NS_LITERAL_CSTRING("distribution"));
searchPlugins->AppendNative(NS_LITERAL_CSTRING("searchplugins"));
bool exists;
rv = searchPlugins->Exists(&exists);
if (NS_FAILED(rv) || !exists)
return;
nsCOMPtr<nsIFile> commonPlugins;
rv = searchPlugins->Clone(getter_AddRefs(commonPlugins));
if (NS_SUCCEEDED(rv)) {
commonPlugins->AppendNative(NS_LITERAL_CSTRING("common"));
rv = commonPlugins->Exists(&exists);
if (NS_SUCCEEDED(rv) && exists)
array.AppendObject(commonPlugins);
}
nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (prefs) {
nsCOMPtr<nsIFile> localePlugins;
rv = searchPlugins->Clone(getter_AddRefs(localePlugins));
if (NS_FAILED(rv))
return;
localePlugins->AppendNative(NS_LITERAL_CSTRING("locale"));
nsCString locale;
nsCOMPtr<nsIPrefLocalizedString> prefString;
rv = prefs->GetComplexValue("general.useragent.locale",
NS_GET_IID(nsIPrefLocalizedString),
getter_AddRefs(prefString));
if (NS_SUCCEEDED(rv)) {
nsAutoString wLocale;
prefString->GetData(getter_Copies(wLocale));
CopyUTF16toUTF8(wLocale, locale);
} else {
rv = prefs->GetCharPref("general.useragent.locale", getter_Copies(locale));
}
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIFile> curLocalePlugins;
rv = localePlugins->Clone(getter_AddRefs(curLocalePlugins));
if (NS_SUCCEEDED(rv)) {
curLocalePlugins->AppendNative(locale);
rv = curLocalePlugins->Exists(&exists);
if (NS_SUCCEEDED(rv) && exists) {
array.AppendObject(curLocalePlugins);
return; // all done
}
}
}
// we didn't append the locale dir - try the default one
nsCString defLocale;
rv = prefs->GetCharPref("distribution.searchplugins.defaultLocale",
getter_Copies(defLocale));
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIFile> defLocalePlugins;
rv = localePlugins->Clone(getter_AddRefs(defLocalePlugins));
if (NS_SUCCEEDED(rv)) {
defLocalePlugins->AppendNative(defLocale);
rv = defLocalePlugins->Exists(&exists);
if (NS_SUCCEEDED(rv) && exists)
array.AppendObject(defLocalePlugins);
}
}
}
}
nsresult nsMsgI18NConvertFromUnicode(const char* aCharset,
const nsString& inString,
nsACString& outString,
bool aIsCharsetCanonical,
bool aReportUencNoMapping)
{
if (inString.IsEmpty()) {
outString.Truncate();
return NS_OK;
}
// Note: This will hide a possible error if the Unicode contains more than one
// charset, e.g. Latin1 + Japanese.
else if (!aReportUencNoMapping && (!*aCharset ||
!PL_strcasecmp(aCharset, "us-ascii") ||
!PL_strcasecmp(aCharset, "ISO-8859-1"))) {
LossyCopyUTF16toASCII(inString, outString);
return NS_OK;
}
else if (!PL_strcasecmp(aCharset, "UTF-8")) {
CopyUTF16toUTF8(inString, outString);
return NS_OK;
}
nsresult rv;
nsCOMPtr <nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsIUnicodeEncoder> encoder;
// get an unicode converter
if (aIsCharsetCanonical) // optimize for modified UTF-7 used by IMAP
rv = ccm->GetUnicodeEncoderRaw(aCharset, getter_AddRefs(encoder));
else
rv = ccm->GetUnicodeEncoder(aCharset, getter_AddRefs(encoder));
NS_ENSURE_SUCCESS(rv, rv);
// Must set behavior to kOnError_Signal if we want to receive the
// NS_ERROR_UENC_NOMAPPING signal, should it occur.
int32_t behavior = aReportUencNoMapping ? nsIUnicodeEncoder::kOnError_Signal:
nsIUnicodeEncoder::kOnError_Replace;
rv = encoder->SetOutputErrorBehavior(behavior, nullptr, '?');
NS_ENSURE_SUCCESS(rv, rv);
const char16_t *originalSrcPtr = inString.get();
const char16_t *currentSrcPtr = originalSrcPtr;
int32_t originalUnicharLength = inString.Length();
int32_t srcLength;
int32_t dstLength;
char localbuf[512+10]; // We have seen cases were the buffer was overrun
// by two (!!) bytes (Bug 1255863).
// So give it ten bytes more for now to avoid a crash.
int32_t consumedLen = 0;
bool mappingFailure = false;
outString.Truncate();
// convert
while (consumedLen < originalUnicharLength) {
srcLength = originalUnicharLength - consumedLen;
dstLength = 512;
rv = encoder->Convert(currentSrcPtr, &srcLength, localbuf, &dstLength);
#ifdef DEBUG
if (dstLength > 512) {
char warning[100];
sprintf(warning, "encoder->Convert() returned %d bytes. Limit = 512", dstLength);
NS_WARNING(warning);
}
#endif
if (rv == NS_ERROR_UENC_NOMAPPING) {
mappingFailure = true;
}
if (NS_FAILED(rv) || dstLength == 0)
break;
outString.Append(localbuf, dstLength);
currentSrcPtr += srcLength;
consumedLen = currentSrcPtr - originalSrcPtr; // src length used so far
}
dstLength = 512; // Reset available buffer size.
rv = encoder->Finish(localbuf, &dstLength);
if (NS_SUCCEEDED(rv)) {
if (dstLength)
outString.Append(localbuf, dstLength);
return !mappingFailure ? rv: NS_ERROR_UENC_NOMAPPING;
}
return rv;
}
NS_IMETHODIMP
sbStringTransformImpl::NormalizeString(const nsAString & aCharset,
PRUint32 aTransformFlags,
const nsAString & aInput,
nsAString & _retval)
{
nsCString str;
CopyUTF16toUTF8(aInput, str);
if(aTransformFlags & sbIStringTransform::TRANSFORM_LOWERCASE) {
gchar* lowercaseStr = g_utf8_strdown(str.BeginReading(), str.Length());
NS_ENSURE_TRUE(lowercaseStr, NS_ERROR_OUT_OF_MEMORY);
str.Assign(lowercaseStr);
g_free(lowercaseStr);
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_UPPERCASE) {
gchar* uppercaseStr = g_utf8_strup(str.BeginReading(), str.Length());
NS_ENSURE_TRUE(uppercaseStr, NS_ERROR_OUT_OF_MEMORY);
str.Assign(uppercaseStr);
g_free(uppercaseStr);
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONSPACE) {
nsString workingStr;
bool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
bool bypassTest = PR_FALSE;
gchar* nonspaceStr = g_utf8_normalize(str.BeginReading(),
str.Length(),
G_NORMALIZE_ALL);
NS_ENSURE_TRUE(nonspaceStr, NS_ERROR_OUT_OF_MEMORY);
glong strLen = g_utf8_strlen(nonspaceStr, -1);
for(glong currentChar = 0; currentChar < strLen; ++currentChar) {
gchar* offset = g_utf8_offset_to_pointer(nonspaceStr, currentChar);
gunichar unichar = g_utf8_get_char(offset);
GUnicodeType unicharType = g_unichar_type(unichar);
if(bypassTest ||
(unicharType != G_UNICODE_NON_SPACING_MARK &&
unicharType != G_UNICODE_COMBINING_MARK &&
unicharType != G_UNICODE_ENCLOSING_MARK)) {
workingStr += unichar;
if(leadingOnly)
bypassTest = PR_TRUE;
}
}
g_free(nonspaceStr);
CopyUTF16toUTF8(workingStr, str);
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_SYMBOLS) {
nsString workingStr;
bool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
bool bypassTest = PR_FALSE;
gchar* nosymbolsStr = g_utf8_normalize(str.BeginReading(),
str.Length(),
G_NORMALIZE_ALL);
NS_ENSURE_TRUE(nosymbolsStr, NS_ERROR_OUT_OF_MEMORY);
glong strLen = g_utf8_strlen(nosymbolsStr, -1);
for(glong currentChar = 0; currentChar < strLen; ++currentChar) {
gchar* offset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar);
gunichar unichar = g_utf8_get_char(offset);
GUnicodeType unicharType = g_unichar_type(unichar);
if (aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_KEEPNUMBERSYMBOLS) {
PRInt32 numberLength;
SB_ExtractLeadingNumber((const gchar *)offset, NULL, NULL, &numberLength);
if (numberLength > 0) {
for (glong copychar=0;copychar < numberLength;copychar++) {
gchar* copyoffset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar+copychar);
gunichar unichar = g_utf8_get_char(copyoffset);
workingStr += unichar;
}
currentChar += numberLength-1;
if(leadingOnly)
bypassTest = PR_TRUE;
continue;
}
}
if(bypassTest ||
(unicharType != G_UNICODE_CURRENCY_SYMBOL &&
unicharType != G_UNICODE_MODIFIER_SYMBOL &&
unicharType != G_UNICODE_MATH_SYMBOL &&
unicharType != G_UNICODE_OTHER_SYMBOL)) {
workingStr += unichar;
if(leadingOnly)
bypassTest = PR_TRUE;
}
}
g_free(nosymbolsStr);
CopyUTF16toUTF8(workingStr, str);
}
if((aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM) ||
(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM_IGNORE_SPACE)) {
nsString workingStr;
bool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
bool bypassTest = PR_FALSE;
gchar* nosymbolsStr = g_utf8_normalize(str.BeginReading(),
str.Length(),
G_NORMALIZE_ALL);
NS_ENSURE_TRUE(nosymbolsStr, NS_ERROR_OUT_OF_MEMORY);
glong strLen = g_utf8_strlen(nosymbolsStr, -1);
for(glong currentChar = 0; currentChar < strLen; ++currentChar) {
gchar* offset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar);
gunichar unichar = g_utf8_get_char(offset);
GUnicodeType unicharType = g_unichar_type(unichar);
if (aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_KEEPNUMBERSYMBOLS) {
PRInt32 numberLength;
SB_ExtractLeadingNumber((const gchar *)offset, NULL, NULL, &numberLength);
if (numberLength > 0) {
for (glong copychar=0;copychar < numberLength;copychar++) {
gchar* copyoffset = g_utf8_offset_to_pointer(nosymbolsStr, currentChar+copychar);
gunichar unichar = g_utf8_get_char(copyoffset);
workingStr += unichar;
}
currentChar += numberLength-1;
if(leadingOnly)
bypassTest = PR_TRUE;
continue;
}
}
if(bypassTest ||
(unicharType == G_UNICODE_LOWERCASE_LETTER ||
unicharType == G_UNICODE_MODIFIER_LETTER ||
unicharType == G_UNICODE_OTHER_LETTER ||
unicharType == G_UNICODE_TITLECASE_LETTER ||
unicharType == G_UNICODE_UPPERCASE_LETTER ||
unicharType == G_UNICODE_DECIMAL_NUMBER ||
unicharType == G_UNICODE_LETTER_NUMBER ||
unicharType == G_UNICODE_OTHER_NUMBER) ||
(!(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM_IGNORE_SPACE) &&
unichar == ' ')) {
workingStr += unichar;
if(leadingOnly)
bypassTest = PR_TRUE;
}
}
g_free(nosymbolsStr);
CopyUTF16toUTF8(workingStr, str);
}
CopyUTF8toUTF16(str, _retval);
return NS_OK;
}
void
FileReader::ReadFileContent(Blob& aBlob,
const nsAString &aCharset,
eDataFormat aDataFormat,
ErrorResult& aRv)
{
//Implicit abort to clear any other activity going on
ErrorResult error;
Abort(error);
error.SuppressException();
if (mReadyState == LOADING) {
// A nested ReadAsSomething() as been called during one of the events
// dispatched by Abort(). We have to terminate this operation in order to
// continue the nested one.
aRv.Throw(NS_ERROR_ABORT);
return;
}
mError = nullptr;
SetDOMStringToNull(mResult);
mTransferred = 0;
mTotal = 0;
mReadyState = EMPTY;
FreeFileData();
mBlob = &aBlob;
mDataFormat = aDataFormat;
CopyUTF16toUTF8(aCharset, mCharset);
nsresult rv;
nsCOMPtr<nsIStreamTransportService> sts =
do_GetService(kStreamTransportServiceCID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
aRv.Throw(rv);
return;
}
nsCOMPtr<nsIInputStream> stream;
mBlob->GetInternalStream(getter_AddRefs(stream), aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
nsCOMPtr<nsITransport> transport;
aRv = sts->CreateInputTransport(stream,
/* aStartOffset */ 0,
/* aReadLimit */ -1,
/* aCloseWhenDone */ true,
getter_AddRefs(transport));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
nsCOMPtr<nsIInputStream> wrapper;
aRv = transport->OpenInputStream(/* aFlags */ 0,
/* aSegmentSize */ 0,
/* aSegmentCount */ 0,
getter_AddRefs(wrapper));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
MOZ_ASSERT(!mAsyncStream);
mAsyncStream = do_QueryInterface(wrapper);
MOZ_ASSERT(mAsyncStream);
mTotal = mBlob->GetSize(aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
aRv = DoAsyncWait();
if (NS_WARN_IF(aRv.Failed())) {
return;
}
//FileReader should be in loading state here
mReadyState = LOADING;
DispatchProgressEvent(NS_LITERAL_STRING(LOADSTART_STR));
if (mDataFormat == FILE_AS_ARRAYBUFFER) {
mFileData = js_pod_malloc<char>(mTotal);
if (!mFileData) {
NS_WARNING("Preallocation failed for ReadFileData");
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
}
}
}
