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); }