NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineDirForHost(const char *serverKey,
nsString &result)
{
PR_EnterMonitor(gCachedHostInfoMonitor);
nsIMAPHostInfo *host = FindHost(serverKey);
if (host)
CopyASCIItoUTF16(host->fOnlineDir, result);
PR_ExitMonitor(gCachedHostInfoMonitor);
return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
}
void
URL::GetProtocol(nsString& aProtocol) const
{
nsCString protocol;
if (NS_SUCCEEDED(mURI->GetScheme(protocol))) {
aProtocol.Truncate();
}
CopyASCIItoUTF16(protocol, aProtocol);
aProtocol.Append(PRUnichar(':'));
}
NS_IMETHODIMP
inFlasher::GetColor(nsAString& aColor)
{
// Copied from nsGenericHTMLElement::ColorToString()
char buf[10];
PR_snprintf(buf, sizeof(buf), "#%02x%02x%02x",
NS_GET_R(mColor), NS_GET_G(mColor), NS_GET_B(mColor));
CopyASCIItoUTF16(buf, aColor);
return NS_OK;
}
void
URLMainThread::GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const
{
nsAutoCString protocol;
if (NS_SUCCEEDED(mURI->GetScheme(protocol))) {
aProtocol.Truncate();
}
CopyASCIItoUTF16(protocol, aProtocol);
aProtocol.Append(char16_t(':'));
}
nsresult
nsPosixLocale::GetXPLocale(const char* posixLocale, nsAString& locale)
{
char country_code[MAX_COUNTRY_CODE_LEN+1];
char lang_code[MAX_LANGUAGE_CODE_LEN+1];
char extra[MAX_EXTRA_LEN+1];
char posix_locale[MAX_LOCALE_LEN+1];
if (posixLocale!=nsnull) {
if (strcmp(posixLocale,"C")==0 || strcmp(posixLocale,"POSIX")==0) {
locale.AssignLiteral("en-US");
return NS_OK;
}
if (!ParseLocaleString(posixLocale,lang_code,country_code,extra,'_')) {
// * locale = "x-user-defined";
// use posix if parse failed
CopyASCIItoUTF16(nsDependentCString(posixLocale), locale);
return NS_OK;
}
// Special case: substitute "nb" (Norwegian Bokmal) for macrolanguage
// code "no" (Norwegian)
if (nsDependentCString(lang_code).LowerCaseEqualsLiteral("no")) {
lang_code[1] = 'b';
}
if (*country_code) {
PR_snprintf(posix_locale,sizeof(posix_locale),"%s-%s",lang_code,country_code);
}
else {
PR_snprintf(posix_locale,sizeof(posix_locale),"%s",lang_code);
}
CopyASCIItoUTF16(nsDependentCString(posix_locale), locale);
return NS_OK;
}
return NS_ERROR_FAILURE;
}
void
IDBIndex::GetLocale(nsString& aLocale) const
{
AssertIsOnOwningThread();
MOZ_ASSERT(mMetadata);
if (mMetadata->locale().IsEmpty()) {
SetDOMStringToNull(aLocale);
} else {
CopyASCIItoUTF16(mMetadata->locale(), aLocale);
}
}
void
WebGLShader::GetShaderTranslatedSource(nsAString* out) const
{
if (!mCompilationSuccessful) {
mContext->ErrorInvalidOperation("getShaderTranslatedSource: Shader has"
" not been successfully compiled.");
return;
}
out->SetIsVoid(false);
CopyASCIItoUTF16(mTranslatedSource, *out);
}
NS_IMETHODIMP
nsLocation::GetHash(nsAString& aHash)
{
if (!CallerSubsumes())
return NS_ERROR_DOM_SECURITY_ERR;
aHash.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult rv = GetURI(getter_AddRefs(uri));
if (NS_FAILED(rv) || !uri) {
return rv;
}
nsAutoCString ref;
nsAutoString unicodeRef;
rv = uri->GetRef(ref);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsITextToSubURI> textToSubURI(
do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
nsAutoCString charset;
uri->GetOriginCharset(charset);
rv = textToSubURI->UnEscapeURIForUI(charset, ref, unicodeRef);
}
if (NS_FAILED(rv)) {
// Oh, well. No intl here!
NS_UnescapeURL(ref);
CopyASCIItoUTF16(ref, unicodeRef);
rv = NS_OK;
}
}
if (NS_SUCCEEDED(rv) && !unicodeRef.IsEmpty()) {
aHash.Assign(PRUnichar('#'));
aHash.Append(unicodeRef);
}
if (aHash == mCachedHash) {
// Work around ShareThis stupidly polling location.hash every
// 5ms all the time by handing out the same exact string buffer
// we handed out last time.
aHash = mCachedHash;
} else {
mCachedHash = aHash;
}
return rv;
}
// XXX : aTryLocaleCharset is not yet effective.
nsresult
nsMIMEHeaderParamImpl::DoGetParameter(const nsACString& aHeaderVal,
const char *aParamName,
ParamDecoding aDecoding,
const nsACString& aFallbackCharset,
bool aTryLocaleCharset,
char **aLang, nsAString& aResult)
{
aResult.Truncate();
nsresult rv;
// get parameter (decode RFC 2231/5987 when applicable, as specified by
// aDecoding (5987 being a subset of 2231) and return charset.)
nsXPIDLCString med;
nsXPIDLCString charset;
rv = DoParameterInternal(PromiseFlatCString(aHeaderVal).get(), aParamName,
aDecoding, getter_Copies(charset), aLang,
getter_Copies(med));
if (NS_FAILED(rv))
return rv;
// convert to UTF-8 after charset conversion and RFC 2047 decoding
// if necessary.
nsCAutoString str1;
rv = DecodeParameter(med, charset.get(), nullptr, false, str1);
NS_ENSURE_SUCCESS(rv, rv);
if (!aFallbackCharset.IsEmpty())
{
nsCAutoString str2;
nsCOMPtr<nsIUTF8ConverterService>
cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
if (cvtUTF8 &&
NS_SUCCEEDED(cvtUTF8->ConvertStringToUTF8(str1,
PromiseFlatCString(aFallbackCharset).get(), false, true,
1, str2))) {
CopyUTF8toUTF16(str2, aResult);
return NS_OK;
}
}
if (IsUTF8(str1)) {
CopyUTF8toUTF16(str1, aResult);
return NS_OK;
}
if (aTryLocaleCharset && !NS_IsNativeUTF8())
return NS_CopyNativeToUnicode(str1, aResult);
CopyASCIItoUTF16(str1, aResult);
return NS_OK;
}
nsresult nsTextToSubURI::convertURItoUnicode(const nsAFlatCString &aCharset,
const nsAFlatCString &aURI,
bool aIRI,
nsAString &_retval)
{
nsresult rv = NS_OK;
// check for 7bit encoding the data may not be ASCII after we decode
bool isStatefulCharset = statefulCharset(aCharset.get());
if (!isStatefulCharset && IsASCII(aURI)) {
CopyASCIItoUTF16(aURI, _retval);
return rv;
}
if (!isStatefulCharset && aIRI) {
if (IsUTF8(aURI)) {
CopyUTF8toUTF16(aURI, _retval);
return rv;
}
}
// empty charset could indicate UTF-8, but aURI turns out not to be UTF-8.
NS_ENSURE_FALSE(aCharset.IsEmpty(), NS_ERROR_INVALID_ARG);
nsCOMPtr<nsICharsetConverterManager> charsetConverterManager;
charsetConverterManager = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIUnicodeDecoder> unicodeDecoder;
rv = charsetConverterManager->GetUnicodeDecoder(aCharset.get(),
getter_AddRefs(unicodeDecoder));
NS_ENSURE_SUCCESS(rv, rv);
unicodeDecoder->SetInputErrorBehavior(nsIUnicodeDecoder::kOnError_Signal);
int32_t srcLen = aURI.Length();
int32_t dstLen;
rv = unicodeDecoder->GetMaxLength(aURI.get(), srcLen, &dstLen);
NS_ENSURE_SUCCESS(rv, rv);
char16_t *ustr = (char16_t *) NS_Alloc(dstLen * sizeof(char16_t));
NS_ENSURE_TRUE(ustr, NS_ERROR_OUT_OF_MEMORY);
rv = unicodeDecoder->Convert(aURI.get(), &srcLen, ustr, &dstLen);
if (NS_SUCCEEDED(rv))
_retval.Assign(ustr, dstLen);
NS_Free(ustr);
return rv;
}
nsresult
Dashboard::GetWebSocketConnections()
{
JSContext* cx = nsContentUtils::GetSafeJSContext();
JSAutoRequest request(cx);
mozilla::dom::WebSocketDict dict;
dict.mEncrypted.Construct();
dict.mHostport.Construct();
dict.mMsgreceived.Construct();
dict.mMsgsent.Construct();
dict.mReceivedsize.Construct();
dict.mSentsize.Construct();
Sequence<bool> &encrypted = dict.mEncrypted.Value();
Sequence<nsString> &hostport = dict.mHostport.Value();
Sequence<uint32_t> &received = dict.mMsgreceived.Value();
Sequence<uint32_t> &sent = dict.mMsgsent.Value();
Sequence<double> &receivedSize = dict.mReceivedsize.Value();
Sequence<double> &sentSize = dict.mSentsize.Value();
uint32_t length = mWs.data.Length();
if (!encrypted.SetCapacity(length) || !hostport.SetCapacity(length) ||
!received.SetCapacity(length) || !sent.SetCapacity(length) ||
!receivedSize.SetCapacity(length) || !sentSize.SetCapacity(length)) {
mWs.cb = nullptr;
mWs.data.Clear();
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
mozilla::MutexAutoLock lock(mWs.lock);
for (uint32_t i = 0; i < mWs.data.Length(); i++) {
CopyASCIItoUTF16(mWs.data[i].mHost, *hostport.AppendElement());
*sent.AppendElement() = mWs.data[i].mMsgSent;
*received.AppendElement() = mWs.data[i].mMsgReceived;
*receivedSize.AppendElement() = mWs.data[i].mSizeSent;
*sentSize.AppendElement() = mWs.data[i].mSizeReceived;
*encrypted.AppendElement() = mWs.data[i].mEncrypted;
}
JS::Value val;
if (!dict.ToObject(cx, JS::NullPtr(), &val)) {
mWs.cb = nullptr;
mWs.data.Clear();
return NS_ERROR_FAILURE;
}
mWs.cb->OnDashboardDataAvailable(val);
mWs.cb = nullptr;
return NS_OK;
}
// XXX : aTryLocaleCharset is not yet effective.
NS_IMETHODIMP
nsMIMEHeaderParamImpl::GetParameter(const nsACString& aHeaderVal,
const char *aParamName,
const nsACString& aFallbackCharset,
PRBool aTryLocaleCharset,
char **aLang, nsAString& aResult)
{
aResult.Truncate();
nsresult rv;
// get parameter (decode RFC 2231 if it's RFC 2231-encoded and
// return charset.)
nsXPIDLCString med;
nsXPIDLCString charset;
rv = GetParameterInternal(PromiseFlatCString(aHeaderVal).get(), aParamName,
getter_Copies(charset), aLang, getter_Copies(med));
if (NS_FAILED(rv))
return rv;
// convert to UTF-8 after charset conversion and RFC 2047 decoding
// if necessary.
nsCAutoString str1;
rv = DecodeParameter(med, charset.get(), nsnull, PR_FALSE, str1);
NS_ENSURE_SUCCESS(rv, rv);
if (!aFallbackCharset.IsEmpty())
{
nsCAutoString str2;
nsCOMPtr<nsIUTF8ConverterService>
cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
if (cvtUTF8 &&
NS_SUCCEEDED(cvtUTF8->ConvertStringToUTF8(str1,
PromiseFlatCString(aFallbackCharset).get(), PR_FALSE, str2))) {
CopyUTF8toUTF16(str2, aResult);
return NS_OK;
}
}
if (IsUTF8(str1)) {
CopyUTF8toUTF16(str1, aResult);
return NS_OK;
}
if (aTryLocaleCharset && !NS_IsNativeUTF8())
return NS_CopyNativeToUnicode(str1, aResult);
CopyASCIItoUTF16(str1, aResult);
return NS_OK;
}
void
Link::GetUsername(nsAString& aUsername, ErrorResult& aError)
{
aUsername.Truncate();
nsCOMPtr<nsIURI> uri(GetURI());
if (!uri) {
return;
}
nsAutoCString username;
uri->GetUsername(username);
CopyASCIItoUTF16(username, aUsername);
}
void
Link::GetPassword(nsAString &aPassword, ErrorResult& aError)
{
aPassword.Truncate();
nsCOMPtr<nsIURI> uri(GetURI());
if (!uri) {
return;
}
nsAutoCString password;
uri->GetPassword(password);
CopyASCIItoUTF16(password, aPassword);
}
nsresult
Link::GetProtocol(nsAString &_protocol)
{
nsCOMPtr<nsIURI> uri(GetURI());
if (!uri) {
_protocol.AssignLiteral("http");
}
else {
nsAutoCString scheme;
(void)uri->GetScheme(scheme);
CopyASCIItoUTF16(scheme, _protocol);
}
_protocol.Append(PRUnichar(':'));
return NS_OK;
}
nsresult
DOMFileImplBase::GetInternalUrl(nsIPrincipal* aPrincipal, nsAString& aURL)
{
NS_ENSURE_STATE(aPrincipal);
nsCString url;
nsresult rv = nsBlobProtocolHandler::AddDataEntry(
NS_LITERAL_CSTRING(BLOBURI_SCHEME), this, aPrincipal, url);
if (NS_FAILED(rv)) {
return rv;
}
CopyASCIItoUTF16(url, aURL);
return NS_OK;
}
void
Link::GetProtocol(nsAString &_protocol, ErrorResult& aError)
{
nsCOMPtr<nsIURI> uri(GetURI());
if (!uri) {
_protocol.AssignLiteral("http");
}
else {
nsAutoCString scheme;
(void)uri->GetScheme(scheme);
CopyASCIItoUTF16(scheme, _protocol);
}
_protocol.Append(char16_t(':'));
return;
}
NS_IMETHODIMP
Navigator::GetAppCodeName(nsAString& aAppCodeName)
{
nsresult rv;
nsCOMPtr<nsIHttpProtocolHandler>
service(do_GetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "http", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString appName;
rv = service->GetAppName(appName);
CopyASCIItoUTF16(appName, aAppCodeName);
return rv;
}
NS_IMETHODIMP
Navigator::GetProduct(nsAString& aProduct)
{
nsresult rv;
nsCOMPtr<nsIHttpProtocolHandler>
service(do_GetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "http", &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString product;
rv = service->GetProduct(product);
CopyASCIItoUTF16(product, aProduct);
return rv;
}
nsresult
nsMsgAttachmentHandler::LoadDataFromFile(nsILocalFile *file, nsString &sigData, bool charsetConversion)
{
PRInt32 readSize;
char *readBuf;
nsCOMPtr <nsIInputStream> inputFile;
nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), file);
if (NS_FAILED(rv))
return NS_MSG_ERROR_WRITING_FILE;
PRInt64 fileSize;
file->GetFileSize(&fileSize);
readSize = (PRUint32) fileSize;
readBuf = (char *)PR_Malloc(readSize + 1);
if (!readBuf)
return NS_ERROR_OUT_OF_MEMORY;
memset(readBuf, 0, readSize + 1);
PRUint32 bytesRead;
inputFile->Read(readBuf, readSize, &bytesRead);
inputFile->Close();
nsDependentCString cstringReadBuf(readBuf, bytesRead);
if (charsetConversion)
{
if (NS_FAILED(ConvertToUnicode(m_charset.get(), cstringReadBuf, sigData)))
CopyASCIItoUTF16(cstringReadBuf, sigData);
}
else
CopyASCIItoUTF16(cstringReadBuf, sigData);
PR_FREEIF(readBuf);
return NS_OK;
}
nsresult
CryptoBuffer::ToJwkBase64(nsString& aBase64) const
{
// Shortcut for the empty octet string
if (Length() == 0) {
aBase64.Truncate();
return NS_OK;
}
nsAutoCString base64;
nsresult rv = Base64URLEncode(Length(), Elements(),
Base64URLEncodePaddingPolicy::Omit, base64);
NS_ENSURE_SUCCESS(rv, rv);
CopyASCIItoUTF16(base64, aBase64);
return NS_OK;
}
void CharacterData::GetData(nsAString& aData) const {
if (mText.Is2b()) {
aData.Truncate();
mText.AppendTo(aData);
} else {
// Must use Substring() since nsDependentCString() requires null
// terminated strings.
const char* data = mText.Get1b();
if (data) {
CopyASCIItoUTF16(Substring(data, data + mText.GetLength()), aData);
} else {
aData.Truncate();
}
}
}
nsresult
DeviceStorageRequestParent::PostBlobSuccessEvent::CancelableRun() {
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
nsString mime;
CopyASCIItoUTF16(mMimeType, mime);
nsCOMPtr<nsIDOMBlob> blob = new nsDOMFileFile(mFile->mPath, mime, mLength, mFile->mFile);
ContentParent* cp = static_cast<ContentParent*>(mParent->Manager());
BlobParent* actor = cp->GetOrCreateActorForBlob(blob);
BlobResponse response;
response.blobParent() = actor;
unused << mParent->Send__delete__(mParent, response);
return NS_OK;
}
void nsEudoraWin32::GetAccountName( const char *pSection, nsString& str)
{
str.Truncate();
nsCString s(pSection);
if (s.LowerCaseEqualsLiteral("settings"))
{
str.AssignLiteral("Eudora ");
str.Append(NS_ConvertASCIItoUTF16(pSection));
}
else
{
str.AssignASCII(pSection);
if (StringBeginsWith(s, NS_LITERAL_CSTRING("persona-"), nsCaseInsensitiveCStringComparator()))
CopyASCIItoUTF16(Substring(s, 8), str);
}
}
// Returns NULL if there is no personal namespace on the given host
NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineInboxPathForHost(const char *serverKey, nsString &result)
{
PR_EnterMonitor(gCachedHostInfoMonitor);
nsIMAPHostInfo *host = FindHost(serverKey);
if (host)
{
nsIMAPNamespace *ns = NULL;
ns = host->fNamespaceList->GetDefaultNamespaceOfType(kPersonalNamespace);
if (ns)
{
CopyASCIItoUTF16(nsDependentCString(ns->GetPrefix()), result);
result.AppendLiteral("INBOX");
}
}
else
result.Truncate();
PR_ExitMonitor(gCachedHostInfoMonitor);
return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
}
NS_IMETHODIMP
nsMacLocale::GetXPLocale(short scriptCode, short langCode, short regionCode, nsAString& locale)
{
int i;
bool validResultFound = false;
locale.Truncate();
//
// parse language
//
for(i=0;lang_list[i].iso_code;i++) {
if (langCode==lang_list[i].mac_lang_code && scriptCode==lang_list[i].mac_script_code) {
CopyASCIItoUTF16(nsDependentCString(lang_list[i].iso_code), locale);
validResultFound = true;
break;
}
}
if (!validResultFound) {
return NS_ERROR_FAILURE;
}
//
// parse region
//
for(i=0;country_list[i].iso_code;i++) {
if (regionCode==country_list[i].mac_region_code) {
locale.Append(PRUnichar('-'));
AppendASCIItoUTF16(country_list[i].iso_code, locale);
validResultFound = true;
break;
}
}
if (validResultFound) {
return NS_OK;
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsLocation::GetHash(nsAString& aHash)
{
aHash.SetLength(0);
nsCOMPtr<nsIURI> uri;
nsresult rv = GetURI(getter_AddRefs(uri));
nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
if (url) {
nsCAutoString ref;
nsAutoString unicodeRef;
rv = url->GetRef(ref);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsITextToSubURI> textToSubURI(
do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
nsCAutoString charset;
url->GetOriginCharset(charset);
rv = textToSubURI->UnEscapeURIForUI(charset, ref, unicodeRef);
}
if (NS_FAILED(rv)) {
// Oh, well. No intl here!
NS_UnescapeURL(ref);
CopyASCIItoUTF16(ref, unicodeRef);
rv = NS_OK;
}
}
if (NS_SUCCEEDED(rv) && !unicodeRef.IsEmpty()) {
aHash.Assign(PRUnichar('#'));
aHash.Append(unicodeRef);
}
}
return rv;
}
NS_CStringToUTF16(const nsACString& aSrc,
nsCStringEncoding aSrcEncoding,
nsAString& aDest)
{
switch (aSrcEncoding) {
case NS_CSTRING_ENCODING_ASCII:
CopyASCIItoUTF16(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_UTF8:
CopyUTF8toUTF16(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_NATIVE_FILESYSTEM:
NS_CopyNativeToUnicode(aSrc, aDest);
break;
default:
return NS_ERROR_NOT_IMPLEMENTED;
}
return NS_OK; // XXX report errors
}
PRBool nsOEScanBoxes::ReadString( nsIInputStream * stream, nsString& str, PRUint32 offset)
{
nsresult rv;
nsCOMPtr <nsISeekableStream> seekStream = do_QueryInterface(stream, &rv);
NS_ENSURE_SUCCESS(rv, PR_FALSE);
rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, offset);
if (NS_FAILED( rv))
return( PR_FALSE);
PRUint32 cntRead;
char buffer[kOutlookExpressStringLength];
char * pReadTo = buffer;
rv = stream->Read( pReadTo, kOutlookExpressStringLength, &cntRead);
if (NS_FAILED( rv) || (cntRead != kOutlookExpressStringLength))
return( PR_FALSE);
buffer[kOutlookExpressStringLength - 1] = 0;
CopyASCIItoUTF16(buffer, str);
return( PR_TRUE);
}
void
CreateObjectURLInternal(const GlobalObject& aGlobal, T aObject,
nsAString& aResult, ErrorResult& aRv)
{
nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
if (NS_WARN_IF(!global)) {
aRv.Throw(NS_ERROR_FAILURE);
return;
}
nsCOMPtr<nsIPrincipal> principal =
nsContentUtils::ObjectPrincipal(aGlobal.Get());
nsAutoCString url;
aRv = nsHostObjectProtocolHandler::AddDataEntry(aObject, principal, url);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
global->RegisterHostObjectURI(url);
CopyASCIItoUTF16(url, aResult);
}