自学教程：C++ CopyASCIItoUTF16函数代码示例

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

voidURL::GetProtocol(nsString& aProtocol) const{  nsCString protocol;  if (NS_SUCCEEDED(mURI->GetScheme(protocol))) {    aProtocol.Truncate();  }  CopyASCIItoUTF16(protocol, aProtocol);  aProtocol.Append(PRUnichar(':'));}

NS_IMETHODIMPinFlasher::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;}

voidURLMainThread::GetProtocol(nsAString& aProtocol, ErrorResult& aRv) const{  nsAutoCString protocol;  if (NS_SUCCEEDED(mURI->GetScheme(protocol))) {    aProtocol.Truncate();  }  CopyASCIItoUTF16(protocol, aProtocol);  aProtocol.Append(char16_t(':'));}

nsresultnsPosixLocale::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;}

voidIDBIndex::GetLocale(nsString& aLocale) const{  AssertIsOnOwningThread();  MOZ_ASSERT(mMetadata);  if (mMetadata->locale().IsEmpty()) {    SetDOMStringToNull(aLocale);  } else {    CopyASCIItoUTF16(mMetadata->locale(), aLocale);  }}

voidWebGLShader::GetShaderTranslatedSource(nsAString* out) const{    if (!mCompilationSuccessful) {        mContext->ErrorInvalidOperation("getShaderTranslatedSource: Shader has"                                        " not been successfully compiled.");        return;    }    out->SetIsVoid(false);    CopyASCIItoUTF16(mTranslatedSource, *out);}

NS_IMETHODIMPnsLocation::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;}

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

voidLink::GetUsername(nsAString& aUsername, ErrorResult& aError){  aUsername.Truncate();  nsCOMPtr<nsIURI> uri(GetURI());  if (!uri) {    return;  }  nsAutoCString username;  uri->GetUsername(username);  CopyASCIItoUTF16(username, aUsername);}

nsresultLink::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;}

nsresultDOMFileImplBase::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;}

NS_IMETHODIMPNavigator::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_IMETHODIMPNavigator::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;}

nsresultnsMsgAttachmentHandler::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;}

nsresultCryptoBuffer::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();    }  }}

nsresultDeviceStorageRequestParent::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;}

// Returns NULL if there is no personal namespace on the given hostNS_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_IMETHODIMPnsMacLocale::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_IMETHODIMPnsLocation::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);}

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